dsh-pause-session 0.0.0-stage → 0.1.0

package/lib/types/shared.d.ts

@@ -0,0 +1,324 @@
+/**
+ * The identities both halves of dsh-pause-session name, the status encodings they
+ * share, and the one spelling a host log line gives a caught value.
+ *
+ * The browser bundle may value-import only the shell's baseline module table,
+ * so this module imports nothing: the client half reads command names and the
+ * decode functions from it directly, and the host half derives the branded
+ * identities from the same strings.
+ *
+ * A third-party plugin's only live channel to the browser is the command
+ * registry — it can add neither a `ctx.remote` namespace nor a forwarded event,
+ * both of which are compiled into the harness's own API assembly. A command
+ * descriptor's only free-form field is its `description`, and a command
+ * result's only free-form field is its `text`, so the park state travels as a
+ * prefix plus `;`-separated fields on one of those. The text stays
+ * human-readable: the same words are what the slash-command menu shows.
+ *
+ * Every value inside a field is escaped, so a decoded name is the exact name
+ * that was encoded. Session ids, tool names, and call ids are the host's own
+ * data and may contain the `;`, `,`, `/`, or newline a field is separated by; a
+ * folded spelling would decode as a different name — a different row, looked up
+ * again.
+ * @module dsh-pause-session/shared
+ */
+/** Command that pauses the receiving session before its next model request. */
+export declare const PAUSE_COMMAND = "pause";
+/** Command that resumes the receiving session; registered only while that session is paused. */
+export declare const RESUME_COMMAND = "pause-resume";
+/** Command that resumes every parked session the registry remembers. */
+export declare const RESUME_ALL_COMMAND = "pause-resume-all";
+/** Command that registers and parks every running session tree in one action. */
+export declare const PAUSE_ALL_COMMAND = "pause-all";
+/** Command that reports the whole-app park state; registered globally, always. */
+export declare const STATE_ALL_COMMAND = "pause-state-all";
+/** Command that reports the receiving session's park state; registered only while it is paused. */
+export declare const STATUS_COMMAND = "pause-state";
+/** Command that turns the receiving session's own goal re-arm on or off; registered only while it is paused. */
+export declare const GOAL_COMMAND = "pause-goal";
+/** Command that reports every session that did not stop cleanly. */
+export declare const TRIAGE_COMMAND = "pause-triage";
+/** Command that resumes one session from the decision list exactly as the clean path would. */
+export declare const TRIAGE_CONTINUE_COMMAND = "pause-triage-continue";
+/** Command that resumes one session from the decision list with the unknown-outcome note. */
+export declare const TRIAGE_NOTE_COMMAND = "pause-triage-note";
+/** Command that opens one session from the decision list without spending a request. */
+export declare const TRIAGE_REVIEW_COMMAND = "pause-triage-review";
+/** Command that leaves one session from the decision list exactly as it is. */
+export declare const TRIAGE_LEAVE_COMMAND = "pause-triage-leave";
+/** Command that turns one listed session's goal re-arm on or off. */
+export declare const TRIAGE_GOAL_COMMAND = "pause-triage-goal";
+/** Stable definition id of the pause command, matched by identity rather than by copy. */
+export declare const PAUSE_DEFINITION_ID = "dsh-pause-session/pause";
+/** Stable definition id of the resume command: the host's own "this session is paused" fact. */
+export declare const RESUME_DEFINITION_ID = "dsh-pause-session/resume";
+/** Stable definition id of the global resume command, matched by identity rather than by copy. */
+export declare const RESUME_ALL_DEFINITION_ID = "dsh-pause-session/resume-all";
+/** Stable definition id of the whole-app pause command. */
+export declare const PAUSE_ALL_DEFINITION_ID = "dsh-pause-session/pause-all";
+/** Stable definition id of the whole-app status read. */
+export declare const STATE_ALL_DEFINITION_ID = "dsh-pause-session/state-all";
+/** Stable definition id of the status read, matched by identity rather than by copy. */
+export declare const STATUS_DEFINITION_ID = "dsh-pause-session/status";
+/** Stable definition id of the paused session's own goal re-arm toggle. */
+export declare const GOAL_DEFINITION_ID = "dsh-pause-session/goal";
+/** Stable definition id of the decision-list read. */
+export declare const TRIAGE_DEFINITION_ID = "dsh-pause-session/triage";
+/** Stable definition id of the decision-list "continue" verb. */
+export declare const TRIAGE_CONTINUE_DEFINITION_ID = "dsh-pause-session/triage-continue";
+/** Stable definition id of the decision-list "continue with the unknown-outcome note" verb. */
+export declare const TRIAGE_NOTE_DEFINITION_ID = "dsh-pause-session/triage-note";
+/** Stable definition id of the decision-list "open without activating" verb. */
+export declare const TRIAGE_REVIEW_DEFINITION_ID = "dsh-pause-session/triage-review";
+/** Stable definition id of the decision-list "leave it alone today" verb. */
+export declare const TRIAGE_LEAVE_DEFINITION_ID = "dsh-pause-session/triage-leave";
+/** Stable definition id of the decision-list goal re-arm toggle. */
+export declare const TRIAGE_GOAL_DEFINITION_ID = "dsh-pause-session/triage-goal";
+/** First token of every encoded status, so a descriptor is never parsed by accident. */
+export declare const STATUS_PREFIX = "pause: ";
+/**
+ * One log line's text for a caught value.
+ * @param error - the caught value.
+ * @returns the error's message, or the value's own spelling.
+ */
+export declare function describeError(error: unknown): string;
+/**
+ * The four park outcomes, listed in the order a park walks them — and the one
+ * vocabulary the live status, the durable registry, and the published words all
+ * derive from, so they cannot drift apart:
+ *
+ * - `draining`: paused, and the session is still working — a tool is running, or
+ *   a turn is between steps.
+ * - `parking`: standing still at the park point; the session-level flush has
+ *   not resolved yet.
+ * - `safe`: parked and flushed, so it is safe to walk away. The only clean one.
+ * - `flush-failed`: parked, but the flush failed — the durable promise is not
+ *   kept, and it must never be read as clean.
+ */
+export declare const PARK_PHASES: readonly ["draining", "parking", "safe", "flush-failed"];
+/** One park outcome. */
+export type ParkPhase = (typeof PARK_PHASES)[number];
+/**
+ * Fold several records into the one verdict that speaks for all of them: the
+ * worst phase any of them reached, and whether every one of them is clean.
+ *
+ * This is how a session's control answers for its tree. "Safe to close" is a
+ * promise about everything the press registered, so it may be said only when
+ * every member reached the flushed park point; anything else is reported as the
+ * least-clean state in the set, never rounded up to the session's own.
+ * @param phases - the durable phases of the records being spoken for.
+ * @returns the worst phase, and whether that verdict is the clean one.
+ */
+export declare function foldTreePhases(phases: Iterable<ParkPhase>): {
+    phase: ParkPhase;
+    safe: boolean;
+};
+/** Everything the browser is told about one paused session. */
+export interface ParkStatus {
+    /**
+     * The phase of everything that session's press registered — the session and
+     * the subagent members under it, folded by {@link foldTreePhases}. A member
+     * still draining or stalled holds this at its own phase, because the control
+     * that owns the tree may not say "safe to close" while any member of it is
+     * not.
+     */
+    readonly phase: ParkPhase;
+    /** Whether the host commits to "you can close the lid now". */
+    readonly safe: boolean;
+    /** Tools in flight when the status was published; empty once parked. */
+    readonly runningTools: readonly string[];
+    /**
+     * Whether the resume that takes this pause back may re-open the session's
+     * goal — the durable record's own opt-out, which outlives this process. It is
+     * absent when this host could not read the record that holds it; a browser
+     * that is not told shows no switch rather than a state it would have to
+     * guess, and a guess here would tell the user their money is safe when
+     * nobody knows whether it is.
+     */
+    readonly rearmGoal?: boolean;
+}
+/**
+ * Encode one status for a command descriptor.
+ * @param status - the state to publish.
+ * @returns the descriptor text, e.g. `pause: draining; tools: edit, bash; goal: on`.
+ */
+export declare function encodeParkStatus(status: ParkStatus): string;
+/**
+ * Decode a status previously written by {@link encodeParkStatus}.
+ * @param text - a command descriptor's description.
+ * @returns the status, or `undefined` when this text carries none — a foreign
+ * command, or a reading taken before the host published anything.
+ */
+export declare function decodeParkStatus(text: string): ParkStatus | undefined;
+/**
+ * First token of every encoded whole-app status. A different prefix from the
+ * per-session status on purpose: one decoder must never read the other's text.
+ */
+export declare const GLOBAL_STATUS_PREFIX = "pause all: ";
+/** The whole-app answer to "can I close the lid?". */
+export type GlobalVerdict = 'idle' | 'waiting' | 'safe';
+/** A surface the whole-app report could not read at all. */
+export type GlobalBlindSpot = 'trees' | 'jobs';
+/**
+ * Everything the whole-app control publishes about the park as a whole.
+ *
+ * The counts and the names are one answer, not two: a report that says
+ * "3 registered, 1 safe" and then fails to say which two are missing is the
+ * kind of silence this control exists to prevent. The verdict is the only
+ * summary, and it is derived here so the host and the browser cannot disagree
+ * about it.
+ */
+export interface GlobalStatus {
+    /** `idle` with nothing registered, `safe` only when every registered session is. */
+    readonly verdict: GlobalVerdict;
+    /** Sessions this park owns — the durable list plus anything pressed since. */
+    readonly registered: number;
+    /** How many of them reached the flushed park point. */
+    readonly safe: number;
+    /**
+     * The session this park belongs to — the first registered one this host can
+     * hold, whatever phase it reached, so a client can address its reads at the
+     * park instead of at whatever session the user happens to be looking at. A
+     * park whose every record is unreadable here names the first of those: the
+     * name is a fact about the park, and an address that cannot answer is the
+     * client's fallback to take.
+     *
+     * The buckets below name a session only while it has something left to do,
+     * and the clean case — every registered session `safe`, which is the ordinary
+     * one — leaves all of them empty: without this field a park that finished
+     * cleanly names no session at all. `undefined` when the park holds nothing,
+     * and absent from a reading written before this field existed; a client must
+     * not treat either absence as an address.
+     */
+    readonly parkedAt?: string;
+    /**
+     * Registered sessions still working: a tool is in flight or a turn is between
+     * steps. Their park point is announced by the marker commands the park
+     * registers, so a reader has nothing to watch here.
+     */
+    readonly draining: readonly string[];
+    /**
+     * How many registered sessions stand at the park point with their flush still
+     * pending — the host's `parking` phase. Nothing announces a flush resolving,
+     * so this is the one state a reader can only learn by asking again. A count
+     * rather than names: it says how long to keep watching, not which transcript
+     * a row belongs in, which is what `draining` is for.
+     */
+    readonly parking: number;
+    /**
+     * Registered sessions that will not reach the park point in this process: a
+     * flush that failed, a pause adopted from an earlier process, a press whose
+     * registry write failed, or a record whose session this host cannot read and
+     * therefore did not hold. Named, never folded into the count and forgotten.
+     */
+    readonly stalled: readonly string[];
+    /** Registered sessions whose tree contains a route a restart cannot resume. */
+    readonly unresumable: readonly string[];
+    /** Registered sessions whose subagent tree could not be read — unknown, not clean. */
+    readonly unreadTrees: readonly string[];
+    /** Live background jobs owned by the registered trees; nothing here can stop them. */
+    readonly jobs: readonly string[];
+    /** Whole surfaces the report could not read, so their emptiness is not a fact. */
+    readonly blind: readonly GlobalBlindSpot[];
+}
+/**
+ * Encode one whole-app status for a command result.
+ * @param status - the state to publish.
+ * @returns the result text, e.g.
+ * `pause all: waiting; registered: 3; safe: 1; parked-at: overnight; draining: overnight; parking: 1; stalled: -; unresumable: -; unread-trees: -; jobs: bash-1; blind: -`.
+ */
+export declare function encodeGlobalStatus(status: GlobalStatus): string;
+/**
+ * Decode a whole-app status previously written by {@link encodeGlobalStatus}.
+ * @param text - a command result's text.
+ * @returns the status, or `undefined` when this text carries none.
+ */
+export declare function decodeGlobalStatus(text: string): GlobalStatus | undefined;
+/**
+ * First token of every encoded decision list. Separate from the per-session and
+ * whole-app status prefixes on purpose, for the same reason those two are
+ * separate: one decoder must never read another's text.
+ */
+export declare const TRIAGE_PREFIX = "pause triage: ";
+/** How one decision-list row was read out of the session's own stored log. */
+export type TriageReading = 'read' | 'unreadable';
+/**
+ * What one stored log says about a tool call whose outcome was never recorded.
+ *
+ * The call event itself is durable; the harness turns every such call into a
+ * synthetic `TOOL_OUTCOME_UNKNOWN` error result when it next reads the log, and
+ * this is that same derivation taken without writing anything back. The marker
+ * itself is never in the stored log of a session still on the list: the resume
+ * that appends it is also the resume that drops the record putting it here.
+ */
+export interface TriageTrace {
+    /** The tool's own name, from the call event the model produced. */
+    readonly tool: string;
+    /** The provider-issued id pairing the call with the result that never arrived. */
+    readonly callId: string;
+}
+/**
+ * One session that did not stop cleanly, as the decision list presents it.
+ *
+ * Every field is read from the session's own log or from the durable park
+ * record; nothing here is derived from the fact that the session is merely
+ * listed. `reading` is the honesty field: a log this host could not read says
+ * `unreadable` and carries no facts, rather than an empty row that would read
+ * as "no traces".
+ */
+export interface TriageRow {
+    /** The parked session. */
+    readonly sessionId: string;
+    /** The durable park outcome; never `safe`, which is the clean path's business. */
+    readonly phase: Exclude<ParkPhase, 'safe'>;
+    /** When that outcome was last written. */
+    readonly updatedAt: number;
+    /** Whether the facts below came from the log. */
+    readonly reading: TriageReading;
+    /** What the stored log's last event was, with the step it belongs to when it has one. */
+    readonly lastEvent?: string;
+    /** The turn and step that last event belongs to. */
+    readonly turn?: number;
+    readonly step?: number;
+    /** Tools whose call event is durable and whose result is not — the unknown outcomes. */
+    readonly traces: readonly TriageTrace[];
+    /** Whether the stored log ends owing the model an answer. */
+    readonly owed: boolean;
+    /**
+     * Whether resuming this session may re-open its goal. Re-arming is what makes
+     * a resumed goal spend its owner's rounds, so it is a per-session choice the
+     * row shows and the list can flip.
+     */
+    readonly rearmGoal: boolean;
+    /**
+     * Whether the host could hand this session its owed request at all: a log it
+     * could not read, or one whose last request recorded no route, cannot be
+     * woken — which is a fact about the entry, not a refusal of the user's choice.
+     */
+    readonly wakeable: boolean;
+}
+/** The decision list: what did not stop cleanly, and each row's facts. */
+export interface TriageList {
+    /** Every listed session, in registry order. */
+    readonly rows: readonly TriageRow[];
+}
+/**
+ * The decisions the list offers for one row. The first four carry the row out;
+ * `goal` changes what the next resume may spend without touching the park
+ * itself.
+ */
+export declare const TRIAGE_ACTIONS: readonly ["continue", "note", "review", "leave", "goal"];
+/** One decision the list offers. */
+export type TriageAction = (typeof TRIAGE_ACTIONS)[number];
+/**
+ * Encode one decision list for a command result.
+ * @param list - the rows to publish.
+ * @returns the result text, e.g. `pause triage: 1; row: overnight; phase: draining; stopped: tool/call/turn 1 step 1; tools: gated; wake: yes`.
+ */
+export declare function encodeTriageList(list: TriageList): string;
+/**
+ * Decode a decision list previously written by {@link encodeTriageList}.
+ * @param text - a command result's text.
+ * @returns the list, or `undefined` when this text carries none.
+ */
+export declare function decodeTriageList(text: string): TriageList | undefined;

package/lib/types/tree.d.ts

@@ -0,0 +1,71 @@
+/**
+ * One session's subagent tree, read from the parent catalogs.
+ *
+ * "This session's work" includes the subagents it delegated to, nested ones
+ * included, so the session-header press and the status the header shows both
+ * need the same answer to "which sessions hang under this one".
+ * `listDescendants` is the harness's own recursive walk of the parent-owned
+ * catalogs, and it is the only source: the tree is read from the parents that
+ * record it, never guessed from session ids.
+ *
+ * A walk is read, not remembered. The tree is a fact that grows — a delegation
+ * in flight publishes its child after the parent's catalog was read — so a
+ * press walks the tree at press time and a status read walks it at read time.
+ * `@module dsh-pause-session/tree`
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/** One session a walk found under another, with the catalog's own mode for it. */
+export interface TreeMember {
+    readonly id: SessionId;
+    /**
+     * The catalog's durable mode for this child. `external` is a child with no
+     * local session to park, and `unsupported` is a mode this build cannot read;
+     * the other two are the harness's own split between a route a restart can
+     * resume (`continuable`) and one it cannot.
+     */
+    readonly mode: 'one-shot' | 'external' | 'continuable' | 'unsupported';
+}
+/** One branch a walk reached and could not read. */
+export interface UnreadBranch {
+    readonly id: SessionId;
+    /**
+     * `corrupt` and `unavailable` mean the branch's own catalog was not read, so
+     * the members under it are unknown. `unsupported` means the parent's catalog
+     * records a mode this build cannot read; that branch was still traversed, and
+     * what it holds is known — but no restart can resume through it.
+     */
+    readonly reason: 'corrupt' | 'unsupported' | 'unavailable';
+}
+/** What one session's tree walk found. */
+export interface TreeWalk {
+    /**
+     * Catalog descendants in pre-order, direct children first and each child's
+     * own children after it. A missing subagent service leaves this empty.
+     */
+    readonly members: readonly TreeMember[];
+    /**
+     * Branches the walk reached and could not fully read. A branch named here may
+     * hold members nobody can see, so it is never read as "no members".
+     */
+    readonly unread: readonly UnreadBranch[];
+    /**
+     * Whether the walk itself failed, so even the branches are unknown. Named
+     * separately from {@link unread}, which lists the branches of a walk that ran.
+     */
+    readonly unreadWhole: boolean;
+}
+/**
+ * Read the subagent tree under one session.
+ *
+ * A failure to read a branch is reported as unread rather than as an empty
+ * tree: the difference is what keeps a press from claiming it registered a tree
+ * it never saw, and keeps a status answer from calling itself safe behind an
+ * unknown branch.
+ * @param ctx - host context carrying the optional subagent service.
+ * @param rootSessionId - the session whose descendants are requested.
+ * @param signal - cancellation for the catalog walk.
+ * @returns the descendants found and what of the walk could not be read.
+ * @throws the cancellation reason when `signal` aborts the walk.
+ */
+export declare function walkDescendants(ctx: Context, rootSessionId: SessionId, signal?: AbortSignal): Promise<TreeWalk>;

package/lib/types/triage.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The morning decision list: every session that did not stop cleanly, the facts
+ * its own log carries about where it stopped, and the listed verbs the user can
+ * take on it.
+ *
+ * A session gets here by NOT being on the clean path. A record whose phase is
+ * `safe` is woken silently by `./resume.ts` and never appears here; the other
+ * three phases describe work nobody can vouch for, and guessing on them would
+ * spend the owner's money on a guess. This module is the other half of that
+ * rule, not a second copy of it: the reading is taken from the session's own
+ * stored log through a read handle that claims no ownership and writes nothing,
+ * so asking what happened cannot itself change what happened.
+ *
+ * WHAT ONE READ COSTS. The list is read again on every command-registry change
+ * while the panel is open, and what it publishes is about the end of a log that
+ * only grows, so `./coldlog.ts` bounds each row's read to that end. A row whose
+ * facts the bound cannot hold reports itself unreadable rather than publishing
+ * a fragment.
+ *
+ * WHAT A ROW REPORTS. "Where it stopped" is the last event of the stored log
+ * with the turn and step it belongs to. "Which tool was in flight" is the
+ * `tool/call` events that no durable `tool/result` answers — a call event is
+ * only written once the loop reached the dispatch, so an unanswered one is
+ * exactly a tool the real world ran and the log never heard back from. The
+ * harness turns each of those into a synthetic `TOOL_OUTCOME_UNKNOWN` error
+ * result when it next reads the log; this module derives the same answer from
+ * the stored events instead of writing it back. Nothing here is inferred from
+ * the fact that the session is listed.
+ *
+ * WHAT THE ROW PROMISES. `wake` says the host can hand this session the request
+ * it owes, and the wake that keeps that promise is `./resume.ts`'s. Both read
+ * one rule from `./history.ts` over the same derivation the loop reads, so a
+ * promise this list publishes is a promise that wake keeps. When the log cannot
+ * be folded into that derivation, the promise is withheld and the reading is
+ * reported; a withheld promise costs a user nothing, a broken one spends their
+ * money.
+ *
+ * WHO MAY DECIDE. A decision names its target as command input, and the command
+ * channel carries no origin of its own, so this list acts only on rows its most
+ * recent read published to the calling session: the caller's own read is what
+ * makes a target actionable. Anything else is refused, not looked up.
+ *
+ * TWO OF THE FIVE VERBS PUT THE SESSION BACK ON THE CLEAN PATH. Continue and
+ * continue-with-the-note go through `ResumePath.decideUnclean`, which activates
+ * the session, wakes it and drops the durable record before the gate opens.
+ *
+ * THE OTHER THREE TOUCH NOTHING. Leave writes nothing at all: the record stays,
+ * the session stays held, and the row is still on tomorrow's list. Review
+ * answers without activating anything or writing anything — opening a session
+ * to read it is the user's own action in their session history, and starting an
+ * agent on their behalf is precisely what they declined. Goal flips the row's
+ * own re-arm opt-out: it is the user path for the one thing a resume can spend
+ * without the user watching it, and it takes effect on whatever resume comes
+ * next. All five carry the same binding — the row must be one this caller was
+ * shown — because each changes, or declines to change, durable state of a
+ * parked session.
+ * @module dsh-pause-session/triage
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { CommandResult } from '@deepseek-ai/dsh-commands';
+import type { ParkRegistry } from './registry.js';
+import type { ResumePath } from './resume.js';
+import type { TriageAction, TriageList } from './shared.js';
+/** Result copy for a decision the list itself could not carry out. */
+export declare const TRIAGE_FAILED_TEXT = "pause could not carry out that decision; the session is exactly as it was.";
+/** Result copy for leaving one listed session alone. */
+export declare const TRIAGE_LEFT_TEXT = "pause left this session paused; it is still on the list.";
+/** Result copy for a decision aimed at a session that is not on the list. */
+export declare const TRIAGE_NOT_LISTED_TEXT = "pause has no unfinished pause for this session.";
+/**
+ * Result copy for a decision aimed at a row the calling session was not shown.
+ * The list is the only thing that legitimizes a target, so a target nobody read
+ * is refused rather than acted on.
+ */
+export declare const TRIAGE_UNSHOWN_TEXT: string;
+/**
+ * Model-facing text that goes with a wake when the user chooses to continue
+ * with a note.
+ *
+ * It is written the way the harness writes its own recovery text: the same two
+ * facts the synthetic tool result states (the call's outcome was never recorded;
+ * verify before retrying anything with side effects), in the same voice, with no
+ * mention of the stop mechanism. The harness's own version lives in the tool
+ * result for that call, which is why this one does not repeat the call's name —
+ * it warns about the step as a whole, and the specific result sits directly
+ * above it in the history.
+ */
+export declare const UNKNOWN_OUTCOME_NOTE: string;
+/** What mounting the decision list hands back. */
+export interface TriageListService {
+    /**
+     * Read the list for one calling session, and record the rows it was shown.
+     * @param caller - the session the read was addressed to.
+     * @param signal - cancellation for the stored-log reads.
+     * @returns every session that did not stop cleanly, with the facts its own log carries.
+     */
+    read(caller: SessionId, signal?: AbortSignal): Promise<TriageList>;
+    /**
+     * Carry out one decision on one listed session, for the caller that read it.
+     * @param caller - the session the decision was addressed to.
+     * @param sessionId - the listed session to act on.
+     * @param action - which of the listed decisions was taken.
+     * @param signal - cancellation for the cold load and setup.
+     * @returns the outcome for whoever asked.
+     */
+    decide(caller: SessionId, sessionId: SessionId, action: TriageAction, signal?: AbortSignal): Promise<CommandResult>;
+}
+/**
+ * Mount the decision list over the durable registry and the clean resume path.
+ *
+ * The list is the registry's own complement: it asks for every record whose
+ * phase is not `safe`, so a session that cleaned up is off the list by the same
+ * fact that puts it on the silent path, and nothing has to be reconciled.
+ * @param ctx - host context carrying the optional persistence service.
+ * @param registry - the durable list of park outcomes.
+ * @param resumePath - the path all three resuming decisions go through.
+ * @param windowEvents - how many events of each stored log one read may fold.
+ * @returns the list read and the decision verbs.
+ */
+export declare function mountTriageList(ctx: Context, registry: ParkRegistry, resumePath: ResumePath, windowEvents?: number): TriageListService;

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Pause Session",
+    "description": "Pause every running session and its subagents at a safe point, then resume them later without losing the work in flight."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "\u6682\u505c\u4f1a\u8bdd",
+    "description": "\u5728\u5b89\u5168\u70b9\u6682\u505c\u6240\u6709\u8fd0\u884c\u4e2d\u7684\u4f1a\u8bdd\u53ca\u5176\u5b50\u4ee3\u7406\uff0c\u4e4b\u540e\u518d\u4ece\u4e2d\u65ad\u5904\u6062\u590d\uff0c\u4e0d\u4e22\u5931\u6b63\u5728\u6267\u884c\u7684\u5de5\u4f5c\u3002"
+  }
+}