@avantf/dsh-mission 0.3.0

package/lib/types/client/contract.d.ts

@@ -0,0 +1,209 @@
+/**
+ * The client half's own vocabulary, declared here rather than imported from
+ * `@avantf/mission-core`: the browser bundle must not pull the host engine in.
+ * @module @avantf/dsh-mission/client/contract
+ */
+/**
+ * Why a node is queued instead of running, as the host reports it. The browser half's own copy (it
+ * must not import the engine); `null`/absent on the node means nothing is holding it back.
+ */
+export interface WaitingForView {
+    readonly reason: 'capacity' | 'unit' | 'slot' | 'aging';
+    /** Which capacity signal, when `reason` is `capacity`: compute units or the free-memory floor. */
+    readonly resource?: 'cpu' | 'memory';
+    readonly needed?: number;
+    readonly available?: number;
+    readonly unit?: string;
+}
+export interface MissionNodeView {
+    readonly id: string;
+    /** Where the node was born; `children` is the dependency edge it is rendered by. */
+    readonly parentId: string | null;
+    /** The ids this node depends on (a reused prerequisite appears in several parents). */
+    readonly children: readonly string[];
+    readonly depth: number;
+    readonly title: string;
+    /** Why this mission exists (written by whoever decomposed its parent). In the ROW projection the
+     *  texts are no longer carried (a current host sends `[]`); the detail dialog has every one. A
+     *  non-empty array is what an OLDER host still sends, and {@link contextCount} falls back to it. */
+    readonly context: readonly string[];
+    /** How many premises the mission carries — the row's marker. The detail dialog renders the texts. */
+    readonly contextCount?: number;
+    /** The owner's corrections, newest last. A row renders the count as a "steered" marker: the title
+     *  above is the goal as created, so a corrected mission needs this to be readable at all. Capped to
+     *  the newest few by a current host; {@link correctionCount} is the true number. */
+    readonly corrections: readonly string[];
+    /** The owner's FULL correction count, including any past the row cap. Optional so a client built
+     *  before this field still renders (the badge falls back to `corrections.length`). */
+    readonly correctionCount?: number;
+    readonly status: string;
+    readonly attempts: number;
+    readonly createdAt: number;
+    /** When this node was FIRST dispatched, or `null` while it is still queued. Optional because an
+     *  older host does not send it, and absence reads exactly like `null` (= never dispatched). */
+    readonly dispatchedAt?: number | null;
+    /** When this node reached a terminal status, or `null` while it is still in play. Optional for the
+     *  same reason as {@link dispatchedAt}. */
+    readonly endedAt?: number | null;
+    readonly hasResult: boolean;
+    readonly resultRef: string | null;
+    /** The session that ran this node LAST, or `null` when none ever did. Carried in the ROW
+     *  projection as well as the detail so a row can offer "open the executor" without a second read.
+     *  It is a DISPLAY address kept after the session ended (the panel's node-id entry opens it), so it
+     *  is not the same thing as "is running now" — that is {@link workerLive}. */
+    readonly workerSessionId: string | null;
+    /** Whether {@link workerSessionId} is still running: the node-id entry uses it to say 进行中 or
+     *  已结束. Optional because an older host does not send it, and absence reads as "not live". */
+    readonly workerLive?: boolean;
+    /** Declared capacity weight (cores-equivalent); an older host omits it and reads as 1. */
+    readonly weight?: number;
+    /** Why this node is queued; absent/`null` means nothing is holding it back. */
+    readonly waitingFor?: WaitingForView | null;
+}
+export interface MissionTreeViewData {
+    readonly rootId: string;
+    readonly nodes: readonly MissionNodeView[];
+    /** Epoch millis when the owner archived the tree; `null` while it is live. */
+    readonly closedAt: number | null;
+}
+export interface MissionSnapshot {
+    readonly trees: readonly MissionTreeViewData[];
+    /**
+     * The host's reported wire revision (`wire.ts`'s `SNAPSHOT_WIRE_VERSION`), carried forward so a
+     * later click can refuse to call a method this host never registered. `undefined` means the host
+     * predates the marker, which is the same vintage as the oldest revision.
+     */
+    readonly wire?: number;
+    /**
+     * A version-skew note from the host half — set when the payload's `wire` marker is absent (older
+     * host) or unknown (newer host). The trees are still rendered: the marker is a note, not a failure.
+     */
+    readonly skew?: string;
+}
+export interface MissionSnapshotState {
+    readonly data: MissionSnapshot | undefined;
+    readonly loading: boolean;
+    readonly error: string | undefined;
+    readonly refresh: () => Promise<void>;
+}
+export interface MissionNodeDetailView {
+    readonly id: string;
+    readonly rootId: string;
+    readonly title: string;
+    readonly description: string;
+    /** Why this mission exists — the premise the decomposer attached (the owner's initial judgement,
+     *  for a root). NOT the same as `description`, which is what the mission must achieve. */
+    readonly context: readonly string[];
+    /** What this mission's executors recorded with `note_mission` before splitting it: the blocker, the
+     *  paths ruled out, what the prerequisites have to settle. Oldest first; appended, never replaced. */
+    readonly analysisNotes: readonly string[];
+    /** The `attempts` value of the dispatch that wrote the LAST analysis note; `0` when there is none. */
+    readonly analysisAttempt: number;
+    /** The direction changes this mission was given, newest last — rendered between the goal and the
+     *  result so the two can be read together rather than as a mismatch. */
+    readonly corrections: readonly string[];
+    readonly status: string;
+    readonly attempts: number;
+    readonly depth: number;
+    /** When this node was accepted into the tree. Optional: an older host does not send it, and the
+     *  dialog's timing line then prints 「受理 —」 rather than invented epoch time. */
+    readonly createdAt?: number | null;
+    /** When this node was FIRST dispatched, or `null` while it is still queued. The detail dialog shows
+     *  the full 受理/派发/结束 line; the row shows the compact form. Optional for the same reason as the
+     *  row projection's copy. */
+    readonly dispatchedAt?: number | null;
+    /** When this node reached a terminal status, or `null` while it is still in play. */
+    readonly endedAt?: number | null;
+    /** The mission's own submitted result, or null while it has not submitted one. */
+    readonly result: string | null;
+    /** Where an oversized result was spilled, so the reader can still open it. */
+    readonly resultPointer: string | null;
+    /** The session that ran this node LAST, or `null` when none ever did. This is the NODE's executor
+     *  — a different id from `id`, which names the mission. A node whose attempt was reclaimed, or one
+     *  that finished, still carries its LAST executor here on purpose: the panel's node-id entry opens
+     *  that session, and a finished mission is exactly when a reader wants to look back at it. */
+    readonly workerSessionId: string | null;
+    /** Whether {@link workerSessionId} is still running (see the row projection's copy). */
+    readonly workerLive?: boolean;
+    /** Declared capacity weight (cores-equivalent); an older host omits it and reads as 1. */
+    readonly weight?: number;
+    /** Why this node is queued; absent/`null` means nothing is holding it back. */
+    readonly waitingFor?: WaitingForView | null;
+}
+export interface MissionNodeDetailChild {
+    readonly id: string;
+    readonly title: string;
+    readonly status: string;
+    readonly result: string | null;
+    readonly resultPointer: string | null;
+}
+/** What a clicked row expands into. Read on demand, never part of the snapshot. */
+export interface MissionNodeDetail {
+    readonly node: MissionNodeDetailView;
+    readonly children: readonly MissionNodeDetailChild[];
+}
+/**
+ * One worker session as the host's optional `uiWorkspace.openSession` takes it: the durable
+ * parent/child address of a *continuable* subagent — the same target the main UI sends when a child
+ * is picked from the "N 个子智能" dropdown. Declared structurally rather than imported from the
+ * host's `dsh-api-session-controller` types, like the rest of this file: the browser bundle must not
+ * take a dependency on a host package's client types.
+ */
+export interface WorkerSessionTarget {
+    readonly parentSessionId: string;
+    readonly childSessionId: string;
+    readonly mode: 'continuable';
+}
+/**
+ * What a CLICK-TIME executor lookup answered (W18), as the view consumes it. `resolved` carries the
+ * session to open; the other three are the distinguishable ways there is nothing to open, which the
+ * view renders as different sentences:
+ *
+ * - `never-dispatched` — the record proves no session ever ran this node;
+ * - `not-found` — it ran once, and the session is gone (cleaned up, or its log is not on this host);
+ * - `unsupported` — this host cannot look anything up at all (no session service, or an older host
+ *   whose Remote face predates the method).
+ */
+export interface ExecutorSessionLookup {
+    readonly status: 'resolved' | 'never-dispatched' | 'not-found' | 'unsupported';
+    /** Present when `status` is `resolved`. */
+    readonly sessionId?: string;
+    /** The host's own words when it has any (a missing service, a failed listing). */
+    readonly error?: string;
+}
+export interface MissionViewProps {
+    /** Read the current snapshot and keep it updated. */
+    readonly useSnapshot: () => MissionSnapshotState;
+    /** Delete one whole finished mission tree by root; rejects with the host's reason, which the view shows. */
+    readonly onDeleteTree: (rootId: string) => Promise<void>;
+    /**
+     * Delete EVERY closed (finish_mission-archived) tree this session owns, in one batch — the panel's
+     * "清理已完成". ABSENT when this host has no such call (an older host): the button is then not
+     * rendered at all rather than offered and doomed. Rejects with the host's reason, which the view
+     * shows; resolves to the two root-id lists the host reported so the panel can say what happened.
+     */
+    readonly onCleanFinished?: () => Promise<{
+        deleted: readonly string[];
+        skipped: readonly string[];
+    }>;
+    readonly loadDetail: (nodeId: string) => Promise<MissionNodeDetail>;
+    /** Read the FULL text behind a spilled result; rejects with the host's reason, which the pane shows. */
+    readonly loadResult: (nodeId: string) => Promise<string>;
+    /** The owner session these trees belong to — the PARENT half of a worker-session address. */
+    readonly sessionId: string;
+    /**
+     * Ask the host to open the session that ran a mission. ABSENT when this host has no `uiWorkspace`
+     * service — the id then renders as plain text, never as a dead link, and everything else in the
+     * panel keeps working. `uiWorkspace` is fetched optionally for exactly this reason: a host without
+     * it must still mount this plugin (see `client/index.ts`, and `inject` there deliberately omits it).
+     */
+    readonly openWorkerSession?: (target: WorkerSessionTarget) => void;
+    /**
+     * Find the session that ran a node whose record has no handle (W18). Called ONLY from a click —
+     * it is a Remote call whose server side lists sessions and reads a few logs, so nothing on the
+     * render path may touch it. Rejecting means "the lookup itself failed"; a `not-found`/`unsupported`
+     * ANSWER is a result, not an error.
+     */
+    readonly resolveWorkerSession?: (nodeId: string) => Promise<ExecutorSessionLookup>;
+}
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/client/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/client/contract.ts"],"names":[],"mappings":"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"}

package/lib/types/client/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `@avantf/dsh-mission` — the browser half: one `conversation.view` tab ("任务") rendering
+ * this session's mission trees. Inject `remote`, never `remote.avantfMission` (a namespace only
+ * exists after its own contribution mounts, and boot's `assertEntriesActive` throws on an
+ * entry waiting for a missing service); the hand-written contribution is mounted here.
+ * @module @avantf/dsh-mission/client
+ */
+import { type ReactNode } from 'react';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** Cordis plugin name; matches the host half. */
+export declare const name = "avantf-mission";
+/** Required client services; the Remote namespace itself is intentionally absent (see above). */
+export declare const inject: string[];
+/**
+ * The slice of the client Context this half uses, declared structurally: an installed dsh
+ * ships no `ui-slots` package (the browser shell seeds it into the module table), so the
+ * seat's real types are not resolvable from what the running host shares.
+ */
+interface ClientContext {
+    effect(callback: () => (() => void) | void, label?: string): void;
+    logger: {
+        error(message: string): void;
+    };
+    locale: {
+        register(namespace: string, dictionaries: Record<'zh' | 'en', Record<string, string>>): () => void;
+        bind(namespace: string): (key: string) => string;
+    };
+    remote: {
+        $mount(contribution: unknown): Promise<() => Promise<void>>;
+    };
+    get(name: string): unknown;
+    slots: {
+        inject(name: string, register: () => void): void;
+        register(options: {
+            name: string;
+            id: string;
+            order: number;
+            locale: string;
+            label: () => string;
+        }, component: (props: {
+            sessionId: SessionId;
+        }) => ReactNode): void;
+    };
+}
+/** Client plugin body: mount this package's Remote face, register the tab. */
+export declare function apply(ctx: ClientContext): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAyE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC7G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAuB/D,iDAAiD;AACjD,eAAO,MAAM,IAAI,mBAAmB,CAAA;AAEpC,iGAAiG;AACjG,eAAO,MAAM,MAAM,UAAgC,CAAA;AAWnD;;;;GAIG;AACH,UAAU,aAAa;IACrB,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjE,MAAM,EAAE;QAAE,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;IACxC,MAAM,EAAE;QACN,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,IAAI,CAAA;QAClG,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;KACjD,CAAA;IACD,MAAM,EAAE;QAAE,MAAM,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;KAAE,CAAA;IACvE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAC1B,KAAK,EAAE;QACL,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;QAChD,QAAQ,CACN,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,MAAM,CAAA;SAAE,EACzF,SAAS,EAAE,CAAC,KAAK,EAAE;YAAE,SAAS,EAAE,SAAS,CAAA;SAAE,KAAK,SAAS,GACxD,IAAI,CAAA;KACR,CAAA;CACF;AAkLD,8EAA8E;AAC9E,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAgK9C"}

package/lib/types/client/seat.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reading the HOST's seat hooks defensively.
+ *
+ * The seat hands this plugin the installed runtime's own snapshot shapes, and this plugin only
+ * DECLARES them structurally — nothing here is checked against the host at mount time. A field the
+ * running dsh no longer has makes the selector throw, and the selectors below are called in a
+ * component body: the shell's slot error boundary then renders an empty `<div>` (no text at all) and
+ * does not retry within the session, so the panel stays blank while every host-side gate is green.
+ *
+ * That is not hypothetical: dsh 0.1.6 dropped `SessionSnapshot.queue`, and the declared peer range
+ * (`^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2`) admits 0.1.6. The compat gate covers the host half
+ * only — services, typert faces, the version table — so the browser half's seat props need their own
+ * guard, and it is this file: every field read off a seat hook goes through a reader, and an absent
+ * field yields a NEUTRAL constant (not a fresh value per render, so the derived revision stays stable
+ * instead of flapping).
+ */
+/** What this plugin reads off the seat's session snapshot. Every field is optional: the host owns it. */
+export interface SeatSessionView {
+    readonly queue?: readonly unknown[];
+    readonly running?: boolean;
+}
+/** How many prompts the session has queued, or -1 when the running dsh exposes no queue. */
+export declare function queuedCount(session: SeatSessionView | undefined): number;
+/** Whether the session is running; an absent (or non-boolean) field reads as "not running". */
+export declare function isRunning(session: SeatSessionView | undefined): boolean;
+//# sourceMappingURL=seat.d.ts.map

package/lib/types/client/seat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seat.d.ts","sourceRoot":"","sources":["../../../src/client/seat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,yGAAyG;AACzG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CAExE;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,GAAG,OAAO,CAEvE"}

package/lib/types/client/styles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Inject once per document: the view remounts on every session switch, and a second
+ * `<style>` per mount would grow the document without limit.
+ */
+export declare function INSTALL_STYLES(): void;
+//# sourceMappingURL=styles.d.ts.map

package/lib/types/client/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/client/styles.ts"],"names":[],"mappings":"AAwKA;;;GAGG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAQrC"}

package/lib/types/coldResume.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The HOST half of session continuation: waking a session that already knows the mission instead of
+ * starting a fresh executor.
+ *
+ * Two wakes share this file because they share the whole protocol — guard, ADOPT, DELIVER, and a
+ * refusal that is never allowed to spawn on top of a live binding:
+ *
+ * - the PARKED wake — the executor that decomposed a node parked itself on it, and is woken (by the
+ *   owner's pre-step, the one turn where the authorizing parent is guaranteed materialized) once
+ *   every child is terminal;
+ * - the COLD wake — a restart demoted a `running` node and left `lastWorkerId`, so the engine's
+ *   dispatch pass first tries to continue that session before reserving a claim for a new one.
+ *
+ * Why this is its own module rather than four methods on the host: it is a clean, self-contained
+ * concern (the core-side `continuation.ts` delta, the `adoptParked`/`adoptContinuation` tree
+ * transitions, and this delivery seam are the three halves of one feature), and the host is the
+ * plugin's only continuously growing hub. `host.ts` keeps thin delegations and hands in exactly the
+ * state below — the same shape `workerSessions.ts` uses for its commands, so "what this needs from
+ * the host" is explicit rather than "everything on `this`".
+ *
+ * The delivery rides `ctx.subagents.sendMessage` to a child that may not be resident: `dsh-subagent`'s
+ * `materialize` ("create OR resume one child Agent") calls `agents.resume({ resumeSessionId })`, the
+ * same code path for "the residency was released" and "the process restarted and the session is being
+ * rebuilt from disk". There is no second protocol here, and no new session API.
+ *
+ * Host-side state is passed by reference on purpose: the wake guards (`wakingClaims`) and the claim
+ * sets are the SAME objects the rest of the host reads, so a wake delivered from here is seen by the
+ * sweep exactly as it was before the extraction.
+ *
+ * @module @avantf/dsh-mission/coldResume
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import type { SubagentSendMessageOptions } from '@deepseek-ai/dsh-subagent';
+import { type MissionEngine, type MissionTree, type NodeRecord, type ResumeOutcome, type ResumeWorkerInput, type WellFormedSource } from '../mission-core/index.js';
+import type { MissionLogger } from './log.js';
+/**
+ * What the two wakes need from the host. Declared as a narrow port (not `this`) so the module cannot
+ * reach into anything else — every member below is read by the moves, and nothing here is a
+ * convenience accessor.
+ */
+export interface ColdResumeDeps {
+    /** The tree, or `undefined` before start-up has opened one (the parked wake's early exit). */
+    readonly tree: MissionTree | undefined;
+    /** The tree, throwing when start-up has not opened one (the cold wake's precondition). */
+    requireTree(): MissionTree;
+    /** The engine, read for ONE admission-policy snapshot per parked-wake pass. */
+    readonly engine: MissionEngine | undefined;
+    /** Live agents, by session id: the owner must be materialized before anything can be delivered. */
+    readonly agents: {
+        get(id: SessionId): Agent | undefined;
+    };
+    /** The delivery seam; a non-resident child is materialized (or resumed) by the runtime. */
+    readonly subagents: {
+        sendMessage(sender: Agent, targetId: SessionId, content: ContentBlock[], options: SubagentSendMessageOptions): Promise<unknown>;
+    };
+    readonly log: MissionLogger;
+    readonly wellFormed: WellFormedSource;
+    /** Sessions whose wake is in flight; live from the adoption until the resumed agent is observed. */
+    readonly wakingClaims: Set<string>;
+    /** Parked nodes the owner has already been told about; dropped when the node is actually woken. */
+    readonly parkedSignaled: Set<string>;
+    /** Owner sessions this host has dispatched a worker for (hook scoping). */
+    readonly dispatchedFor: Set<string>;
+    /** Every claim id this process has issued. */
+    readonly issuedClaims: Set<string>;
+    /** Claims bound but not yet accepted by the child. */
+    readonly startingClaims: Set<string>;
+    trace(message: string): void;
+    /** Publish a change for one tree, by its root id. */
+    announceTree(rootId: string): void;
+    /** Clear the starting guard for a claim whose start attempt is over. */
+    endStartAttempt(claimId: string): void;
+    /** Stamp the prompt a session was just handed; tolerant, and defined on the host (`startWorker`
+     *  uses it too). */
+    recordBaseline(nodeId: string, holder: string): Promise<void>;
+    /** Start a fresh executor; the callers here deliberately do not await it. */
+    startWorker(node: NodeRecord, claimId: string): Promise<void>;
+}
+/**
+ * Wake every parked session whose children have landed. Called from the owner's pre-step, and only
+ * there: that turn is the one place the owner is guaranteed materialized, and the only Agent the
+ * continuation protocol accepts as the authorizing parent (`authorizeLineage`).
+ *
+ * Order per node is fixed: ADOPT (bind `claimedBy`) before delivering — a woken session can call
+ * `submit_mission` immediately, which authorizes on `claimedBy === caller`. A failed delivery gets no
+ * retry: undo the adoption (`wake-failed`, charging neither failure counter, no cooldown) and
+ * dispatch fresh; `attempts` advances, being the `note_mission` generation marker, not a budget.
+ *
+ * Both binding paths go through the ENGINE's admission policy (`engine.admissionPolicy()`), not a
+ * host-side reading of capacity: the parked wake is the most common binding path there is (an owner's
+ * pre-step), and it used to adopt with no policy at all, which means no capacity recheck and a
+ * machine that could be oversubscribed by wakes while the dispatch loop carefully respected the
+ * gate. A refusal is the same deferral every other path gets: the node stays `ready`, the address
+ * stays on it, nothing is charged, and the next pass retries.
+ */
+export declare function wakeParkedWorkers(deps: ColdResumeDeps, agent?: Agent): Promise<number>;
+/**
+ * Try to continue a node in the session recorded when an interruption demoted it (`lastWorkerId`)
+ * instead of starting a fresh executor — the "cold wake" of a mission that survived a restart.
+ * Reached from the engine's dispatch pass, before any claim is reserved; returns whether the node
+ * was dispatched by this call, must be left alone, or needs the ordinary fresh path.
+ *
+ * The delivery rides the seam the parked wake already uses: `ctx.subagents.sendMessage` to a
+ * non-resident child goes through `dsh-subagent`'s `materialize` ("create OR resume one child
+ * Agent"), which calls `agents.resume({ resumeSessionId: ... })`. That is the same code path for
+ * "the residency was released" and "the process restarted and the session is being rebuilt from
+ * disk", so there is no second protocol to invent here.
+ *
+ * Order per node is the parked wake's, for the same reason: GUARD → ADOPT → DELIVER. The guard has
+ * to land BEFORE the adoption, because the target session is idle/unmaterialized by definition:
+ * `heldByLiveWorkers` cannot see it, so the sweep fired by the previous run's own `subagent/end`
+ * would strip the binding mid-delivery while the cold resume still lands — two executors for one
+ * node, one wasted round, and `failures` charged for it.
+ *
+ * Failure is not a failure of the mission: the delivery being refused means "that session is
+ * gone or not resumable", and a fresh executor is the complete answer (`note_mission` is the
+ * hand-off). So the host undoes its own adoption with `wake-failed` — no budget, no cooldown —
+ * and answers `failed`, and the engine immediately takes the ordinary path in the same pass.
+ */
+export declare function resumeWorker(deps: ColdResumeDeps, input: ResumeWorkerInput): Promise<ResumeOutcome>;
+//# sourceMappingURL=coldResume.d.ts.map

package/lib/types/coldResume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coldResume.d.ts","sourceRoot":"","sources":["../../src/coldResume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,CAAA;IACtC,0FAA0F;IAC1F,WAAW,IAAI,WAAW,CAAA;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,CAAA;IAC1C,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE;QAAE,GAAG,CAAC,EAAE,EAAE,SAAS,GAAG,KAAK,GAAG,SAAS,CAAA;KAAE,CAAA;IAC1D,2FAA2F;IAC3F,QAAQ,CAAC,SAAS,EAAE;QAClB,WAAW,CACT,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,OAAO,CAAC,CAAA;KACpB,CAAA;IACD,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;IACrC,oGAAoG;IACpG,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAClC,mGAAmG;IACnG,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpC,2EAA2E;IAC3E,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACnC,8CAA8C;IAC9C,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAClC,sDAAsD;IACtD,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,qDAAqD;IACrD,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,wEAAwE;IACxE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtC;wBACoB;IACpB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7D,6EAA6E;IAC7E,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAiE5F;AAqCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CA2EzG"}

package/lib/types/domain.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Durable layout for the mission tree: one record per tree, opened once per process
+ * (`storage-domain` refuses a second open), which is why the plugin owns the handle.
+ * @module @avantf/dsh-mission/domain
+ */
+import * as z from 'zod';
+import type { TreeDocument as TreeDocumentShape } from '../mission-core/index.js';
+/**
+ * Layout version. **Stays 1 while the schema only gains optional-with-default fields**: the
+ * `single` layout compares the stamp for exact equality and throws `version-mismatch` on any
+ * bump, a failed open that bricks every existing installation. Bump only for a non-backward-
+ * readable change, and move to `layout: 'per-record'` in the same change so `compatibleVersions` applies.
+ */
+export declare const DOMAIN_VERSION = 1;
+export declare const TREES_TABLE = "trees";
+/**
+ * The node and tree schemas, exported so the cross-layer default pin
+ * (`test/domain_defaults_pin.spec.ts`) can enumerate EVERY field this module defaults, instead of
+ * the pin hard-coding a list that would go stale the moment a field is added.
+ */
+export declare const nodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    rootId: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodString;
+    unit: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    weight: z.ZodCatch<z.ZodDefault<z.ZodNumber>>;
+    roundMs: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+    context: z.ZodArray<z.ZodString>;
+    corrections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    correctionsDeliveredUpTo: z.ZodDefault<z.ZodNumber>;
+    analysisNotes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    analysisAttempt: z.ZodDefault<z.ZodNumber>;
+    analysisAuthor: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        blocked: "blocked";
+        ready: "ready";
+        running: "running";
+        interrupted: "interrupted";
+        done: "done";
+    }>;
+    createdAt: z.ZodNumber;
+    dispatchedAt: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+    endedAt: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+    depth: z.ZodNumber;
+    claimedBy: z.ZodNullable<z.ZodString>;
+    claimedAt: z.ZodNumber;
+    attempts: z.ZodNumber;
+    failures: z.ZodDefault<z.ZodNumber>;
+    spawnFailures: z.ZodDefault<z.ZodNumber>;
+    parkedWorker: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    lastWorkerId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    executorSessionId: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    dispatchBaseline: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        corrections: z.ZodNumber;
+        notes: z.ZodNumber;
+        terminalChildren: z.ZodNumber;
+        fingerprint: z.ZodString;
+        attempts: z.ZodNumber;
+        holder: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    }, z.core.$strip>>>>;
+    progressAt: z.ZodDefault<z.ZodNumber>;
+    activityAt: z.ZodDefault<z.ZodNumber>;
+    stalls: z.ZodDefault<z.ZodNumber>;
+    hungCount: z.ZodCatch<z.ZodDefault<z.ZodNumber>>;
+    stalledNotifiedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    result: z.ZodNullable<z.ZodString>;
+    hasResult: z.ZodBoolean;
+    resultReadAt: z.ZodNullable<z.ZodNumber>;
+    resultRef: z.ZodNullable<z.ZodString>;
+    resultHint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    children: z.ZodArray<z.ZodString>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export declare const treeSchema: z.ZodObject<{
+    rootId: z.ZodString;
+    ownerSessionId: z.ZodString;
+    createdAt: z.ZodNumber;
+    closedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    reportedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const treeDocumentSchema: z.ZodType<TreeDocumentShape>;
+export type TreeDocument = TreeDocumentShape;
+export declare const workDomain: {
+    name: string;
+    version: number;
+    tables: {
+        trees: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, TreeDocumentShape>;
+    };
+};
+//# sourceMappingURL=domain.d.ts.map

package/lib/types/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../src/domain.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,YAAY,IAAI,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAK7E;;;;;GAKG;AACH,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,eAAO,MAAM,WAAW,UAAU,CAAA;AAsBlC;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoFrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;iBAQrB,CAAA;AAEF,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAG1D,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAA;AAE5C,eAAO,MAAM,UAAU;;;;;;CAQrB,CAAA"}