dsh-llm-fallbacks 0.6.13 → 0.8.0

package/dist/role-resolution.d.ts

@@ -1,105 +1,37 @@
 /**
- * Dispatch-time role resolution (plan fallbacks-role-automatch Task 2; the
- * dispatch-role stage added by plan dsh-148-agent-team-role-delivery Task 1).
- *
- * Precedence (first hit wins) across four ordered stages:
+ * Dispatch-time role resolution (named virtual chains, plan
+ * named-virtual-chains T3): narrowed to TWO stages —
  * 1. explicit — `session.header.agentPreset` trimmed matches a declared role
- *    id → that role's DECLARED RAW id (via the `roleIds` trimmed-id map, the
- *    same canonicalization the rules path uses); the reserved `'inherit'`
- *    and undeclared presets are NEVER dispatchable explicit roles and fall
- *    through to the next stage;
+ *    id → that role's DECLARED RAW id (via the `roleIds` trimmed-id map); the
+ *    reserved `'inherit'` and undeclared presets are NEVER dispatchable
+ *    explicit roles;
  * 2. dispatch — `opts.dispatchRole`: the role the dispatch seam resolved from
  *    the Assignment/teammate prompt (`**Execute as**: <id>`, the single
  *    parser in `src/subagents-seam.ts`), canonicalized by the same trim +
  *    `roleIds` lookup. An absent, empty, `'inherit'` or no-longer-declared
- *    reference falls through silently — a role removed after the dispatch is
- *    not an error;
- * 3. rules — the existing `resolveRole` passthrough, unchanged (a declared
- *    role wins; no-rule-match / an explicit rule targeting `'inherit'`
- *    resolve to `'inherit'`);
- * 4. auto-match — only when stage 3 resolved to `'inherit'` AND
- *    `opts.automatchEnabled`: call `opts.automatch` with the agent. The hook
- *    (Task 3 supplies the bounded LLM caller) MUST return a declared raw id
- *    or `null`; the resolver defensively validates the return against
- *    `roleIds` — an unknown id warns and resolves to `'inherit'`, never an
- *    undeclared role. When `automatch` is undefined or `automatchEnabled`
- *    is false the hook is skipped.
- *
- * `'inherit'` is the single "no specific role" outcome — reached by
- * no-rule-match OR an explicit rule targeting `'inherit'` — and both are
- * auto-match eligible when enabled. An operator who wants a class to never
- * auto-match sets `roleAutoMatch: false` (→ `automatchEnabled: false`).
+ *    reference resolves to `undefined` — no role, no error.
  *
- * Pure ordering logic: no config object and no LLM service inside this
- * module — the LLM is an injectable hook owned by Task 3/4.
+ * The rules stage is DELETED with `roles.rules` (v2). `undefined` is the
+ * single "no specific role" outcome — the plugin does not intervene and the
+ * child inherits the delegating agent's route.
  *
  * @module dsh-llm-fallbacks/role-resolution
  */
-import { type FallbacksRoleRule } from './config.ts';
-import { type AgentLike } from './roles.ts';
-import type { Selector } from './selectors.ts';
-export type { FallbacksRoleRule } from './config.ts';
-/** Options for {@link resolveRoleAtDispatch}. */
-export interface ResolveRoleAtDispatchOptions {
+export interface DeclaredRoleOptions {
     /**
      * Dispatch-declared role: the DECLARED RAW id the seam resolved from the
      * Assignment/teammate prompt (`**Execute as**: <id>`). Validated against the
      * live `roleIds` map; absent, `inherit`, or no-longer-declared → skipped.
      */
     dispatchRole?: string;
-    /**
-     * Whether the auto-match stage may run (the `roleAutoMatch` config switch).
-     * When `false`, stage 4 never runs and the outcome is identical to the
-     * explicit/dispatch/rules stages alone.
-     */
-    automatchEnabled: boolean;
-    /**
-     * Auto-match hook — Task 3 supplies the bounded LLM caller; the resolver
-     * itself contains no LLM. Contract: given the agent being resolved, return
-     * a declared raw role id or `null`. The resolver defensively validates the
-     * return against `roleIds` — an unknown id warns and resolves to
-     * `'inherit'`, never an undeclared role. Skipped when undefined.
-     */
-    automatch?: (agent: AgentLike) => Promise<string | null>;
-    /** Warning sink — the decision path injects the plugin logger. */
-    warn: (message: string) => void;
-    /**
-     * The route the agent's request was actually SERVED by, when that differs
-     * from the pair recorded on the agent (the virtual `FallbacksChain/Auto`
-     * row). Rule matching accepts either, so a rule keyed on the real chain head
-     * keeps matching a child whose recorded route is the virtual pair (QC1 I-1).
-     * `undefined` for every real route.
-     */
-    servedRoute?: {
-        provider: string;
-        model: string;
-    };
 }
 /**
- * Resolve the dispatch-time role for an agent across four ordered stages
- * (explicit → dispatch → rules → auto-match hook). Never throws on its own
- * inputs; the hook's own rejection is deliberately NOT caught here (the
- * Task-3/4 wiring bounds the LLM call so it never throws out of the request
- * path).
+ * The dispatch role: explicit preset → dispatch-declared. Returns
+ * `undefined` when neither stage resolves (NOT SPECIFIED — no plugin
+ * intervention).
  *
  * `roleIds` is the canonical trimmed-id map (`trimmed id → declared raw id`,
  * built in `src/index.ts` apply()): every stage canonicalizes its reference
- * by trim and returns the DECLARED RAW id, so roleDef lookups in
- * `chains.ts` / `commands.ts` find the stored `roles.list[]` entry exactly
- * (qc2 F-001 — no silent role inertness on padded YAML ids).
- */
-export declare function resolveRoleAtDispatch(agent: AgentLike, rules: FallbacksRoleRule[], roleIds: ReadonlyMap<string, string>, opts: ResolveRoleAtDispatchOptions): Promise<string>;
-/**
- * The dispatch-time chain head (plan fallbacks-role-automatch Task 4): the
- * FIRST candidate of a `resolveChainViews` pass whose `wildcard` flag is
- * false — an exact `provider/model` entry. `provider/*` entries are NOT
- * dispatch injection targets (no failing model to anchor them; a guessed
- * injection risks a hard failure whose code may sit outside `triggerCodes`),
- * so a wildcard-only chain yields `undefined` → no injection (today's
- * behavior). No cooldown/failed filtering and no existence probe run here —
- * a fresh subagent's first request has no failure-scoped state (see the Task
- * 4 decision) and exact heads are never probed. Pairs with
- * {@link resolveChainViews}'s parallel `wildcard` provenance (`src/chains.ts`);
- * the caller resolves the role's concatenated chain first.
+ * by trim and returns the DECLARED RAW id.
  */
-export declare function firstExactCandidate(all: readonly Selector[], wildcard: readonly boolean[]): Selector | undefined;
+export declare function resolveDeclaredRole(agentPreset: string | undefined, roleIds: ReadonlyMap<string, string>, opts: DeclaredRoleOptions): string | undefined;

package/dist/schema.d.ts

@@ -15,9 +15,10 @@
  * Object fields are optional by default in schemastery; `.default()` fills
  * the spec defaults, `.required()` keeps mandatory fields. Unknown keys are
  * RETAINED by the composition (verified plan Task 1 Step 1) — that is what
- * lets `detectLegacyKeys` flag two-block-era leftovers (`chains` /
- * `roles.default`) on the composed object at startup (warn + gateway
- * `legacyKeys`, see `src/index.ts` apply()).
+ * lets `detectLegacyKeys` flag v1 two-block leftovers (`rootChain` /
+ * `roles.rules` / …) on the composed object at startup (warn-only
+ * migration; the gateway strips them via LEGACY_KEYS, see
+ * `src/gateway.ts`).
  *
  * Current host contract: the whole schema is marked `volatile` (the host
  * retired `installSection` — the Loader entry Config IS the settings
@@ -34,7 +35,7 @@
  * @module dsh-llm-fallbacks/schema
  */
 import z from '@deepseek-ai/schemastery';
-import type { FallbacksConfig } from './config.ts';
+import type { FallbacksConfigSource } from './config.ts';
 declare module '@deepseek-ai/schemastery' {
     namespace Schemastery {
         interface Meta {
@@ -43,4 +44,4 @@ declare module '@deepseek-ai/schemastery' {
         }
     }
 }
-export declare const Config: z<FallbacksConfig>;
+export declare const Config: z<FallbacksConfigSource>;

package/dist/seeds.d.ts

@@ -42,7 +42,7 @@
  *
  * @module dsh-llm-fallbacks/seeds
  */
-import { type FallbackStrategy, type FallbacksConfig, type FallbacksConfigLogger, type FallbacksRoles } from './config.ts';
+import { type FallbacksConfig, type FallbacksConfigLogger, type FallbacksRoles } from './config.ts';
 /** A seed declaration from a companion plugin (spec §9.1). */
 export interface SeedDeclaration {
     id: string;
@@ -112,10 +112,8 @@ export interface EffectiveRole {
     id: string;
     /** Effective row persona. */
     persona: string;
-    /** Passthrough — never touched by seeds (R4). */
-    chain?: string[];
-    /** Passthrough — never touched by seeds (R4). */
-    fallback?: FallbackStrategy;
+    /** Passthrough — never touched by seeds (R4): the named-chain POINTER. */
+    chain?: string;
     /** Id is in the live declaration set (trimmed row-id match). */
     seeded: boolean;
     /** `seeded` && row persona !== current seed default. */
@@ -154,7 +152,7 @@ export interface SeedsWireStatus {
 export interface SeedsIo {
     /** Fresh composed config read (the same source the gateway reads). */
     read(): FallbacksConfig;
-    /** Persist a full `{ list, rules }` to the settings user layer. */
+    /** Persist the `{ list }` to the settings user layer. */
     writeRoles(roles: FallbacksRoles): Promise<void>;
 }
 /**
@@ -192,7 +190,7 @@ export declare class FallbacksSeedManager {
      * RESOLVED effective default before/after the candidate slice commit
      * (at-default tracking follows the resolution winner — a producer that
      * is not the winner for an id it declares never rewrites the row),
-     * writes only when the computed `{ list, rules }` differs from the
+     * writes only when the computed `{ list }` differs from the
      * current composed roles (idempotent, AC-1), and commits the slice only
      * after a successful write (compute → write → commit; retry-safe). An
      * empty batch drops the producer's slice.

package/dist/state.d.ts

@@ -1,137 +1,34 @@
 /**
- * Per-agent fallback state machine (spec §5.1; plan Task 3).
+ * Per-agent fallback state (direction C, plan dsh-022-rc1-upgrade).
  *
  * One `AgentFallbackState` per `agent.id`, held in a `FallbackStateStore`
- * created at plugin apply, removed on `agent/disposed`, defensively pruned on
- * `agent/status` idle, and cleared wholesale on plugin dispose (spec §6:
- * 无残留状态).
+ * created at plugin apply, removed on `agent/disposed`, and cleared wholesale
+ * on plugin dispose (spec §6: 无残留状态).
  *
- * **pendingSwitch lifecycle** (spec §5.1):
- * 1. **Produce** (decision point — request-error trigger-code or
- *    agent/request always-cap): `writePending` stores the decision and clears
- *    `appliedTurnStep`, so a *fresh* decision is always applicable at the
- *    current (turn, step) — required for chains (decision B→C must apply even
- *    though A→B was already applied at the same (turn, step)).
- * 2. **Apply** (`agent/request`): `applyPending` returns the pending switch
- *    when one exists and has not already been applied at the current
- *    (turn, step), records `appliedTurnStep`, and clears `pendingSwitch`
- *    (anti-replay guard).
- * 3. **Discard**: chain exhaustion / safety valve → the caller delegates
- *    (`next()`) and the pending state dies with the agent.
- *
- * **stepFailures** resets whenever (turn, step) advances (`syncStep`);
- * **cooldown** (`CooldownStore`) is a `provider/model → expiry epoch ms` map
- * with lazy expiry (`revertPolicy: 'never'` = `Infinity` TTL). The time-boxed
- * cooldown deliberately survives idle cleanup so `cooldown-expiry` revert
- * (US-4 / T4 integration) works across turns.
+ * The store is the CROSS-CALL memory the chain walk reads: **cooldown**
+ * (`CooldownStore` — a `provider/model → expiry epoch ms` map with lazy expiry;
+ * `revertPolicy: 'never'` = `Infinity` TTL) plus the **recovery** circuit
+ * (`RecoveryStore`). The time-boxed cooldown deliberately survives idle
+ * cleanup so `cooldown-expiry` revert (US-4 / T4 integration) works across
+ * turns. Per-request bookkeeping (the failed-candidate set, the switch cap) is
+ * walk-local: a walk lives inside one `stream()` call, so nothing durable is
+ * kept for it here.
  *
  * @module dsh-llm-fallbacks/state
  */
-import type { FallbackSwitchReason } from './events.ts';
-import { CooldownStore, StepFailureSet } from './cooldown.ts';
+import { CooldownStore } from './cooldown.ts';
 import { RecoveryStore } from './recovery.ts';
 import type { RecoveryPolicy } from './config.ts';
-/**
- * What a switch's failure was actually about.
- *
- * `'route'` (the default) is every failure the plugin has ever walked: the
- * provider/model itself is unhealthy (auth, quota, rate limit, ...), so the
- * from-route is cooled down and counted as a route failure.
- * `'request'` is a failure of the REQUEST on a healthy route — a
- * `CONTEXT_WINDOW_EXCEEDED` rejection is the request being too big, not the
- * model being down. `commit()` keeps the step-scoped bookkeeping for those
- * but writes no suppression and no recovery failure (see `src/index.ts`
- * `REQUEST_SCOPED_CODES`).
- */
-export type SwitchScope = 'route' | 'request';
-/** Decision awaiting application at the next `agent/request` boundary (spec §5.1). */
-export interface PendingSwitch {
-    from: {
-        provider: string;
-        model: string;
-    };
-    to: {
-        provider: string;
-        model: string;
-    };
-    role: string;
-    reason: FallbackSwitchReason;
-    /**
-     * What the failure was about — absent means `'route'`, the semantics every
-     * switch had before request-scoped codes existed (same optional-with-a-
-     * documented-default idiom as `FallbacksRole.fallback`). Only the
-     * `agent/request-error` listener ever sets `'request'`.
-     */
-    scope?: SwitchScope;
-}
-/**
- * One plugin-originated subagent switch the host allowlist blocked (plan
- * dsh-012-subagent-routing T3; spec D1). The intersection of the resolved
- * candidates with the effective allowlist was empty while the unconstrained walk
- * would have switched — the attempt is recorded in-memory only (issue #52:
- * no durable session write) for the Subagents card warning (spec D4/T5).
- */
-export interface BlockedSwitchAttempt {
-    /** Epoch ms when the switch was blocked. */
-    at: number;
-    /** The route the unconstrained walk would have switched to (exact provider+model). */
-    route: {
-        provider: string;
-        model: string;
-    };
-    /** The failure reason that triggered the would-be switch. */
-    reason: FallbackSwitchReason;
-}
-/**
- * How the effective subagent chain head was chosen (plan dsh-012-subagent-routing
- * T5 / T2 M3). Lives on a per-agent map (mirrors {@link BlockedSwitchAttempt}),
- * not on {@link AgentFallbackState} — recording a head is not a switch intent
- * (F-004: the fallback store grows only inside `commit()`).
- */
-export type ChainHeadSource = 'authorized' | 'injected';
-/**
- * The effective chain head for one subagent, plus the source label the
- * Subagents card renders (spec D4). In-memory only (issue #52).
- */
-export interface EffectiveChainHead {
-    /** Epoch ms when this head was recorded (recency for the card snapshot). */
-    at: number;
-    /** Exact provider+model of the effective chain head. */
-    route: {
-        provider: string;
-        model: string;
-    };
-    /** `authorized` = host spawn preserved; `injected` = plugin role-inject. */
-    source: ChainHeadSource;
-}
-/** The current (turn, step)'s failed-model set and switch budget (spec §5.1). */
-export interface StepFailures {
-    turn: number;
-    step: number;
-    /** `${provider}/${model}` keys failed in this step (double suppression with cooldown). */
-    failed: StepFailureSet;
-    /** Switches committed in this step; the caller judges it against `maxSwitchesPerStep`. */
-    switchCount: number;
-}
-/** One agent's whole fallback runtime state (spec §5.1). */
+/** One agent's fallback runtime state. */
 export interface AgentFallbackState {
-    /** Decision produced but not yet applied at an `agent/request` boundary. */
-    pendingSwitch?: PendingSwitch;
-    /** The (turn, step) the last pending switch was applied to — anti-replay. */
-    appliedTurnStep?: {
-        turn: number;
-        step: number;
-    };
-    /** Current (turn, step)'s failure bookkeeping. */
-    stepFailures: StepFailures;
     /** `provider/model → expiry epoch ms`; lazily expired on read. */
     cooldown: CooldownStore;
     /** Half-open recovery bookkeeping (plan fallbacks-half-open-recovery P2). */
     recovery: RecoveryStore;
 }
 /**
- * The `Map<agent.id, AgentFallbackState>` store plus the state-machine
- * operations (spec §5.1).
+ * The `Map<agent.id, AgentFallbackState>` store plus the state operations the
+ * walk and the diagnostics surfaces read.
  */
 export declare class FallbackStateStore {
     private readonly states;
@@ -146,29 +43,6 @@ export declare class FallbackStateStore {
     delete(agentId: string): void;
     /** Remove every agent's state (plugin dispose — no residual state). */
     clear(): void;
-    /** Reset step-scoped bookkeeping when (turn, step) advances (spec §5.1). */
-    syncStep(state: AgentFallbackState, turn: number, step: number): void;
-    /** Record the current model as failed in this step (spec §5.1). */
-    recordFailure(state: AgentFallbackState, key: string): void;
-    /** Bump the step's switch budget (spec §5.1). */
-    recordSwitch(state: AgentFallbackState): void;
-    /**
-     * Produce a pending switch. A fresh decision always supersedes a previous
-     * one and must be applicable at the current (turn, step), so the applied
-     * marker is cleared here (see module doc — chains).
-     */
-    writePending(state: AgentFallbackState, pending: PendingSwitch): void;
-    /**
-     * Apply the pending switch at (turn, step) when one exists and has not
-     * already been applied there; records the applied marker and clears the
-     * pending switch (spec §5.1 lifecycle step 2).
-     */
-    applyPending(state: AgentFallbackState, turn: number, step: number): PendingSwitch | undefined;
-    /**
-     * Defensive `agent/status` idle cleanup: drop per-step state. The time-boxed
-     * cooldown survives so `cooldown-expiry` revert works across turns (US-4).
-     */
-    clearStepState(state: AgentFallbackState): void;
     /** Suppress `key` until `untilEpochMs` (`Infinity` for `revertPolicy: 'never'`). */
     suppress(state: AgentFallbackState, key: string, untilEpochMs: number): void;
     /**

package/dist/subagents-seam.d.ts

@@ -58,8 +58,28 @@
  * (the runtime mints its own child id and `agent/created` has already run), in
  * which case this module resolves the same question against the live roles
  * source and carries the verdict onto the record keyed off the RESOLVED id,
- * before the child's first pre-step. This module writes no request field,
- * reads no provider persona capability, and injects no agent preset.
+ * before the child's first pre-step. This module reads no provider persona
+ * capability and injects no agent preset.
+ *
+ * Role chain stamp (named virtual chains §3, `injectRoleChain`): the SAME
+ * resolution point is where a dispatch child is pointed at a named chain —
+ * `request.agentOptions` is stamped with `{ provider: 'FallbacksChain',
+ * model: <role.chain> }` (rc.1 merges it over the parent's route when
+ * `manager.startLocal` creates the child) when all FOUR conditions hold: a
+ * declared role resolved, its `chain` is non-empty AND declared, the request
+ * carries no explicit `agentOptions` (explicit = authorized, untouched), and
+ * the backend is LOCAL. No host-policy consultation: the mapping is the
+ * user's STATIC config, never a model-authored route — no allowlist, no
+ * `unprovable` branch, no `virtualRouteInjected` flag. The seam does NOT
+ * check conformance: a declared-but-non-conforming chain is still stamped and
+ * the walk's own tail gate refuses it — one gate, in the walk. Injection is
+ * creation-time only BY CONSTRUCTION: rc.1's `startActivation` rejects any
+ * child id that already exists (`DUPLICATE_CHILD`): a caller-reserved
+ * `childId` the seam already recorded is a RE-ACTIVATION of that child (its
+ * durable selection is already fixed), so it stamps nothing — that activation
+ * writes the role record only (I-000081). A non-stamped dispatch forwards the
+ * caller's spec untouched (external backends keep pure inheritance; not
+ * specified ⇒ the child inherits the delegating agent's route).
  *
  * In-session notice row (plan Task 3): the SAME install point registers the
  * `agent/pre-step` emitter (`./role-notice.ts`) over the record map it owns, so
@@ -89,7 +109,7 @@
  * @module dsh-llm-fallbacks/subagents-seam
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { type FallbacksRole } from './config.ts';
+import { type FallbacksConfig, type FallbacksRole } from './config.ts';
 /**
  * The cordis service-read waterfall event the seam registers on. Referenced
  * ONCE (registration) so a future cordis rename is a one-line change here.
@@ -169,14 +189,25 @@ export interface SubagentStartRequestView {
             readonly id?: string;
         };
     };
+    /**
+     * rc.1 `SubagentStartRequest.agentOptions` (design §1.1) — the route the
+     * caller (or the model, on the tool path) asked the child to run on. Read
+     * only: an explicit pair here is the AUTHORIZED route and is never touched.
+     */
+    readonly agentOptions?: {
+        readonly provider?: string;
+        readonly model?: string;
+    };
 }
 /**
  * Structural view of the activation spec (rc.1 `SubagentActivationSpec`,
- * consumed fields only): `childId` is the caller-reserved identity a resume
- * already carries — also the record fallback when the request carries no
- * Assignment header — and `label` is the catalog join's other half (the
- * cataloged child membership carries this exact string). `signal`, `delivery`
- * and every future field travel with the caller's spec object.
+ * consumed fields only): `childId` is the caller-RESERVED identity of a NEW
+ * local child (rc.1 `startLocal` rejects an id that already exists with
+ * `DUPLICATE_CHILD`, so `startActivation` never attaches to a child that
+ * outlived an earlier activation) — also the record fallback when the request
+ * carries no Assignment header — and `label` is the catalog join's other half
+ * (the cataloged child membership carries this exact string). `signal`,
+ * `delivery` and every future field travel with the caller's spec object.
  */
 export interface SubagentActivationSpecView {
     readonly provider: string;
@@ -199,6 +230,12 @@ export interface SubagentSeamOptions {
      * wired) ⇒ no verdict, exactly like a listener that never saw the child.
      */
     roles?: () => readonly FallbacksRole[];
+    /**
+     * Live config reader — the SAME `source()` the runtime and the adapter walk
+     * read. Absent ⇒ the seam never stamps a role chain (a partial wiring keeps
+     * the native dispatch unchanged).
+     */
+    source?: () => FallbacksConfig;
     /** Contained debug sink (at most one line per contained degrade). */
     debug?: (message: string) => void;
 }
@@ -220,8 +257,8 @@ export interface SubagentSeam {
      * deliberately NOT cleared on `agent/disposed` — a continuable child's durable
      * session survives the activation, so clearing the marker would let a
      * re-activation resume append a second notice row to the same log. It is
-     * bounded (`NOTICE_EMITTED_LIMIT`) and cleared only in the plugin dispose
-     * effect.
+     * bounded (`NOTICE_EMITTED_LIMIT`) and cleared only when the LAST applied
+     * fiber of its root disposes (a surviving fiber's children still need it).
      */
     readonly noticeEmitted: Set<string>;
     /**
@@ -233,7 +270,7 @@ export interface SubagentSeam {
      * message.
      */
     readonly ownsWrapper: boolean;
-    /** Stop intercepting service reads (the owning fiber's teardown also does). */
+    /** Withdraw this fiber's registrations (its own lifecycle effect does this on teardown). */
     dispose(): void;
 }
 /**
@@ -272,15 +309,15 @@ export declare function resolveDeclaredRoleFromAssignment(prompt: string, roleId
  * DECLARED RAW id the seam already resolved, so this is an exact id match, not
  * a second canonicalization pass.
  *
- * Only `id` and `persona` are read: no `chain`, no `rootChain`, no routing
- * state — a `chain: []` role's persona resolves exactly like a chained one's.
+ * Only `id` and `persona` are read: no `chain` pointer, no routing state — a
+ * role that specifies a chain names its persona exactly like one that does not.
  *
  * @param roles - the live declared roles (`roles.list`).
  * @param roleId - the DECLARED RAW role id resolved at the seam.
  */
 export declare function personaForRole(roles: readonly FallbacksRole[], roleId: string): string | undefined;
 /**
- * @internal Test seam (mirrors `chainHeads`): the seam installed on
+ * @internal Test seam: the seam installed on
  * `ctx`, if any. Not part of the plugin's public surface — lets tests read and
  * seed the per-child record map without reaching into the installation
  * closure. `undefined` when no seam is installed.

package/dist/time-slots.d.ts

@@ -9,12 +9,12 @@
  * wires these helpers at request time (Task 2). Malformed rows NEVER
  * throw: they warn ONCE per row instance (through `console.warn` — the
  * resolver's 3-argument contract has no logger parameter) and are
- * skipped; a legacy non-empty non-conforming `rootChain` keeps the
- * legacy failure walk verbatim (P6).
+ * skipped; a non-empty non-conforming `entries` tail keeps the failure walk
+ * verbatim (the chain's delegate stays inert).
  *
  * @module dsh-llm-fallbacks/time-slots
  */
-import type { FallbacksConfig } from './config.ts';
+import type { NamedChain } from './config.ts';
 /** Official all-day selectors — the ONLY legal tails (length 1, XOR):
  * Flash (the current official default) and Pro, both selectable. The Pro
  * tail id is the catalog id verbatim: the official default catalog
@@ -87,32 +87,29 @@ export declare const PRESETS: Record<PresetId, PresetDefinition>;
  */
 export declare function isAllDayConforming(chain: readonly string[]): boolean;
 /**
- * Effective chain for a root request at `now` (P5): the FIRST extra row
- * whose descriptor contains `now` (stored order) — that row's `chain`
- * REPLACES the all-day chain (never concatenated); no match ⇒ `rootChain`
- * (the all-day row, always last and required). Malformed rows warn once
- * and are skipped; never throws.
+ * Effective chain for a request on ONE named chain at `now`: the FIRST
+ * matching row of {@link NamedChain.timeSlots} (stored order) — that row's
+ * `chain` REPLACES {@link NamedChain.entries} (never concatenated); no match
+ * ⇒ the chain's own `entries`. Malformed rows warn once and are skipped;
+ * never throws.
  *
- * P6 (qc1 F-001): without a conforming all-day the slot rows are inert, so
- * this IS the raw `rootChain` — the gate lives in {@link resolveSlotState},
- * the single source every slot surface (this, the 分时切换 log, the
- * `/fallbacks` strip, the virtual adapter delegate, its served-route anchor)
- * reads.
+ * Without a conforming entries tail the slot rows are inert, so this IS the
+ * raw `entries` — the gate lives in {@link resolveSlotState}, the single
+ * source every slot surface reads.
  */
-export declare function resolveEffectiveChain(config: FallbacksConfig, now: Date, tz: string): string[];
+export declare function resolveEffectiveChain(chain: NamedChain, now: Date, tz: string): string[];
 /**
- * Slot winner + display label (P5): drives 分时切换 detection (per-root-agent
- * last-winner marker, in-process only) and the card / `/fallbacks` status
- * strip. `winner` is the matching row or `'all-day'`; `label` names the
- * slot (frozen preset label or `custom HH:mm-HH:mm`).
+ * Slot winner + display label for one named chain: drives 分时切换 detection
+ * (per-(agent, chain) last-winner marker, in-process only) and the card /
+ * `/fallbacks` status strip. `winner` is the matching row or `'all-day'`;
+ * `label` names the slot (frozen preset label or `custom HH:mm-HH:mm`).
  *
- * P6 gate (qc1 F-001): without a conforming all-day
- * (`isAllDayConforming(config.rootChain)`) the winner is ALWAYS `'all-day'`
- * — a legacy multi-model (or empty) chain earns no slot rows, so every
- * surface fed by this resolver reports the inert state and routing stays on
- * the raw `rootChain` (the legacy walk verbatim).
+ * Gate: without a conforming entries tail (`isAllDayConforming(chain.entries)`)
+ * the winner is ALWAYS `'all-day'` — a multi-model (or empty) chain earns no
+ * slot rows, so every surface fed by this resolver reports the inert state and
+ * routing stays on the raw `entries`.
  */
-export declare function resolveSlotState(config: FallbacksConfig, now: Date, tz: string): {
+export declare function resolveSlotState(chain: NamedChain, now: Date, tz: string): {
     winner: SlotRowConfig | 'all-day';
     label: string;
 };

package/dist/tui-settings.d.ts

@@ -114,12 +114,11 @@ export declare const FALLBACKS_TUI_SECTION_NS = "fallbacks";
  */
 export declare const JSON_FIELD_MAX_DRAFT_BYTES: number;
 /**
- * The `fallbacks` /settings section: 12 fields covering all 14 web-card
- * capabilities (the default-model choice rides `rootChain`'s last entry and
- * the per-role fallback strategy rides `roles.list` JSON; the config-level
- * `enabled` switch is REMOVED — plan fallbacks-web-ux-alignment T2, the
- * Plugins-page row toggle is the master switch and the runtime gates read
- * content presence). Scalar
+ * The `fallbacks` /settings section covering the web-card capabilities
+ * (named virtual chains v2: ONE `Chains (JSON)` field over `chains` on the
+ * same bounded-parse machinery; `Roles (JSON)` keeps the chain POINTER; the
+ * v1 `rootChain` / top-level `timeSlots` / `roles.rules` fields are REMOVED
+ * with their mechanisms). Scalar
  * capabilities use native kinds (boolean/number/select); complex structures
  * use `text` fields with custom `format`/`parse` that mirror the gateway's
  * validation. Built fresh per call — the host deep-freezes whatever it