@mstar-harness/dsh 3.6.3 → 3.7.1

package/dist/gates/catalog.d.ts

@@ -14,7 +14,7 @@ export interface CatalogCacheEntry {
 }
 /**
  * The apply-scoped `harnessDir → cache key` reverse map + invalidation
- * closure (plan `20260811-panel-f4-timeliness` Task 2, decision D3): the
+ * closure : the
  * catalog cache is keyed by {@link EXPLICIT_CACHE_KEY} or the session cwd,
  * while ledger records (dispatch/settle) identify the affected workspace by
  * `{HARNESS_DIR}` — the reverse map bridges the two so a ledger change
@@ -96,10 +96,7 @@ export declare function buildCatalogSources(ctx: Context, harnessDir: string | n
  * workspace root and TTL-refreshed — Config `catalogTtlMs`).
  * @param ttlMs - catalog refresh interval in milliseconds.
  * @param register - the apply-scoped `harnessDir → cache key` reverse-map
- * registration (plan `20260811-panel-f4-timeliness` Task 2 — keeps every
- * workspace's entry invalidatable by a ledger change; see
- * `createCatalogInvalidation`).
- * @param digests - per agent+workspace turn digests (last rendered text)
+ * registration. * @param digests - per agent+workspace turn digests (last rendered text)
  * for the digest-gated re-emission.
  * @param payload - the proposed step the loop is about to enter.
  * @param next - the remaining pre-step chain; its value is the delegated decision.

package/dist/gates/dispatch.d.ts

@@ -11,14 +11,13 @@ export declare const DISPATCH_LOGGER = "mstar/dispatch-gate";
  * default id + its fork sibling — roadmap §9 W-B1: fork dispatches carry the
  * same Assignment-shaped `{ description, prompt }` args and must be gated
  * like `subagent`). Exported SHARED with the agent-flow settle pairing
- * (`registerSettleListener` matches the same tool set — plan
- * `20260811-panel-f4-timeliness` Task 1) so the default cannot drift between
+ * (`registerSettleListener` matches the same tool set) so the default cannot drift between
  * the gate and the settle seam.
  */
 export declare const DEFAULT_DISPATCH_TOOLS: readonly ["subagent", "subagent_fork"];
 /**
  * The fixed workflow/ralph tool names the workflow gate matches (plan
- * `20260815-dsh-workflow-gate` — architect-verified): the workflow tool
+ *   — architect-verified): the workflow tool
  * registers under Config-default name `'workflow'` and is RENAMEABLE per
  * instance (`toolName`, `tool-workflow/src/index.ts:41`); `ralph` is a
  * fixed name (`tool-ralph/src/index.ts:413`). A renamed instance is out
@@ -51,7 +50,7 @@ export interface DispatchGateAdvisory {
  * stay silent — no false-positive warnings. Callers MUST pass the engine
  * `assignmentHeaderRegion` slice: a `## Assignment` heading or
  * field line quoted in the task body must not shape a non-assignment prompt.
- * Exported for the agent-flow ledger's shape guard (qc2 F-2 — the shared
+ * Exported for the agent-flow ledger's shape guard — the shared
  * `DshHostAdapter.dispatchGate` core applies the SAME guard on both dispatch
  * surfaces, so the exec-less host-hook path records nothing for
  * non-Assignment text either).
@@ -65,7 +64,7 @@ export declare function isAssignmentShaped(assignmentText: string): boolean;
  * frontmatter, else warn-only.
  */
 export declare function resolveDispatchHard(harnessDir: string | null, config: Config, assignmentText: string): boolean;
-/** A header value that means "no value" (placeholder conventions). Type guard so callers narrow to `string`. Shared with the agent-flow ledger (qc1 F-003 — one grammar, no copy-paste drift). */
+/** A header value that means "no value" (placeholder conventions). Type guard so callers narrow to `string`. Shared with the agent-flow ledger  (one grammar, no copy-paste drift). */
 export declare function isNaValue(value: string | undefined): value is undefined;
 /**
  * Resolve the target plan id from the Assignment HEADER region: `Plan Path`
@@ -95,7 +94,7 @@ export declare function sessionIdOf(exec: ToolExecution): string | undefined;
  * whose plan row is `InProgress`.
  *
  * Contract (status-and-residuals.md § Pre-dispatch re-verify; v3
- * relocation — plan `20260819-workflow-dsh-viz` Task 3): before any
+ * relocation —): before any
  * writable implement dispatch, reread the ACTIVE workflow snapshot
  * (`workflows/<id>/snapshot.json` — the v1 root `plans[]` home is gone; the
  * root v2 `status.json` supplies the active `workflows[]`) and confirm
@@ -150,8 +149,7 @@ export declare function dispatchGateCore(config: Config, harnessDir: string | nu
 };
 /**
  * The workflow-gate input composed from one `workflow`/`ralph` tool call
- * (plan `20260815-dsh-workflow-gate` Task 1 — consumed by the Task 2 P-a /
- * P-c and Task 3 P-b policies): the tool name + the structural reads of
+ * : the tool name + the structural reads of
  * `meta` (workflow) / `objective` (ralph) + the in-flight call.
  */
 export interface WorkflowGateInput {
@@ -164,7 +162,7 @@ export interface WorkflowGateInput {
     /** The in-flight tool call — Task 3 P-b lease attribution reads the calling agent/session off it. */
     exec: ToolExecution;
     /**
-     * P-b lease attribution (plan Task 3): the calling workspace's first
+     * P-b lease attribution: the calling workspace's first
      * `InProgress` plan lacking `execution_lease` coverage (computed by
      * {@link writableFanOutUncovered} from the status.json read through the
      * contained resolver path — `preExecuteListener` already resolved the
@@ -177,7 +175,7 @@ export interface WorkflowGateInput {
 /**
  * Compose the {@link WorkflowGateInput} from one workflow/ralph tool call's
  * arguments — structural reads, NEVER throws (plan
- * `20260815-dsh-workflow-gate` Task 1; args shapes architect-verified:
+ *   Task 1; args shapes architect-verified:
  * workflow `{ script, meta: { name, description, whenToUse?, phases? },
  * args? }` (`tool-workflow/src/index.ts:152-161`); ralph
  * `{ objective, maxRounds?, maxHandoffChars? }`
@@ -187,7 +185,7 @@ export interface WorkflowGateInput {
  *
  * `meta.name` is NORMALIZED through {@link normalizeWorkflowName} (control
  * chars stripped) BEFORE the empty check — the P-c cache-key congruence
- * fold-in (plan Task 5): the run-start observation (workflow-ledger.ts)
+ * fold-in: the run-start observation (workflow-ledger.ts)
  * keys the ask cache with the SAME normalized name, so a control-char name
  * (`au\u0000dit`) asks once and observes under one key instead of re-asking
  * forever. The length is NEVER capped here (the gate's identity axis is

package/dist/gates/fallbacks-advisory.d.ts

@@ -1,7 +1,6 @@
 /**
  * Warn-only adoption advisory for the OPTIONAL `dsh-llm-fallbacks` plugin
- * (plan `20260815-dsh-fallbacks-personas` Task 4 + `20260816-dsh-b4-seeds`
- * Task 3): when the capability is mounted, ONE advisory pass per apply
+ * (plan   Task 4 +  when the capability is mounted, ONE advisory pass per apply
  * reports the deployment's fallbacks taxonomy state (bounded: ≤1 warn per
  * category, logger `mstar/fallbacks-advisory`):
  *
@@ -28,12 +27,18 @@
  *
  * Unreadable row config (absent field / non-object, or an unreadable
  * `roles.list`) → skip + one debug log. Unmounted → the pass is not invoked
- * (returns `false`, no logs). The advisory NEVER writes the fallbacks config
- * — the read is read-only over the deployment's config layer (never the
- * fallbacks plugin's module internals); the only write path is the
- * idempotent seeds re-declare through the released seeds surface (no-delta
- * → no settings write upstream). The advisory never throws (the caller's
- * dispatch/apply flow is never affected).
+ * (`{ ran: false, converged: false }`, no logs). An aborted pass (any caught
+ * error, including a rejected re-declare) reports `{ ran: true, converged:
+ * false }` — the honest latch: the caller arms its one-shot latch only on
+ * `ran && converged`, so a failed pass never suppresses the decision-point
+ * retry. The degraded-abort warn is deduplicated to at most ONE per apply
+ * (module flag; the entry resets it via {@link resetAdvisoryAbortWarn}).
+ * The advisory NEVER writes the fallbacks config — the read is read-only
+ * over the deployment's config layer (never the fallbacks plugin's module
+ * internals); the only write path is the idempotent seeds re-declare
+ * through the released seeds surface (no-delta → no settings write
+ * upstream). The advisory never throws (the caller's dispatch/apply flow is
+ * never affected).
  *
  * Module boundary: no barrel — the entry imports this module by explicit
  * relative path (the role-persona module pattern).
@@ -54,24 +59,56 @@ export declare function setAdvisoryLogger(sink: AdvisoryLogSink): AdvisoryLogSin
 /**
  * Warn id-list cap: an id-list warn line lists at most this many ids before
  * the `… and K more` suffix — a huge registry (thousands of rows) must not
- * produce a multi-KB log line (plan QC fix wave S-cap). Exported for the
+ * produce a multi-KB log line (cap). Exported for the
  * suite's cap assertions; module surface only — the entry's frozen 47-name
  * export surface deliberately does not re-export it.
  */
 export declare const ADVISORY_ID_LIST_CAP = 20;
 /**
- * One advisory pass: unmounted → not invoked (`false`, no logs); mounted →
- * report the taxonomy adoption state (bounded: ≤1 warn per category). With
- * the service present the pass is ASYNC: it awaits the idempotent re-declare
- * before the effective-state readback (report determinism — the boot
- * dual-inject-child race window is closed). Never throws — every failure
- * mode degrades to skip + one debug/warn. Never writes the fallbacks config.
+ * One advisory pass outcome (the honest-latch contract):
+ * - `ran` — the pass executed (the capability is mounted); `false` means the
+ *   pass was not invoked (unmounted). Carries the one-pass-per-apply
+ *   bookkeeping.
+ * - `converged` — the pass reached its converged end. Per return path:
+ *   unmounted → `false`; aborted pass (any caught error, including a
+ *   rejected re-declare) → `false`; a no-re-declare path (loader-fallback
+ *   structural read, unreadable config, or a service-present pass that
+ *   never reaches the re-declare) → `true`; service-present path → reflects
+ *   the re-declare resolving.
+ *
+ * The caller (entry `apply`) arms its one-shot latch only on
+ * `ran && converged` — a rejected re-declare must never suppress the
+ * `subagent/start` decision-point retry.
+ */
+export interface AdvisoryPassReport {
+    ran: boolean;
+    converged: boolean;
+}
+/**
+ * Reset the degraded-abort warn dedup flag (one warn per apply budget).
+ * Called by the entry at `apply` (next to the advisory sink binding) and in
+ * the `llm-fallbacks` inject child's teardown (a fiber swap re-opens the
+ * budget for the re-applied fiber). Exported for the suite's dedup case.
+ */
+export declare function resetAdvisoryAbortWarn(): void;
+/**
+ * One advisory pass: unmounted → not invoked (`{ ran: false, converged:
+ * false }`, no logs); mounted → report the taxonomy adoption state (bounded:
+ * ≤1 warn per category). With the service present the pass is ASYNC: it
+ * awaits the idempotent re-declare before the effective-state readback
+ * (report determinism — the boot dual-inject-child race window is closed).
+ * Never throws — every failure mode degrades to skip + one debug/warn, and
+ * an aborted pass reports `converged: false` (the honest latch). Never
+ * writes the fallbacks config.
  *
  * @param ctx - the plugin's registrant context (the app composition root).
  * @param agentsDir - the `harness-agents/` mirror root the mstar role-id set
  *   is derived from; absent → the taxonomy checks are skipped (one debug
  *   log; the legacy-keys check is mirror-independent and still runs).
- * @returns `true` when the pass ran (mounted), `false` when unmounted — the
- *   caller (entry `apply`) uses the boolean for the one-pass-per-apply latch.
+ * @returns the {@link AdvisoryPassReport} — `ran` marks a mounted pass (the
+ *   one-pass-per-apply bookkeeping), `converged` marks a pass that reached
+ *   its converged end; the caller (entry `apply`) arms the one-shot latch
+ *   only on `ran && converged`, so an aborted pass (e.g. a rejected
+ *   re-declare) never suppresses the decision-point retry.
  */
-export declare function runFallbacksAdvisory(ctx: Context, agentsDir: string | undefined): Promise<boolean>;
+export declare function runFallbacksAdvisory(ctx: Context, agentsDir: string | undefined): Promise<AdvisoryPassReport>;

package/dist/gates/fallbacks-probe.d.ts

@@ -1,6 +1,6 @@
 /**
  * Capability probes for the OPTIONAL `dsh-llm-fallbacks` plugin (plan
- * `20260814-dsh-fallbacks-integration` Task 1 — probe foundation).
+ *   Task 1 — probe foundation).
  *
  * The fallbacks plugin is an optional SEPARATE install (two-command
  * contract) and a dev-time-only dependency of this package: src carries
@@ -55,7 +55,7 @@ export declare function fallbacksService(ctx: Context): FallbacksServiceView | u
  * The fallbacks loader row when present and enabled (group rows skipped).
  * Unlike {@link fallbacksMounted}, NO live-fiber requirement: the entry is
  * declarative and `options.config` is set at entry creation, so the adoption
- * advisory (plan `20260815-dsh-fallbacks-personas` Task 4) can read the
+ * advisory  can read the
  * deployment's row config even during HMR/fiber-swap windows — the advisory
  * caller gates on `fallbacksMounted` first.
  */

package/dist/gates/fallbacks-seeds.d.ts

@@ -1,6 +1,6 @@
 /**
  * Zero-config seed declaration for the OPTIONAL `dsh-llm-fallbacks` plugin
- * (plan `20260816-dsh-b4-seeds` Task 2): when the `llm-fallbacks` service is
+ * : when the `llm-fallbacks` service is
  * applied, this module declares the 13 `mode: subagent` mstar roles into the
  * fallbacks seed registry — persona = mirror `description` (verbatim, the
  * SSOT stays `mstar-roles`) + one mandatory-load guide line.

package/dist/gates/fallbacks-structural.d.ts

@@ -1,6 +1,6 @@
 /**
  * Local structural mirrors of the consumed `dsh-llm-fallbacks` surface
- * (plan `20260831-dsh-alpha2-optional-fallbacks` Task 2). dsh natively
+ * . dsh natively
  * covers subagent customization, so the fallbacks
  * plugin is an OPTIONAL capability activated by the unchanged two-command
  * install contract — and a dev-time-only dependency of this package (type

package/dist/gates/goal-bridge.d.ts

@@ -4,7 +4,7 @@ import type { Config, HarnessResolver } from './_shared.ts';
 export declare const GOAL_BRIDGE_LOGGER = "mstar/goal-bridge";
 /**
  * Flat `maxGoalRounds` config fallback (architect decision — plan
- * `20260816-dsh-nb2-goal-bridge`): 256, aligned with the GoalService default
+ *  ): 256, aligned with the GoalService default
  * (`goal/src/index.ts:187`) and ralph `maxRounds` (`tool-ralph/src/index.ts:37`).
  */
 export declare const DEFAULT_MAX_GOAL_ROUNDS = 256;
@@ -46,8 +46,7 @@ export interface GoalView extends GoalRefView {
  * index.ts:244-257`); `complete` is a CAS by `{ id, revision }`
  * (`GOAL_STALE_REVISION` on stale). The drift path uses complete+create
  * (never `edit`) so each new iteration gets a FRESH goal with a clean
- * round budget (plan QC fix wave — qc2 W-1 / qc3 F-001/F-008).
- */
+ * round budget. */
 export interface GoalsServiceView {
     get(agent: unknown): GoalView | undefined;
     create(agent: unknown, request: {
@@ -74,8 +73,7 @@ export declare function iterationGoalObjective(iterationId: string): string;
  * `status` is `active` or `locked` — the directory name IS the iteration id
  * (plan-conventions `{ITERATION_DIR}/<id>/`). Completed/status-less/archived
  * compasses do not steer. Silent on any read failure (advisory degrade).
- * Shared with the planMode bridge via explicit no-barrel import (Task 4b —
- * the same "is an active iteration steering" read).
+ * Shared with the planMode bridge via explicit no-barrel import (the same "is an active iteration steering" read).
  * @param harnessDir - the resolved `{HARNESS_DIR}`.
  */
 export declare function steeringCompass(harnessDir: string): {
@@ -115,13 +113,12 @@ export declare function mirrorIterationGoal(agent: unknown, input: MirrorIterati
  * first root-like ancestor. `undefined` when unresolvable (fork lineage,
  * non-in-process provider, registry gap, or a cycle) — the decision point
  * then silently skips. Cycle guard: a `seen` set over visited session ids
- * (the upstream `liveLineage` guard — plan QC fix wave qc2 W-2 / qc3
- * F-003) breaks on ANY revisited id — a 1-hop self-loop, a 2+ hop cycle
+ * (the upstream `liveLineage` guard) breaks on ANY revisited id — a 1-hop self-loop, a 2+ hop cycle
  * (A→B→A), or a longer malformed lineage — instead of spinning forever on
  * the synchronous `subagent/start` decision-point listeners (reachable via
  * HMR remounts, resumed/forked sessions with stale headers, or a future
  * host change). Shared with the planMode bridge via explicit no-barrel
- * import (Task 4b — the same `subagent/start` decision-point root walk).
+ * import (the same `subagent/start` decision-point root walk).
  */
 export declare function rootAgentOf(agent: unknown, agents: AgentsView): unknown | undefined;
 /**
@@ -131,7 +128,7 @@ export declare function rootAgentOf(agent: unknown, agents: AgentsView): unknown
  * decision point — index.ts advisory slot), resolving the delegating ROOT
  * via the `parentSession` walk — the two mirror edges are idempotent (get +
  * compare when the mirror is in place — no churn) — plus a THIRD, advisory
- * listener on the `session/event` firehose (Task 3): a `goal/change`
+ * listener on the `session/event` firehose : a `goal/change`
  * envelope whose goal is blocked logs ONE warn (code + objective summary +
  * project-register residual pointer) with ZERO harness writes
  * (the one-way mirror; see {@link warnBlockedGoal}). The goals service is an

package/dist/gates/role-persona.d.ts

@@ -1,6 +1,5 @@
 /**
- * Native-first role-persona delivery (plan `20260831-dsh-alpha2-optional-fallbacks`
- * Task 3): a role-matched subagent start merges the persona into the request's
+ * Native-first role-persona delivery : a role-matched subagent start merges the persona into the request's
  * NATIVE `persona` slot (`@deepseek-ai/dsh-subagent`
  * `SubagentStartRequest.persona`) — the additive `mstar:role-persona`
  * system-prompt section is gone. Native semantics: the request persona
@@ -37,14 +36,20 @@
  * parsers the dispatch gate uses (`assignmentHeaderRegion` +
  * `parseAssignmentFields`) — over the start request's prompt text (the
  * `ContentBlock[]` the child receives as its first user message). Persona
- * lookup (plan `20260815-dsh-fallbacks-personas` Task 3) is the single
+ * lookup  is the single
  * {@link personaFor} surface — `Config.rolePersonas[executeAs]` →
  * `harness-agents/` mirror default → skip (never gated on `roleMap` or on
  * the fallbacks mounted state: persona delivery is fallbacks-independent).
  * `roleMap` is a taxonomy bridge for logging + future rule-driven interop
  * only. The mirror root is bound at apply (`setRolePersonaAgentsDir` ←
  * `packagedAgentsDir()`), package-relative so the shipped bundle works from
- * any launch cwd.
+ * any launch cwd. Lifetime: the root is a module-level binding with ONE
+ * writer — the per-apply `setRolePersonaAgentsDir` call — and it is read
+ * per start, so every start observes an apply-constant value; re-calling
+ * the setter (an HMR re-apply) IS the re-bind, and that re-bind is the
+ * intended reset (it also re-arms the mirror-absent latch below). The
+ * per-apply payload `Config.rolePersonas` is the contrast: closed over per
+ * apply in `registerRolePersonaChannel`.
  *
  * Capability gates (native fail-loud contracts, per surface): one-shot
  * `SubagentRuntime.start` REJECTS a request carrying `persona` for a
@@ -69,6 +74,22 @@
  * per apply (S-002 latch); a throwing merge aborts the merge only — the
  * ORIGINAL request reaches the service and the start is never affected.
  *
+ * Seam probe (apply-time, observation only): a future cordis rename/removal
+ * of `internal/get` would stop the listener from ever firing — persona
+ * delivery would silently degrade to the raw service with no runtime
+ * signal. {@link probeRolePersonaSeam} runs ONCE per apply right after
+ * {@link registerRolePersonaChannel}: a temporary canary listener + ONE
+ * controlled proxied read (`ctx.subagents` — NEVER `ctx.get`, whose accessor
+ * bypasses the waterfall and would false-warn every healthy boot) assert
+ * that the seam dispatched AND the returned value carries the wrapper brand.
+ * A broken seam warns ONCE per apply (fail-loud); an unresolved service is
+ * `service-absent` (`ok: true` + one debug — the apply ctx does not resolve
+ * `subagents`; cordis resolves the service in dispatch scopes, where reads
+ * are intercepted per read); any probe-internal error fails
+ * OPEN (`ok` + one debug) — the probe never throws and never blocks a
+ * dispatch. The decision core is the pure {@link evaluateSeamProbe}, so the
+ * whole outcome table is unit-pinnable without cordis internals.
+ *
  * Persona text is rendered by dsh system-prompt's STRICT `{{...}}`
  * interpolation (the native persona has the same template semantics as the
  * deployment persona), so persona values MUST NOT contain `{{` paired with
@@ -78,7 +99,12 @@
  * boot throw).
  *
  * Module boundary: no barrel — the entry imports this module by explicit
- * relative path and re-exports the public names verbatim. No dsh-subagent
+ * relative path and re-exports the public names verbatim, EXCEPT the four
+ * probe exports (`PERSONA_SEAM_EVENT`, `ROLE_PERSONA_WRAPPER_BRAND`,
+ * `evaluateSeamProbe`, `probeRolePersonaSeam`), which are deliberately NOT
+ * re-exported from the entry: the frozen entry surface keeps the probe
+ * observable only through this module (tests import it directly; the
+ * shipped bundle exports no probe symbol). No dsh-subagent
  * dependency: the runtime surface is consumed structurally (same pattern as
  * the probe's `LoaderEntryView` and T2's `fallbacks-structural.ts`).
  */
@@ -86,6 +112,23 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { Config } from './_shared.ts';
 /** Logger label for the role-persona channel (dsh logger naming: `<scope>/<subject>`). */
 export declare const ROLE_PERSONA_LOGGER = "mstar/role-persona";
+/**
+ * The interception seam: the cordis service-read waterfall event the channel
+ * listener registers on. The registration and the apply-time seam probe both
+ * reference THIS constant — a future cordis rename of `internal/get` becomes
+ * a one-line, probe-family-caught edit here instead of a silent delivery
+ * stop (the probe family pins the literal; see `probeRolePersonaSeam`).
+ */
+export declare const PERSONA_SEAM_EVENT = "internal/get";
+/**
+ * Wrapper brand — the non-enumerable symbol own property every persona
+ * wrapper carries (`wrapSubagentsService` stamps it at creation). The apply-
+ * time seam probe reads it to assert the wrapper was actually installed on
+ * the controlled read. Non-enumerable + symbol keeps the wrapper's
+ * key/spread/JSON surface identical to the wrapped service's (behavior-
+ * neutral by construction).
+ */
+export declare const ROLE_PERSONA_WRAPPER_BRAND: symbol;
 /** One consumed prompt content block (`@deepseek-ai/dsh-llm` `ContentBlock` text members). */
 interface PromptBlockView {
     readonly type: string;
@@ -167,8 +210,14 @@ export type RolePersonaLogSink = (level: RolePersonaLogLevel, message: string) =
  */
 export declare function setRolePersonaLogger(sink: RolePersonaLogSink): RolePersonaLogSink;
 /**
- * Bind the persona-defaults mirror root. Returns the PRIOR binding so a
- * caller can restore it (test pattern: {@link setRolePersonaLogger}).
+ * Bind the persona-defaults mirror root — the module sink's only writer,
+ * invoked once per apply from the entry with `packagedAgentsDir()`, so an
+ * HMR re-apply re-binds the root instead of inheriting the previous
+ * apply's binding. That re-bind is the intended reset: beyond swapping the
+ * root it re-arms the S-002 mirror-absent latch (`mirrorAbsentDebugged`),
+ * keeping the "no mirror" debug at most once per apply, and the returned
+ * PRIOR binding lets a caller restore the previous root (test pattern:
+ * {@link setRolePersonaLogger}).
  * @param dir - the mirror root, or `undefined` to disable mirror defaults.
  */
 export declare function setRolePersonaAgentsDir(dir: string | undefined): string | undefined;
@@ -188,4 +237,71 @@ export declare function setRolePersonaAgentsDir(dir: string | undefined): string
  *   only payload source; `roleMap` is never consulted for the merge).
  */
 export declare function registerRolePersonaChannel(ctx: Context, config: Config): void;
+/** Outcome of one apply-time seam probe ({@link probeRolePersonaSeam}). */
+export interface PersonaSeamProbeResult {
+    /** `true` = the channel is healthy OR the probe failed open (never block apply). */
+    ok: boolean;
+    /**
+     * Why the probe classified the channel the way it did. `ok: false` ALWAYS
+     * carries a reason; `service-absent` may appear with `ok: true` (the
+     * sanctioned no-warn unresolved-service classification).
+     */
+    reason?: 'seam-absent' | 'wrap-skipped' | 'service-absent';
+}
+/** One probe observation — the inputs of the pure decision core. */
+export interface SeamProbeInputs {
+    /** Whether the temporary canary listener fired during the controlled read. */
+    dispatched: boolean;
+    /** The value the controlled read threw (`undefined` = the read resolved). */
+    readError: unknown;
+    /** The controlled read's resolved value (`undefined` when the read threw). */
+    value: unknown;
+}
+/**
+ * Pure decision core of the seam probe — the ENTIRE outcome table, unit-
+ * pinnable without cordis internals:
+ *
+ * - canary silent → `{ ok: false, reason: 'seam-absent' }` — cordis no
+ *   longer dispatches the seam; our listener can never run. Dominates the
+ *   other inputs (a silent canary means the delivery channel is gone).
+ * - canary fired + read threw → `{ ok: true, reason: 'service-absent' }` —
+ *   the seam works but the reading ctx does not resolve `subagents` (on the
+ *   real composition the apply ctx is inject-guarded; cordis resolves the
+ *   service in dispatch scopes, where reads are intercepted per read). Never
+ *   a warn.
+ * - canary fired + branded value → `{ ok: true }` — healthy.
+ * - canary fired + any other resolved value (unbranded object, primitive,
+ *   undefined) → `{ ok: false, reason: 'wrap-skipped' }` — the listener ran
+ *   but the shape was unrecognized (the `wrapSubagentsService` pass-through).
+ */
+export declare function evaluateSeamProbe({ dispatched, readError, value }: SeamProbeInputs): PersonaSeamProbeResult;
+/**
+ * Apply-time seam probe — runs EXACTLY ONCE per apply, immediately after
+ * {@link registerRolePersonaChannel} (entry wiring), and classifies the
+ * channel's install state per {@link evaluateSeamProbe} (observation only —
+ * it never changes delivery semantics):
+ *
+ * 1. register a TEMPORARY {@link PERSONA_SEAM_EVENT} canary listener
+ *    (`(ctx, name, error, next) => { dispatched = true; return next() }`),
+ *    keeping the disposer `ctx.on` returns;
+ * 2. perform ONE controlled proxied read `ctx.subagents` inside try/catch —
+ *    the exact read path the per-call `ctx.subagents.start(...)` dispatch
+ *    takes. NEVER `ctx.get('subagents')`: the accessor reads the service
+ *    store directly and bypasses the waterfall, which would false-warn
+ *    `seam-absent` on every healthy boot;
+ * 3. dispose the canary SYNCHRONOUSLY (`finally` — also on the throwing
+ *    read path);
+ * 4. classify via {@link evaluateSeamProbe} and log: `ok === false` → ONE
+ *    warn ({@link SEAM_WARN} + reason); `service-absent` → one debug; a
+ *    healthy probe stays silent.
+ *
+ * Contained failure: the body is fully try/catch-wrapped — any probe-
+ * internal error (e.g. a rejected listener registration) fails OPEN with
+ * `{ ok: true }` plus ONE debug naming the error. Never throws out of
+ * `apply`; never affects a subagent start.
+ *
+ * @param ctx - the plugin's registrant context (a runtime-bearing context —
+ *   proxied property reads on it dispatch the seam waterfall).
+ */
+export declare function probeRolePersonaSeam(ctx: Context): PersonaSeamProbeResult;
 export {};

package/dist/gates/skill-lint.d.ts

@@ -56,9 +56,21 @@ export declare class SkillLintVetoError extends Error {
  * CLI `mstar skill lint` combination plus the ephemeral-citation gate;
  * violation codes `lint.frontmatter.*` / `skill-authoring.five-question.*`
  * / `skill.ephemeral.*`). Pure: no enforcement, no I/O.
+ *
+ * Five-question profile (spec A4): the shared Engine classifier
+ * (`classifySkillLint`) selects the mode from `options.skillId` — the
+ * trusted resolved skill-target basename passed by the fs-intent path and
+ * `lintSkillWrite`. A doc-only call (no `skillId`) stays strict authoring —
+ * the greenfield default is never loosened by an unparented document. The
+ * frontmatter and ephemeral-citation checks run in every profile; `core`
+ * (exact `mstar-harness-core`) skips only the five-question check.
  * @param doc - the full SKILL.md text.
+ * @param options - `skillId`: the resolved skill-target directory basename
+ * (trusted boundary identity — never the doc's YAML `name` alone).
  */
-export declare function lintSkillDoc(doc: string): GateResult;
+export declare function lintSkillDoc(doc: string, options?: {
+    skillId?: string;
+}): GateResult;
 /**
  * Enforce the skill-authoring lints over a KNOWN document (the brief's
  * "incoming doc when available" branch): `Enforcement: hard` + violations →
@@ -68,8 +80,13 @@ export declare function lintSkillDoc(doc: string): GateResult;
  * needed on this branch. The content-blind listener path (where the
  * incoming doc is never visible) routes through {@link gateSkillIntent}
  * instead, which applies the status-gate repair-escape decision.
+ *
+ * The lint profile is classified from the trusted resolved skill-target
+ * basename (spec A4): `basename(dirname(resolve(options.target)))` — the
+ * write's own target, never the document's YAML `name`.
  * @param doc - the document about to be written (the write's content).
- * @param options - target display path (veto message) + resolved hard flag.
+ * @param options - target display path (veto message + profile identity) +
+ * resolved hard flag.
  */
 export declare function lintSkillWrite(doc: string, options: {
     target: string;

package/dist/gates/system-prompt.d.ts

@@ -1,11 +1,8 @@
 /**
- * Harness-rules system-prompt injection (plan `20260816-dsh-nb1-systemprompt`
- * Task 2): the root session's ONE `mstar:harness-rules` pointer section plus
- * the `mstar:engine-status` runtime-context summary, both registered on the
- * GLOBAL prompt layer — visible to the root session AND every dispatched
+ * Harness-rules system-prompt injection (visible to the root session AND every dispatched
  * child — on their own names and layers (the child persona rides the NATIVE
  * subagent persona channel since plan
- * `20260831-dsh-alpha2-optional-fallbacks` Task 3 — no child-scoped
+ *   Task 3 — no child-scoped
  * `mstar:role-persona` section exists anymore; duplicate-name throws remain
  * per name per layer, verified `scope/src/store.ts`).
  *
@@ -18,13 +15,13 @@
  *   interpolation and throws on unknown/malformed/undefined references
  *   (`interpolate` in `@deepseek-ai/dsh-system-prompt`), so every injected
  *   string must carry no complete group. The mechanism is LIVE, not static
- *   (plan QC fix wave W-1): every operator-controlled value embedded below
+ *   : every operator-controlled value embedded below
  *   (harness dir, plan ids, iteration id, lease fields, direction prose)
  *   is passed through `stripInterpolationHazard` — complete `{{…}}` groups
  *   are screened so a hostile value can never break prompt assembly, while
  *   a lone `{{` stays literal prose.
  * - The harness dir is resolved PER ASSEMBLY from the assembly context's
- *   agent (plan QC fix wave W-2 — the catalog pre-step precedent): the
+ *   agent : the
  *   session cwd of the agent whose prompt is being assembled, via
  *   `resolver.forAgent`, with the boot value (`forWorkspace(undefined)`,
  *   the explicit config or null) as the fallback when the assembly carries
@@ -39,13 +36,12 @@
  *   re-registration, in zero-config and explicit-config deployments alike.
  * - The context provider reuses the catalog's unified machine-summary
  *   source (`buildCatalogSources` — the SAME builder the engine-status
- *   pre-step catalog row uses) and projects the SLIM digest (plan
- *   `20260820-dsh-engine-status-slim` Task 2): the version watermark
+ *   pre-step catalog row uses) and projects the SLIM digest: the version watermark
  *   ALWAYS, plus ONE `workflow … | plans: …` line only when the active set
  *   selects a lifecycle (`state.selection.kind === 'active'`). Harness dir
  *   and enforcement live in `mstar:harness-rules`; residuals / leases /
  *   direction / iteration-gate detail stay exclusive to the pre-step row.
- *   v3 (plan `20260819-workflow-dsh-viz` Task 3): the
+ *   v3 : the
  *   digest reads ONLY the catalog row (`state` — itself aggregated from the
  *   SELECTED workflow snapshot + project registers) — no direct
  *   status.json / snapshot file reads to change. The build is TTL-memoized
@@ -64,7 +60,7 @@
  * - Registration is deferred through `ctx.inject(['systemPrompt'], …)`
  *   (HMR-safe re-apply): the `section()`/`context()` calls run on the
  *   inject child, and the exact disposers they return are collected on
- *   that child via `systemPromptCtx.effect` (plan QC fix wave W-HMR) — the
+ *   that child via `systemPromptCtx.effect`  — the
  *   registrations therefore unwind with THIS plugin's apply by explicit
  *   ownership, so a re-apply disposes the old registrations before
  *   registering fresh ones (no duplicate-name throw, no stale closure from

package/dist/gates/tools.d.ts

@@ -18,7 +18,7 @@ import { HarnessResolver } from './_shared.ts';
 export declare function registerSddIterationTools(ctx: Context, resolver: HarnessResolver): void;
 /**
  * Register the on-demand seam validation tools (
- * 20260808-dsh-seams-bundle): `mstar design-md validate` / `mstar compound
+ * : `mstar design-md validate` / `mstar compound
  * validate` CLI mirrors plus the audit / roles validators — thin wrappers
  * running the engine in-app. The registrations are deferred with
  * `ctx.inject(['tools'], …)` (same optional-unit pattern as the sdd tools),