Build(deps-dev): Bump @typescript-eslint/eslint-plugin from 8.29.1 to 8.39.1#104
Closed
dependabot[bot] wants to merge 1 commit into
Closed
Conversation
Bumps [@typescript-eslint/eslint-plugin](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/eslint-plugin) from 8.29.1 to 8.39.1. - [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases) - [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/CHANGELOG.md) - [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v8.39.1/packages/eslint-plugin) --- updated-dependencies: - dependency-name: "@typescript-eslint/eslint-plugin" dependency-version: 8.39.1 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 #112. |
dependabot
Bot
deleted the
dependabot/npm_and_yarn/typescript-eslint/eslint-plugin-8.39.1
branch
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
…essions (task #107, slice A) The library layer of the inference handle pattern. Open a session against any AIProviderAdapter, get back a HandleRef, thread it through many generate() calls, close when done. Adapter-agnostic: works uniformly for HeuristicInferenceAdapter, AnthropicAdapter, OpenAICompatibleAdapter, future LlamaCppAdapter, future AircRemoteInferenceAdapter. Joel (2026-05-31): "Maybe you get a handle first then inference? Establish once? Keep loaded or it pages itself intelligently but still a handle. That way you've got a remote handle or a cloud handle. Etc. typically you call these things repeatedly in." Realizes [[inference-is-an-adapter-always-in-the-loop]] §"Inference handles": one canonical session shape across local / cloud / heuristic / remote — the substrate's answer to "model load is expensive, inference is cheap." Production paths (persona service cycle, RAG cycle, sentinel review) hold long-lived handles. ### Library shape - `OpenSessionRequest` — system_prompt, model override, LoRA active_adapters, persona_id scope - `InferenceSession` — adapter + session state + atomics for last_used_ms / generation_count (lock-free updates from generate through &session) - `InferenceHandleStore` — DashMap<Uuid, Arc<InferenceSession>>; multi-threaded generate calls don't serialize on the map - `SessionInspection` — read-only snapshot for [[observability-is-half-the-architecture]]: provider, model, persona, warm-state telemetry - `HandleStoreError` — typed errors (OwnerMismatch / TypeTagMismatch / HandleNotFound / PersonaScopeMismatch); consumers branch on the variant, no string parsing ### Doctrine touchpoints - HandleRef owner = "ai/inference", type_tag = "ai::InferenceSession" — matches the canonical example in cell_shapes.rs line 152 - Validates owner + type_tag before state-map lookup (HandleRef::expect_owned_by shape, per [[cell-processor-command-runtime]]) - Persona scope: session opened for persona A rejects generate requests with persona_id B (same defense-in-depth shape as AircRagSource's cross-persona ctx check) - Per-call request fields override session defaults — caller can vary sampling per turn while session-level system_prompt / LoRA / model stay sticky - Updates last_used_ms + generation_count BEFORE adapter call so observers see in-flight sessions even when generation fails ### Tests (16, all green) - open returns HandleRef with canonical owner + type_tag - multiple opens get distinct UUIDs - generate via valid handle routes to adapter - generate with mismatched owner / type_tag / unknown UUID → typed errors (no swallowing) - close releases; subsequent generate fails; double-close returns false the second time - generate updates last_used_ms + increments generation_count - session system_prompt applies when request omits it - per-request system_prompt overrides session default - persona-scoped session rejects mismatched persona request - persona-scoped session accepts matching persona request - unscoped session accepts any persona request - inspect reports provider / model / has_system_prompt / warm state - 16 concurrent open+generate+close tasks complete without deadlock or lost handles (DashMap concurrency guard) ### What's next (slice B) ServiceModule wrapper exposing `ai/inference/open`, `ai/inference/generate`, `ai/inference/close` as kernel commands. Tasks #100 (rag-inspect ServiceModule) and #104 (rag_inspect chains through inference) both become single-handle long-lived loops once that lands.
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
…able by other AIs (task #100) Wraps the existing `persona::rag_inspect` library function as a kernel-level command. Any AI (Claude, sentinel persona, another peer, mechanic shop) can now call `Commands.execute('persona/rag-inspect', { persona })` and get back a structured snapshot of what that persona's RAG layer would deliver right now — the three canonical introspection questions ([[observability-is-half-the-architecture]]) answered in one call: 1. "Would I respond as it requests at this step?" — full prompt reconstructable from `deliveries`. 2. "Which layer is broken?" — per-source `allocations` show Satisfied / FloorOnly / Dropped / UnderProvisioned state. 3. "Is this contextually relevant?" — each `item` carries score, age_s, peer_id_prefix, lamport, content_preview. ### Architecture - `PersonaResolver` trait — abstracts "given a persona name, give me persona_id + AircTranscriptReader." Production wiring (later commit) implements against `~/.continuum/personas/<name>/seed.json` + `airc_lib::Airc::attach_as`. Tests use a stub that returns canned events without needing a live airc daemon. - `PersonaRagInspectModule` — ServiceModule. Holds `Arc<dyn PersonaResolver>`. Routes the `persona/rag-inspect` command into the library function with parameter overrides (context_window, airc_floor/max/fetch_limit, trace_path, now_ms). - Wire types (`RagInspectParams`, `RagInspectAllocation`, `RagInspectItem`, `RagInspectDelivery`, `RagInspectResult`) ts-rs-derived + auto-exported to `shared/generated/persona/Rag*.ts`. The library's `BudgetAllocation` (which doesn't have ts-rs derives) gets flattened/projected into wire types at the module layer so the inference doctrine layering stays clean. ### Optional knobs flow through Caller can vary the inspection profile per call: - `contextWindow` — model context size (default 32K from library). - `aircFloor` / `aircMax` — source budget overrides. - `aircFetchLimit` — how many airc events to consider (default 100). - `tracePath` — JSONL capture trace for replay (other AIs resume against this). - `nowMs` — wall-clock override for deterministic replay. ### Doctrine alignment - [[commands-are-kernel-level-and-compose]] — pure command-envelope routing. The module has no introspection logic of its own; it's the kernel surface for the library function. - [[observability-is-half-the-architecture]] — this commit realizes the doctrine: introspection becomes a substrate primitive that any AI can call, not just a file on disk that someone has to `cat | jq`. - [[inference-is-an-adapter-always-in-the-loop]] — the resolver trait is the "adapter" for persona resolution; production wiring plugs in the real airc-attach path the same way coordinator wiring plugs in adapters elsewhere. ### Tests (13, all green) Module behavior (8): - config_reports_canonical_name_and_prefix - empty_persona_name_returns_typed_error - unknown_persona_surfaces_resolver_error (resolver errors propagate cleanly to callers) - known_persona_with_empty_room_returns_zero_items_but_satisfied_allocation — Paige has no airc events; deliveries empty; allocation still reports Satisfied because the airc source's full max fits available_for_sources. - known_persona_with_events_returns_items_with_full_rationale — two events; first item has content_preview="hello world", score=1.0, age_s=100, peer_id_prefix.len()=8. - context_window_override_threads_through (8192 instead of 32K default). - handle_command_routes_canonical_command_to_inspect — full CommandRequest envelope round-trips through. - handle_command_unknown_returns_loud_error — typed routing error. ts-rs binding exports (5): - RagInspectAllocation, RagInspectDelivery, RagInspectItem, RagInspectParams, RagInspectResult — all auto-generated to `shared/generated/persona/`. ### What this unblocks - #104: rag_inspect chains through the inference command. With the module shipped, an AI can sequence `persona/rag-inspect` → `ai/inference/open` → `ai/inference/generate` to get the full "what would the persona see + what would they say" loop in two command calls. - Sentinel personas doing adversarial review of other personas' turn quality. - Mechanic-shop tools running prompt audits without needing file-system access. ### Production wiring deferred The `PersonaResolver` impl that reads `~/.continuum/personas/<name>/seed.json` + attaches via `airc_lib::Airc::attach_as` is its own focused commit. The module is ready to wire into the runtime registry the moment that resolver lands.
joelteply
added a commit
that referenced
this pull request
Jun 2, 2026
…ospection loop (task #104) Extends rag_inspect from a RAG-only inspection to the full introspection loop. When the caller asks (and the persona has a preferred adapter), the inspection assembles delivered items into a prompt, calls the inference adapter, and captures the response. This answers the canonical introspection question Joel articulated 2026-05-31: > "With this prompt would I respond as it requests at this step?" Now answerable in ONE command call: Commands.execute('persona/rag-inspect', { persona: 'Paige', chainInference: true, }) returns a `modelResponse` field with adapter_id, model, prompt_text, response_text, finish_reason, input_tokens, output_tokens, response_time_ms. No need to sequence `rag-inspect` → `ai/inference/open` → `ai/inference/generate` manually; the substrate does it for you when asked. ### Library layer (persona/rag_inspect.rs) - New struct `ModelResponseInspection`: adapter_id, model, prompt_text, response_text, finish_reason, input/output_tokens, response_time_ms — captured snapshot suitable for replay (other AIs can paste prompt_text into a different model to compare). - `RagInspection` grows optional `model_response: Option<ModelResponseInspection>` (None on the RAG-only path). - New function `inspect_persona_rag_with_inference(request, airc_reader, Option<Arc<dyn AIProviderAdapter>>)` — the full-chain variant. - Existing `inspect_persona_rag` stays unchanged (delegates to the new function with None), so the demo binary + the PersonaRagInspectModule's existing tests keep working. - Prompt assembly (first cut): "You are <persona_name>. Below are recent messages..." system prompt + one user message per delivered item. Slice 12 (PromptAssembly) will refine; this cut is the simplest shape that produces sensible inputs for the heuristic adapter. ### ServiceModule layer (modules/persona_rag_inspect.rs) - `PersonaResolution` grows `inference_adapter: Option<Arc<dyn AIProviderAdapter>>`. Production wiring (later) supplies the persona's preferred adapter; tests use HeuristicInferenceAdapter. - `RagInspectParams` grows `chainInference: Option<bool>` — caller's request to chain. - `RagInspectResult` grows `modelResponse: Option<RagInspectModelResponse>` — flattened wire shape mirroring the library type. - `RagInspectModelResponse` is its own ts-rs-exported struct in `shared/generated/persona/RagInspectModelResponse.ts`. ### Design choices 1. **Library function takes Option<Arc<dyn AIProviderAdapter>> directly** instead of going through Commands.execute. The library is in the same crate as the adapter trait; calling adapter.generate_text() IS the canonical inference path (the command surface is a wrapper over the same call). No bypass per [[inference-is-an-adapter-always-in-the-loop]] — same trait, same wire shape, same replay determinism (heuristic adapter is deterministic). Avoids a circular dep through the global command executor. 2. **Resolver decides the adapter, not the caller.** Per [[inference-scarcity-economics]] §"commands cannot negotiate this" — the command's chainInference param is a HINT, not a negotiation. The substrate (via the resolver) picks which adapter the persona prefers. Caller can't override. 3. **Adapter absent → silent degrade to RAG-only.** When chainInference=true but the resolver returns no adapter (e.g. persona has no preferred adapter configured), the inspection produces a RAG-only result with model_response=None. Better than a typed error; the caller gets useful introspection without the inference layer. ### Tests (9 new across both layers, all green) Library tests (5 new, 14 total): - ragonly_path_leaves_model_response_none - chained_path_captures_response_from_heuristic_adapter — verifies adapter_id="heuristic", response_text echoes the LAST user turn, finish_reason="stop" - chained_path_with_zero_items_still_produces_marker_response (heuristic emits "(no user text in prompt)" marker) - chained_path_prompt_text_carries_system_and_messages (asserts "You are TestPersona" + the latest user content + "System:" header) - chained_path_same_prompt_yields_same_response_replay_safe — the determinism contract: two runs with identical inputs produce byte-identical responses + prompts. Required for replay-safety per [[persona-record-replay-is-a-product-requirement]]. Module tests (4 new, 18 total): - rag_only_default_leaves_model_response_none - chain_inference_with_adapter_captures_model_response - chain_inference_without_adapter_stays_rag_only - chained_path_through_command_surface_returns_model_response_in_wire_shape — verifies the JSON envelope flattens modelResponse at the top level with camelCase field names (adapterId, responseText, etc). ### What's unblocked - Adversarial review by sentinel personas: a sentinel calls `persona/rag-inspect` with chainInference=true on the persona it's reviewing, sees the full RAG → prompt → response chain in one shot, and judges. - Mechanic-shop debugging: "why did Paige say X?" — call rag-inspect with chainInference=true, get back the exact prompt + the exact response. Reproducible. - Replay-against-other-model: the prompt_text in the response is suitable for pasting into a different model (Claude, GPT-4) and comparing answers — exactly the "would Claude respond differently?" question. ### Production wiring The PersonaResolver impl (reads ~/.continuum/personas/<name>/seed.json, attaches via airc_lib::Airc::attach_as, selects the persona's preferred adapter from AIProviderModule's registry) is the focused follow-up commit. The substrate-side plumbing is now complete.
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.
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/eslint-plugin from 8.29.1 to 8.39.1.
Release notes
Sourced from
@typescript-eslint/eslint-plugin's releases.... (truncated)
Changelog
Sourced from
@typescript-eslint/eslint-plugin's changelog.... (truncated)
Commits
b2ee794chore(release): publish 8.39.1fee2bc6chore: update eslint-plugin-eslint-plugin (#11449)c98d513chore(release): publish 8.39.0a8def4bfix(eslint-plugin): [no-unsafe-assignment] add anunsafeObjectPatternmessa...422e3e2feat(eslint-plugin): [only-throw-error] support yield/await expressions (#11417)e901ad8fix(eslint-plugin): revert #11127 (#11447)8dc8340feat(eslint-plugin): add no-unnecessary-type-conversion to strict-type-checke...2112d58feat: update to TypeScript 5.9.2 (#11445)b872e2bfeat(eslint-plugin): [naming-convention] add enumMember PascalCase default op...757f9eefix(eslint-plugin): [prefer-optional-chain] ignorecheckoption for most RH...Dependabot 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)