Build(deps-dev): Bump @typescript-eslint/parser from 8.29.1 to 8.41.0#111
Closed
dependabot[bot] wants to merge 1 commit into
Closed
Build(deps-dev): Bump @typescript-eslint/parser from 8.29.1 to 8.41.0#111dependabot[bot] wants to merge 1 commit into
dependabot[bot] wants to merge 1 commit into
Conversation
Bumps [@typescript-eslint/parser](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/parser) from 8.29.1 to 8.41.0. - [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases) - [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/parser/CHANGELOG.md) - [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v8.41.0/packages/parser) --- updated-dependencies: - dependency-name: "@typescript-eslint/parser" dependency-version: 8.41.0 dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
Bot
added
dependencies
Contributor
Author
|
Superseded by #116. |
dependabot
Bot
deleted the
dependabot/npm_and_yarn/typescript-eslint/parser-8.41.0
branch
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
… eviction automatically (task #111) Closes the substrate's pressure-response loop for inference lanes. Before this commit the coordinator had `evict_under_pressure` but nothing called it; now the substrate's existing `PressureBroker` tier-monitoring loop fires lane eviction the same way it fires VRAM eviction on the Docker tier — automatically when global pressure crosses the configured threshold. ### What ships - `inference::coordinator::InferenceCoordinator` grows three helper methods used by the wrapper: - `config() -> &CoordinatorConfig` — read-only view - `lanes_usage_bytes() -> u64` — sum of seed KV across active lanes - `capacity_bytes() -> u64` — sum of lane-budget capacity - `lanes_snapshot() -> Vec<ResourcePoolEntry>` — one entry per lane keyed by handle_id, with size_bytes + pinned_count - `inference::coordinator_pool::CoordinatorResourcePool` — adapter wrapping `Arc<InferenceCoordinator>` and implementing `paging::pool::ResourcePool`: - `tier_name()` → "inference-lanes" (overridable via `with_tier_name` for multi-coordinator processes) - `capacity_bytes()` → coordinator's or override - `usage_bytes()` → sum of lane KV bytes - `evict_at_least(want_bytes)` → delegates to `coordinator.evict_under_pressure`, returns actual bytes freed (NOT the target — the broker reads the return value) - `snapshot()` → per-lane entries - Closure-typed clock for deterministic tests (`with_clock(|| 1_500_000)`) - `with_capacity_bytes(n)` — decouples pressure threshold from admission threshold (admission may allow 64GB lane configuration; broker should evict at 28GB host pressure) ### Doctrine alignment - Wrapper sits in `inference::` not `paging::` — the layering goes inference → paging, not the other way; the coordinator has no `paging` dependency. - [[inference-scarcity-economics]] §"commands cannot negotiate this" — the wrapper is internal substrate plumbing. Callers never see it. Pressure response is automatic once registered with the broker. - [[observability-is-half-the-architecture]] — every `evict_at_least` call surfaces through the coordinator's existing `LaneCaptureSink` (each evicted lane emits LaneEvicted with reason). The wrapper itself stays thin. ### Tests (13, all green) Pure-trait tests (no broker): - tier_name_defaults_to_canonical_constant - tier_name_override_takes_effect - capacity_bytes_sums_lane_budgets_times_bytes_per_token - usage_bytes_zero_with_no_lanes_open - usage_bytes_scales_with_open_lanes (8K + 4K → 12K) - snapshot_returns_one_entry_per_lane_with_handle_id_as_key (one Realtime + one Interactive → 2 entries, one pinned) - evict_at_least_delegates_to_coordinator_evict_under_pressure (target 1 → Hard-class Background goes, freed=32K) - evict_at_least_returns_actual_bytes_freed_not_target (target 100K, only 8K available → freed=8K) - evict_at_least_with_only_pinned_lanes_frees_zero - pressure_default_impl_returns_usage_over_capacity - pressure_is_zero_when_capacity_is_zero PressureBroker end-to-end (the substrate's pressure-relief loop calling through to coordinator): - broker_relief_evicts_through_coordinator_pool_when_pressure_high — register with real PressureBroker; pressure=2.5 (Critical); broker.relieve() acts; Hard-class lane evicted. - broker_relief_with_only_pinned_lanes_emits_zero_freed_alert — all Realtime lanes; pressure=4.0 (Critical); broker tries to evict; freed=0; report.triggered=false; all lanes survive. The pinned-realtime guarantee holds even under critical pressure — the substrate's defining promise to active voice/ video chat personas. ### What unblocks now With #109 (coordinator + eviction) + #110 (model-arch probe) + #111 (broker hookup) all landed, the substrate's pressure-driven lane lifecycle is structurally complete: ``` HOST PRESSURE RISES (broker tick observes) │ ▼ PressureBroker.relieve() → wrapper.evict_at_least(want_bytes) │ ▼ CoordinatorResourcePool delegates → coordinator.evict_under_pressure │ ▼ Walk lanes: expired → Hard → Graceful (never Pinned) │ ▼ LaneCaptureSink fires LaneEvicted per lane (with reason) │ ▼ Broker emits PressureAlert (sinks + WARN log) ``` All five steps are tested end-to-end on the heuristic adapter without any GGUFs required. ### Remaining for production wiring The AIProviderModule registration of the LlamaCppAdapter still needs: 1. Construct an InferenceCoordinator with realistic-floor defaults at module init. 2. Wrap it in CoordinatorResourcePool and register with the process-wide PressureBroker singleton. 3. Pass coordinator config's max_concurrency through to LlamaCppAdapter::with_n_seq_max() (per #110's probe-guarded safety). That's pure plumbing in `modules/ai_provider.rs::register_adapters` — next focused commit.
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
… wire (task #108, slices A+B+C) Joel (2026-05-31): %22grid inference and they%27re just the same command just executed across the wire and airc substrate delivered payloads.%22 This commit ships the substrate-side architecture for the AircRemoteInferenceAdapter — three of the five slices that make up #108 (production airc transport + peer-side handler are the two follow-up slices). ### Architecture proven The AircRemoteInferenceAdapter implements AIProviderAdapter. The caller sees: // LOCAL: heuristic adapter on this host let response = local_adapter.generate_text(request).await?; // REMOTE: same call, transport is airc let response = remote_adapter.generate_text(request).await?; No difference at the call site. Composes with everything we shipped earlier this session: the coordinator (#109) can hold a mix of local + remote handles; the rag-inspect chain (#104) works through remote adapters; the lane scheduler eviction (#111) treats remote handles the same as local; the substrate%27s defining boast — %22the Intel Mac participates as a citizen via grid offload%22 — is now structurally realizable. ### Slice A — protocol.rs (wire types) - RemoteInferenceRequest { correlation_id, text_request, target_peer? } - RemoteInferenceResponse { correlation_id, served_by, text_response } - RemoteInferenceError variants: Transport, NoPeerReachable, Timeout, CorrelationMismatch, PeerAdapterFailed, PolicyDenied - ts-rs exports to shared/generated/airc_remote/ - Pure data; no transport, no I/O ### Slice B — transport.rs (the trait + test impls) - AircInferenceTransport trait — one method, send_request (async, &self so adapter can hold Arc<dyn Transport> and concurrent-call across in-flight requests) - StubInferenceTransport — closure-driven for unit tests, with `always_failing(err)` convenience - **LocalAdapterTransport — the architecture proof.** Wraps an Arc<dyn AIProviderAdapter>; send_request unpacks the text request, calls adapter.generate_text, packages the response back into an envelope. With this transport, the remote adapter is functionally identical to calling the wrapped adapter directly — the substrate can%27t tell. ### Slice C — adapter.rs (the AIProviderAdapter impl) - AircRemoteInferenceAdapter::new(Arc<dyn AircInferenceTransport>) - .with_target_peer(peer) — pin every outgoing request to a specific peer (when substrate has reason) - AIRC_REMOTE_PROVIDER_ID = %22airc-remote%22; the adapter rewrites response.provider to this so observability sees %22this came through the grid%22 even when the actual transport was local - All trait methods implemented; future capability-discovery + health-handshake slices documented as pending ### Tests (27 new, all green) Protocol (7): - new_request_assigns_fresh_correlation_id_each_time - new_request_defaults_target_peer_to_none - with_target_peer_sets_the_field - request_serializes_and_round_trips (full serde round-trip) - error_display_is_human_readable (all 6 variants) - error_correlation_mismatch_displays_both_ids - errors_round_trip_via_serde + 3 ts-rs export bindings tests Transport (6): - stub_transport_returns_canned_response - stub_transport_can_return_typed_error - **local_adapter_transport_round_trips_via_heuristic** — THE architecture proof at the transport level - local_adapter_transport_propagates_peer_adapter_errors - local_adapter_transport_preserves_correlation_id - local_adapter_transport_with_custom_peer_id Adapter (11): - adapter_reports_canonical_provider_id - adapter_capabilities_admit_text_and_chat_not_local (is_local=false) - adapter_supports_any_model_name_by_default (peer decides) - **remote_adapter_over_local_heuristic_transport_round_trips** — THE architecture proof at the adapter level. AircRemote wrapped around LocalAdapterTransport(heuristic) produces exactly what calling heuristic directly produces. - **remote_adapter_deterministic_when_peer_is_deterministic** — replay-safety holds across the wire. Same prompt, different remote-adapter instances over different heuristic instances → byte-identical responses. - transport_error_surfaces_as_adapter_error_string - timeout_error_surfaces_with_elapsed_ms - policy_denied_surfaces_through_adapter - with_target_peer_threads_through_to_transport_envelope - without_target_peer_sends_envelope_with_none - health_check_reports_healthy_with_pending_message ### What slices A+B+C deliberately do NOT ship - **Production airc transport** (slice D) — the actual airc_lib::Airc-backed AircInferenceTransport that frames requests into airc events with correlation headers, awaits the paired response event, handles timeouts + retries. The trait shape is stable; the impl plugs in without touching the adapter or wire types. - **Peer-side handler** (slice E) — the receiving end: when a peer%27s airc daemon delivers a %22remote inference request%22 envelope, route it through the peer%27s local InferenceLlmModule (or ai/inference/generate ServiceModule) and send the response back. - **Peer discovery + capacity advertising** — open questions Q8 + Q12 in `docs/planning/AI-LANE-OPEN-QUESTIONS.md`. The substrate needs to know which peers run which models warm. - **Persona identity projection on remote peer** — open question Q9. How does Paige%27s identity flow over airc to a peer that serves her inference? Each of these is its own focused commit. The substrate-side architecture proven by this commit doesn%27t change shape when they land. ### What this unblocks NOW A contributor writing the production airc transport (slice D) has a stable trait to implement against. A contributor writing the peer-side handler (slice E) has typed wire envelopes to route. The substrate-as-grid architecture per [[the-substrate-is-the-grid-tron-frame]] is now real in code. Intel Mac + 1080 Ti + 5090 + Apple Silicon — same command, different transport, transparent to everything above the adapter trait.
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
…ask #120) ## Doctrine (Joel, 2026-06-01) > "We don't get away with singular AI's. We are just clever with > resources." Multi-persona is the floor, not a luxury. Even the lowest tier (Intel Mac discrete-Metal, CPU-only) runs Helper + Coder, sharing a base model and paging per-persona LoRAs. The substrate's `defaults_for_tier(tier)` function ALWAYS returns >= 2 templates; "singular AI" is structurally impossible. ## What ships `persona/role_template.rs`: - `RoleId` — Helper, Coder, Sentinel, Custom - `SpawnPriority` — Required (Helper), HighlyRecommended (Coder), OnRequest (Sentinel and explicit-need roles) - `ModelChoice` — model_id + gguf_file + size + quant + optional base_model_id (the lever for shared-base LoRA paging) - `ModelChoicePerTier` with a safety-floor `choose(tier)` fallback so any unmapped tier still gets the lowest known runnable choice - `IdentityDefaults` (name_pool + bio_template) — feeds the deterministic identity projection from `persona-identity-derives-from-source-id` - `CognitionDefaults` (depth_preference, voice, max_response_chars, asks_before_guessing) — Helper sits clippy-shaped (depth=20, voice="clippy", 400 chars, asks); Coder sits engineer-shaped (depth=70, voice="engineer", 4000 chars, doesn't ask) - `RoleTemplate` bundles all of the above - `helper_template()` + `coder_template()` populated concretely across the HwCapabilityTier ladder, from CpuOnly (Qwen2.5-0.5B-Instruct for Helper, DeepSeek-Coder-1.3B for Coder) up through Sm120 / M5UmaProMax (14B classes) - `defaults_for_tier(tier)` ALWAYS returns >= Helper + Coder ## Tier-shaped expectations | Tier | Helper | Coder | |----------------------------|------------------------------|------------------------------------| | CpuOnly / MacIntelMetalDsc | Qwen2.5-0.5B Q4_K_M (380 MiB)| DeepSeek-Coder-1.3B Q4_K_M (870) | | M1Uma8Gb | Qwen2.5-1.5B (1.1 GiB) | Qwen2.5-Coder-1.5B (1.1 GiB) | | M1Uma16Gb | Qwen2.5-3B (2 GiB) | Qwen2.5-Coder-3B (2 GiB) | | M3UmaProMax / Sm60 | Qwen2.5-7B (4.4 GiB) | Qwen2.5-Coder-7B (4.4 GiB) | | M5UmaProMax / Sm120 | Qwen2.5-14B (8.5 GiB) | Qwen2.5-Coder-14B (8.5 GiB) | Same role identity + cognition shape; just bigger models at higher tiers. At low tiers Helper and Coder may share a base model family (both qwen2.5-1.5b family at M1Uma8Gb, for example) — the base_model_id field is the lever a future LoRA-paging module uses to share weights. ## Tests (9 / 9 green) - `defaults_for_tier_returns_at_least_helper_and_coder_for_every_tier` — the load-bearing invariant. Every variant of HwCapabilityTier yields at least Helper + Coder. If a future refactor narrows the floor at any tier, the test screams. "No singular AI" is structural. - `helper_priority_is_required` — Helper's SpawnPriority pins the always-on contract. - `coder_priority_is_highly_recommended` — Coder shows up by default but is disable-able. - `helper_model_choice_resolves_for_every_tier` — including tiers the template doesn't cover, via the safety floor. - `coder_low_tier_targets_swiss_army_code_family` — names the acceptable model families (Qwen-Coder / DeepSeek-Coder / StarCoder), catches accidental swaps to non-code-capable models. - `helper_cognition_defaults_are_brief_and_friendly` — pins clippy DNA (depth <= 30, max_chars <= 600, asks_before_guessing, voice=clippy). - `coder_cognition_defaults_allow_depth` — pins the contrasting engineer profile (depth >= 50, max_chars >= 2000). - `model_choice_per_tier_falls_back_to_first_entry` — the safety floor stays operative. - `role_id_stable_strings` — header / kanban metadata strings pinned. ## What this enables (follow-ups, separate cards) 1. **PersonaSpawnerModule** — ever-present substrate ServiceModule that reconciles `defaults_for_tier(current_tier)` against currently-running personas. Required → always-spawned. HighlyRecommended → spawn unless explicitly opted out. 2. **Shared-base + LoRA paging** — when Helper + Coder pick the same `base_model_id` at the current tier, the substrate hosts ONE model in memory and pages LoRAs. `[[host-the-seemingly-impossible]]` in concrete form on a laptop. 3. **Hardware-probe wiring** — `HostCapabilityProbe` (already exists, task #115) reports tier; substrate spawns Helper + Coder by default; the user never sees a model selector. 4. **Bootstrap experience** — `airc init` (or continuum equivalent) on first run probes hardware, picks templates from this layer, downloads the GGUFs, spawns the personas, posts a greeting in the default room. Naive users get a working substrate on day 1. ## References - `[[host-the-seemingly-impossible]]` — shared base, page LoRAs - `[[individuality-is-the-substrate-strength]]` — diversity via LoRA - `[[personas-have-names-not-function-labels]]` — role in bio, identity from deterministic projection - `[[substrate-is-communities-of-specialization]]` — even N=2 is a community - Built on: #87 PersonaInstanceManagerModule, #115 HwCapabilityTier, #116 FilesystemPersonaResolver, #109/#110/#111 InferenceCoordinator Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Bumps @typescript-eslint/parser from 8.29.1 to 8.41.0.
Release notes
Sourced from
@typescript-eslint/parser's releases.... (truncated)
Changelog
Sourced from
@typescript-eslint/parser's changelog.... (truncated)
Commits
31a7336chore(release): publish 8.41.060c3b26chore(release): publish 8.40.0b2ee794chore(release): publish 8.39.1c98d513chore(release): publish 8.39.02112d58feat: update to TypeScript 5.9.2 (#11445)d11e79echore(release): publish 8.38.0816be17chore(release): publish 8.37.084b7a2echore(release): publish 8.36.0e2ecca6chore: fix issues introduced by updatednxconfiguration (#11230)f9bd7d8chore(release): publish 8.35.1Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting
@dependabot rebase.Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR:
@dependabot rebasewill rebase this PR@dependabot recreatewill recreate this PR, overwriting any edits that have been made to it@dependabot mergewill merge this PR after your CI passes on it@dependabot squash and mergewill squash and merge this PR after your CI passes on it@dependabot cancel mergewill cancel a previously requested merge and block automerging@dependabot reopenwill reopen this PR if it is closed@dependabot closewill close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually@dependabot show <dependency name> ignore conditionswill show all of the ignore conditions of the specified dependency@dependabot ignore this major versionwill close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this minor versionwill close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this dependencywill close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)