@avantf/dsh-mission 0.3.0

package/lib/types/wire.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Hand-written Typert wire faces (host and client): the generator only runs inside the
+ * harness workspace, and both halves import this one module so the two faces cannot drift.
+ * @module @avantf/dsh-mission/wire
+ */
+import * as z from 'zod';
+import type { InvocationDescriptor } from '@deepseek-ai/dsh-typert-protocol';
+export declare const PACKAGE = "@avantf/dsh-mission";
+/** The Cordis service key that doubles as the Remote namespace. */
+export declare const NAMESPACE = "avantfMission";
+/**
+ * How many of a node's corrections the ROW projection carries. The texts themselves stay (a row marks
+ * a steered mission, and the tooltip explains a title that no longer matches its result), but a node
+ * whose owner corrected it many times must not make every frame carry all of them: past this many, the
+ * row keeps the NEWEST ones and {@link nodeSchema}'s `correctionCount` still reports the true number.
+ * The detail dialog is not affected — it reads every correction from `detailResultSchema`.
+ */
+export declare const ROW_CORRECTIONS_MAX = 5;
+/**
+ * The wire surface: `snapshot` the summary, `detail` one node's full record, `result` the FULL text
+ * behind a spilled one (on demand — a reader asks for it, the panel never prefetches it), `delete`
+ * one finished tree, `cleanFinished` every CLOSED tree this session owns (the panel's batch entry),
+ * `watch` a revision on every change (the engine pushing, not polling), and `resolveExecutorSession`
+ * the CLICK-TIME lookup of a historical node's executor session (W18 — it reads session logs, so it
+ * is deliberately NOT part of any render path).
+ * Every method carries a session id because a Remote invocation has no caller identity.
+ */
+export declare const descriptors: readonly InvocationDescriptor[];
+/**
+ * The `snapshot` result, mirrored by the client-side contract.
+ *
+ * THE VERSION FIELD. `snapshot` is the panel's ONE entry point (every other call is on demand behind a
+ * click), so the version marker lives here and nowhere else: one number that tells the browser half
+ * which host it is talking to, without adding a field to every method's arguments.
+ *
+ * `wire` is a plain optional number, NOT `z.literal(...)`: an unrecognized revision has to reach the
+ * client as a HINT (`client/api.ts` compares it against `SNAPSHOT_WIRE_VERSION`), and a literal would
+ * make `safeParse` fail and blank the whole panel — exactly the degradation the marker exists to
+ * avoid. Absent means "an older host that predates the marker": still readable, with a hint.
+ *
+ * WHY ADDING A REMOTE **MUST** BUMP THIS. The marker only pays for itself if it tracks the SET OF
+ * METHODS the host publishes, not the shape of one payload. The two halves of this plugin do not
+ * update together — the browser bundle is re-read on every page load, the host half only when `dsh
+ * web` starts — so a rebuilt client routinely talks to a host process loaded before the new method
+ * existed. The gateway answers a method that host never published with an HTTP 404, which reads
+ * exactly like "the mission or the file is gone" (measured: clicking the historical node `059f56ed`).
+ * A bumped revision is what lets the client refuse to make that call at all (`client/api.ts` gates
+ * the click-time lookup on {@link EXECUTOR_LOOKUP_WIRE_VERSION}). Bump on every added/removed
+ * `@Remote` method; do NOT bump for a new optional FIELD, which a `.default(...)`-carrying schema
+ * already absorbs across the gap.
+ *
+ * Revision history:
+ * - 1: `snapshot` / `detail` / `result` / `delete` / `watch`.
+ * - 2: `resolveExecutorSession` added (W18) — it shipped WITHOUT this bump, which is the defect the
+ *   revision repairs.
+ * - 3: `cleanFinished` added — the panel's batch entry for a session's CLOSED task trees (the same
+ *   semantics as `/clean missions all`).
+ */
+export declare const SNAPSHOT_WIRE_VERSION = 3;
+/**
+ * The wire revision that FIRST carried `resolveExecutorSession`. A host reporting less than this — or
+ * reporting no `wire` at all, i.e. one older than the marker — has never registered the method, so
+ * `fetchExecutorSession` refuses to SEND the call and says that restarting dsh fixes it. Kept here
+ * beside {@link SNAPSHOT_WIRE_VERSION} so the two revisions are read together; the current client
+ * advertises the newer one.
+ */
+export declare const EXECUTOR_LOOKUP_WIRE_VERSION = 2;
+/**
+ * The wire revision that FIRST carried `cleanFinished`. Same gate as the executor lookup, for the
+ * same reason: a rebuilt panel talking to a host process from before the method existed would get a
+ * gateway 404, which reads like "the mission is gone". The panel refuses to send the call and names
+ * the remedy instead.
+ */
+export declare const CLEAN_FINISHED_WIRE_VERSION = 3;
+export declare const snapshotResultSchema: z.ZodObject<{
+    wire: z.ZodOptional<z.ZodNumber>;
+    trees: z.ZodArray<z.ZodObject<{
+        rootId: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            parentId: z.ZodNullable<z.ZodString>;
+            children: z.ZodArray<z.ZodString>;
+            depth: z.ZodNumber;
+            title: z.ZodString;
+            context: z.ZodArray<z.ZodString>;
+            contextCount: z.ZodDefault<z.ZodNumber>;
+            corrections: z.ZodArray<z.ZodString>;
+            correctionCount: z.ZodDefault<z.ZodNumber>;
+            status: z.ZodString;
+            attempts: z.ZodNumber;
+            createdAt: z.ZodNumber;
+            dispatchedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            endedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            hasResult: z.ZodBoolean;
+            resultRef: z.ZodNullable<z.ZodString>;
+            workerSessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            workerLive: z.ZodDefault<z.ZodBoolean>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            waitingFor: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                reason: z.ZodEnum<{
+                    unit: "unit";
+                    capacity: "capacity";
+                    slot: "slot";
+                    aging: "aging";
+                }>;
+                resource: z.ZodOptional<z.ZodEnum<{
+                    cpu: "cpu";
+                    memory: "memory";
+                }>>;
+                needed: z.ZodOptional<z.ZodNumber>;
+                available: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        closedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * What one batch cleanup did: the ROOT ids of the closed trees removed, and the root ids left
+ * standing. `skipped` is the session's own trees that are not closed out — never another session's
+ * tree, which this call does not even look at. Both halves are plain id lists so the panel can say
+ * "N removed / M skipped" without parsing prose.
+ */
+export declare const cleanFinishedResultSchema: z.ZodObject<{
+    deleted: z.ZodArray<z.ZodString>;
+    skipped: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const detailResultSchema: z.ZodObject<{
+    node: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        rootId: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        context: z.ZodArray<z.ZodString>;
+        corrections: z.ZodArray<z.ZodString>;
+        analysisNotes: z.ZodArray<z.ZodString>;
+        analysisAttempt: z.ZodNumber;
+        status: z.ZodString;
+        attempts: z.ZodNumber;
+        depth: z.ZodNumber;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        dispatchedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        endedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        result: z.ZodNullable<z.ZodString>;
+        resultPointer: z.ZodNullable<z.ZodString>;
+        workerSessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        workerLive: z.ZodDefault<z.ZodBoolean>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        waitingFor: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            reason: z.ZodEnum<{
+                unit: "unit";
+                capacity: "capacity";
+                slot: "slot";
+                aging: "aging";
+            }>;
+            resource: z.ZodOptional<z.ZodEnum<{
+                cpu: "cpu";
+                memory: "memory";
+            }>>;
+            needed: z.ZodOptional<z.ZodNumber>;
+            available: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    children: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        result: z.ZodNullable<z.ZodString>;
+        resultPointer: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** The host face: schemas plus the service model, registered through `ctx.typert.register()`. */
+export declare const hostContribution: never;
+/** The client face: the same descriptors, mounted through `ctx.remote.$mount()`. */
+export declare const clientContribution: never;
+//# sourceMappingURL=wire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../src/wire.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAE5E,eAAO,MAAM,OAAO,wBAAwB,CAAA;AAE5C,mEAAmE;AACnE,eAAO,MAAM,SAAS,kBAAkB,CAAA;AAuFxC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAsEpC;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,oBAAoB,EAQtD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAA;AAE5C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAA;AAqBF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAuCF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW7B,CAAA;AAoDF,iGAAiG;AACjG,eAAO,MAAM,gBAAgB,EAMxB,KAAK,CAAA;AAEV,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,EAG1B,KAAK,CAAA"}

package/lib/types/workerEvents.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Which durable session events count as a worker's OUTPUT, as opposed to a mere sign of life.
+ *
+ * The engine's stale check compares its window against `progressAt`, so the question this module
+ * answers is "does this event prove the MISSION moved?", not "is the session object alive?" — any
+ * event proves the latter, and the host records that separately (see `MissionTree.touchActivity`).
+ *
+ * The rule is an ALLOWLIST on purpose, not a denylist of "retry noise". The harness keeps growing
+ * `SessionEventMap` (plugins may merge their own types), and an unknown type is not evidence of
+ * work. Missing a genuinely productive type costs only that a long run is judged by the round cap
+ * instead of by its output — bounded, logged, budget-free; letting one more noise type through the
+ * other way is the W8 failure this exists to fix (2026-10-02: a node stayed `running` for 7.5 hours
+ * while transport retries refreshed its timestamp every minute).
+ *
+ * The three types allowed, and why each is production rather than plumbing:
+ *
+ * - `assistant/message` — the model's committed output for a step ("Assembled assistant message for
+ *   one step, carrying the step's usage"). This is the mission's work arriving.
+ * - `tool/call` — the model asked for one tool with its argument JSON: a decision and an action.
+ * - `tool/result` — a completed tool call's result. Durable work product; the strongest evidence.
+ *
+ * Everything else is excluded deliberately. The ones that actually kept W8 alive are
+ * `assistant/attempt` — "one model attempt that committed no surface message", i.e. a failed,
+ * retried, cancelled or stream-errored attempt — and the log-only route snapshots `request/header`
+ * / `request/context`, which are appended per request, retries included. Boundary markers
+ * (`turn/*`, `step/*`), prompt plumbing (`system/message`, `developer/message`) and delivered input
+ * (`user/message`) are not output either: a worker that only receives messages and starts steps is
+ * exactly the "alive but producing nothing" state the `hung` cause reclaims.
+ *
+ * @module @avantf/dsh-mission/workerEvents
+ */
+/** Whether one durable session event is output, rather than a retry that merely proves the session is alive. */
+export declare function isOutputEvent(event: {
+    readonly type?: string;
+}): boolean;
+//# sourceMappingURL=workerEvents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workerEvents.d.ts","sourceRoot":"","sources":["../../src/workerEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,gHAAgH;AAChH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAExE"}

package/lib/types/workerSessions.d.ts

@@ -0,0 +1,256 @@
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/**
+ * The slice of the workspace registry these commands use, declared structurally: the
+ * registry is an optional service here (absent headless), and importing it would make a
+ * type the plugin only reads into a deployment requirement.
+ */
+export interface ArchiveRegistry {
+    readonly archivedSessionIds?: readonly string[];
+    archiveSession(id: SessionId): Promise<void>;
+    /**
+     * Durable unarchive: idempotent on the host ("an id that is not archived resolves without
+     * writing"), which is what makes the reconcile pass safe to run on every mount. Optional here
+     * because a host older than the API must still mount; the pass reports itself unsupported then.
+     */
+    unarchiveSession?(id: SessionId): Promise<void>;
+}
+/** One stored session, as `sessionQuery.listSessions()` reports it. */
+export interface StoredSession {
+    readonly header: {
+        readonly id: string;
+        readonly createdAt?: number;
+        readonly origin?: 'subagent';
+        readonly delegationDepth?: number;
+        readonly parentSession?: string;
+    };
+    /** Whether the id currently exists as a live agent. */
+    readonly live: boolean;
+}
+/** What the commands need from the host; explicit so tests can pass fakes. */
+export interface WorkerSessionDeps {
+    /** Stored sessions, live ones included. */
+    list(): Promise<readonly StoredSession[]>;
+    /** Durable archive of one session. Absent in a deployment without a registry. */
+    archive?(id: string): Promise<void>;
+    /**
+     * Durable unarchive of one session — step 3 of the cleanup lifecycle. Absent without a registry,
+     * or on a host whose registry predates `unarchiveSession`; the pass then reports itself
+     * unsupported instead of pretending the marker was lifted.
+     */
+    unarchive?(id: string): Promise<void>;
+    isLive(id: string): boolean;
+    /** Root of the session store (`$DSH_HOME/sessions`, `~/.dsh/sessions` by default). */
+    sessionsRoot: string;
+    /**
+     * Root of the host's projection-cache record directory
+     * (`<dsh home>/storages/session_projcache/sessions` by default). The host keeps one record per
+     * session even after disposal and has no eviction API, so a released record leaves a residue this
+     * module removes. Absent/unreadable is not an error — it simply means there is nothing to clean.
+     */
+    projectionCacheRoot: string;
+}
+/** One of this plugin's workers, with what the commands need to report. */
+export interface WorkerSession {
+    readonly id: string;
+    readonly createdAt: number;
+    readonly live: boolean;
+    /** Whether its log directory was found; a session can be listed without one. */
+    readonly bytes: number;
+    readonly dir: string | undefined;
+}
+/**
+ * A mission worker at all, whichever session owns it: `origin: subagent`, delegation depth 1, and a
+ * claim-id shape. The harness's own delegations use uuids, so they never match. Ownership is the
+ * separate half (`isOurWorker`), because a listing must be able to say "another session's worker"
+ * out loud without that statement being an authorization.
+ */
+export declare function isMissionWorker(record: StoredSession): boolean;
+export declare function isOurWorker(record: StoredSession, ownerId: string): boolean;
+/**
+ * The directory a session id owns, scanned by name so no path encoding is replicated.
+ *
+ * One `readdir` per project directory, with `withFileTypes` so the check needs no `statSync` at all
+ * — the old shape asked `existsSync` AND `statSync` for every project on every call, and this runs
+ * once per candidate worker in a listing.
+ */
+export declare function sessionDirFor(root: string, id: string): string | undefined;
+/** This session's own workers, newest last. */
+export declare function workerSessions(deps: WorkerSessionDeps, ownerId: string): Promise<readonly WorkerSession[]>;
+/** Mission workers of OTHER sessions, as ids: shown so a skip is legible, never an authorization. */
+export declare function foreignWorkerIds(deps: WorkerSessionDeps, ownerId: string): Promise<readonly string[]>;
+/** One owner session's retention picture, computed from its own workers (never from the store). */
+export interface WorkerRetention {
+    /** Settled workers (`!live`), newest first; ties broken by id so the order is deterministic. */
+    readonly settled: readonly WorkerSession[];
+    /** Live workers: excluded from the count entirely, and never a release candidate. */
+    readonly live: readonly WorkerSession[];
+    /** The newest `keep` settled workers the policy holds (all of them when the policy is off). */
+    readonly retained: readonly WorkerSession[];
+    /** Settled workers OLDER than the retained ones: what automatic retention would release. */
+    readonly releasable: readonly WorkerSession[];
+    /** `false` when `keep <= 0`: automatic retention is OFF, so nothing is releasable. */
+    readonly enabled: boolean;
+}
+/**
+ * Split one owner's workers into what the retention policy KEEPS and what it would release.
+ *
+ * The count is over SETTLED (`!live`) workers only. A live worker does not occupy a retention slot
+ * and is never a candidate, so "keep the newest N" means "keep the newest N FINISHED workers",
+ * however many are still running: 13 finished + 4 running with N=10 releases 3, and 3 finished +
+ * 8 running with N=10 releases nothing.
+ *
+ * Ordering is by `header.createdAt` descending — newest first — with the id as a deterministic
+ * tie-break, so a listing and a pass can never disagree about which worker sits on the boundary.
+ * `keep <= 0` disables the policy: everything is kept and nothing is releasable (the disabled
+ * spelling is "keep all", NOT "keep none").
+ */
+export declare function workerRetention(workers: readonly WorkerSession[], keep: number): WorkerRetention;
+export declare function bytes(n: number): string;
+/** Archive every settled, not-yet-archived worker of this session. */
+export declare function archiveWorkers(deps: WorkerSessionDeps, ownerId: string, archived: (id: string) => boolean): Promise<{
+    readonly archived: readonly string[];
+    readonly skipped: readonly string[];
+    readonly supported: boolean;
+}>;
+/** One worker a cleanup pass archived (when needed) and then removed. */
+export interface CleanedWorker {
+    readonly id: string;
+    readonly freed: number;
+    /** `true` when THIS run wrote the archive marker; `false` when it was already archived. */
+    readonly archivedNow: boolean;
+}
+/** One settled worker whose archive FAILED: deliberately left in place, with the reason. */
+export interface RefusedWorker {
+    readonly id: string;
+    readonly reason: string;
+}
+/** What one `/clean archive` pass did, and the three buckets of what it left alone. */
+export interface WorkerCleanup {
+    readonly cleaned: readonly CleanedWorker[];
+    readonly refused: readonly RefusedWorker[];
+    /**
+     * Records that WERE removed, but whose archive marker could not be lifted (step 3 failed).
+     * The deletion stands — the files are gone, so keeping the marker only adds a ghost — and the
+     * failure is reported instead of rolled back.
+     */
+    readonly unarchiveFailures: readonly RefusedWorker[];
+    /**
+     * Projection-cache residue files removed for the records this pass released. The host keeps a
+     * disposed session's checkpoint with no eviction API, so this is the layer that would otherwise
+     * keep the worker listed forever.
+     */
+    readonly purged: readonly string[];
+    /** Residue files that could not be removed: reported, never fatal, never a rollback. */
+    readonly purgeFailures: readonly RefusedWorker[];
+    /** Ours, still running: never touched. */
+    readonly running: readonly string[];
+    /** Mission workers of other sessions: never touched. */
+    readonly foreign: readonly string[];
+    /** `false` when no registry is mounted: nothing can be archived, so nothing is removed. */
+    readonly supported: boolean;
+}
+/**
+ * Archive-then-remove in ONE pass, for this session's settled workers, finishing with the
+ * best-effort unarchive that keeps the registry free of ghost ids.
+ *
+ * Scope is exactly `isOurWorker(record, ownerId) && !live`: a live worker is never touched (no
+ * interrupt, no archive) and another session's worker is never touched. A settled worker that is not
+ * yet archived is archived FIRST, and removed only once that succeeded — a failed archive leaves the
+ * record in place and is reported, because "removed without an archive marker" is the one outcome the
+ * guardrails exist to prevent. After a successful removal the marker is lifted; if THAT fails the
+ * deletion still stands (the files are gone) and the failure is reported in `unarchiveFailures`.
+ * `only` narrows the pass to one named id, still looked up inside this session's own workers. Without
+ * a registry the pass is `supported: false` and removes nothing.
+ *
+ * `retain` is the AUTOMATIC retention half: it narrows the candidates to the settled workers OLDER
+ * than the newest `retain` (see {@link workerRetention}) and reuses this same archive → delete →
+ * unarchive → purge pipeline. Live workers are excluded from the count, so they never occupy a
+ * retention slot and are never released. `retain <= 0` means "policy off", which keeps everything.
+ * A named `only` pass is an explicit manual action and ignores `retain`.
+ *
+ * `all` is the corpus to work from — the automatic pass lists sessions ONCE and hands the same list
+ * to every owner (it used to call `listSessions` once per owner, on every sweep). `measureBytes`
+ * defaults to true for the manual commands, which report what each worker occupies; the automatic
+ * pass turns it off and measures only what it actually releases.
+ */
+export declare function cleanWorkers(deps: WorkerSessionDeps, ownerId: string, archived: (id: string) => boolean, options?: {
+    readonly only?: string;
+    readonly retain?: number;
+    readonly all?: readonly StoredSession[];
+    readonly measureBytes?: boolean;
+}): Promise<WorkerCleanup>;
+export declare function removeWorker(worker: WorkerSession): number;
+/**
+ * The live-preferred session corpus, as `sessionQuery.listSessions()` answers it.
+ *
+ * `readable: false` is the load-bearing half: with no session query at all, "no record" cannot be
+ * told apart from "cannot ask", and this module treats an unproven absence as presence.
+ */
+export interface SessionCorpus {
+    readonly readable: boolean;
+    readonly known: ReadonlySet<string>;
+}
+/** What one ghost-reconciliation pass did, for the log line and the command's reply. */
+export interface GhostReconcile {
+    /** Archive markers lifted this pass. */
+    readonly released: readonly string[];
+    /** Markers whose `unarchiveSession` call failed: reported, never fatal. */
+    readonly failed: readonly RefusedWorker[];
+    /** Projection-cache residue files removed this pass (records proven gone). */
+    readonly purged: readonly string[];
+    /** Residue files that could not be removed: reported, never fatal. */
+    readonly purgeFailures: readonly RefusedWorker[];
+    /** `false` when there is no unarchive API to call: nothing was attempted. */
+    readonly supported: boolean;
+    /** `false` when the corpus could not be read: absence is unproven, so nothing was attempted. */
+    readonly readable: boolean;
+}
+/** What one projection-cache purge pass did: what it removed, and what it could not. */
+export interface ProjectionCachePurge {
+    readonly purged: readonly string[];
+    readonly failures: readonly RefusedWorker[];
+}
+/**
+ * Archived ids that are GHOSTS: mission-shaped, gone from the live-preferred corpus AND gone from
+ * the sessions root under every project directory.
+ *
+ * Written as one predicate used by both the listing and the reconcile pass, so what `/clean archive`
+ * shows and what it clears can never disagree. The narrowness is the whole safety argument: a
+ * non-mission id belongs to another subsystem or another session's archive set, and an id either
+ * source still knows is a record whose archive marker is still meaningful.
+ */
+export declare function ghostArchiveIds(archived: ReadonlySet<string>, known: ReadonlySet<string>, sessionsRoot: string): readonly string[];
+/**
+ * Projection-cache residue whose record is PROVEN gone: `mission-*`-shaped files under the cache
+ * root whose id is absent from BOTH the live-preferred corpus and the sessions root.
+ *
+ * The SAME absence predicate as `ghostArchiveIds`, for a different layer: that function reasons
+ * about archive markers, this one about the host's cached rows. Read-only: it answers what a purge
+ * would remove without removing anything.
+ *
+ * An unreadable corpus means absence is unproven, so the answer is `[]`. A record either source
+ * still knows is a session in use; its cache is never a candidate.
+ */
+export declare function orphanProjectionCacheIds(deps: WorkerSessionDeps, corpus: SessionCorpus): readonly string[];
+/**
+ * Remove the projection-cache residue of every record PROVEN gone.
+ *
+ * Registry-independent by design: proving a record gone needs the corpus and the sessions root, not
+ * an archive marker — and the archive set can legitimately be empty while residue persists, which
+ * is exactly why this enumerates the cache directory instead of taking archived ids as input. Every
+ * removal is best-effort; a failure is returned, never thrown.
+ */
+export declare function purgeOrphanProjectionCache(deps: WorkerSessionDeps, corpus: SessionCorpus): ProjectionCachePurge;
+/**
+ * Lift the archive markers older cleanups left behind, and clear the projection-cache residue of
+ * records that no longer exist, so the subagent list stops showing workers that are gone.
+ *
+ * Deliberately conservative, in three ways: only `mission-*`-shaped ids, only ids absent from BOTH
+ * the live-preferred corpus and the sessions root, and only when the corpus was readable at all (an
+ * unreadable corpus means absence is unproven). The residue purge runs FIRST and is
+ * registry-independent — the archive set no longer has to be non-empty for the pass to do its work.
+ * Each unarchive is best-effort — a failure is returned, never thrown — and the host's own unarchive
+ * is idempotent, so re-running this pass is safe.
+ */
+export declare function reconcileArchivedGhosts(deps: WorkerSessionDeps, archived: ReadonlySet<string>, corpus: SessionCorpus): Promise<GhostReconcile>;
+//# sourceMappingURL=workerSessions.d.ts.map

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

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

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "@avantf/dsh-mission",
+  "version": "0.3.0",
+  "description": "DSH native Cordis plugin: a mission-tree engine (nodes attempted, decomposed by the blocked executor, converged by the engine)",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/envinit-bootstrap.js",
+    "lib/dsh-build.json",
+    "lib/types",
+    "lib/mission-core",
+    "README.md",
+    "lib/interface-version.json",
+    "cordis.patch.yml"
+  ],
+  "engines": {
+    "node": ">=22.15.0 <23 || >=23.11.0"
+  },
+  "peerDependencies": {
+    "@avantf/dsh-plugin-base": ">=0.3.0 <1.0.0",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/cordis-plugin-timer": "^1.1.4",
+    "@deepseek-ai/dsh-agent": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-brand": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-query": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-spill": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-subagent": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-util-values": "^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "zod": ">=4.4.3 <5"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/cordis-plugin-timer": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-brand": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-query": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-spill": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-storage-domain": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subagent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-system-prompt": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-util-values": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@avantf/dsh-plugin-base": ">=0.3.0 <1.0.0",
+    "@avantf/mission-core": "0.3.0",
+    "@tanstack/react-virtual": "^3.14.13",
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "esbuild": "0.25.0",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "typescript": "^5.5.0",
+    "vitest": "^2.1.0",
+    "zod": "4.6.5"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitee.com:ffeng86/dsh-plugins.git",
+    "directory": "mission/packages/plugin"
+  },
+  "author": "qunqi.ff",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/build.mjs",
+    "typecheck": "node ../../scripts/link-dsh.mjs --no-bake && tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}