dsh-pause-session 0.1.0 → 0.2.1

package/lib/types/triage.d.ts

@@ -11,8 +11,8 @@
  * 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
+ * WHAT ONE READ COSTS. The list is read when the panel opens and when a native
+ * action changes the park, 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.
@@ -35,10 +35,10 @@
  * 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.
+ * WHO MAY DECIDE. A decision carries the calling session and its target as wire
+ * input, 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
@@ -58,12 +58,11 @@
  */
 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';
+import type { PauseAnswer } 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. */
@@ -104,7 +103,7 @@ export interface TriageListService {
      * @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>;
+    decide(caller: SessionId, sessionId: SessionId, action: TriageAction, signal?: AbortSignal): Promise<PauseAnswer>;
 }
 /**
  * Mount the decision list over the durable registry and the clean resume path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pause-session",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "DSH plugin: pause every running session (and its subagents) at a safe point before you leave, then resume them the next morning as if nothing was interrupted.",
   "type": "module",
   "main": "lib/index.js",
@@ -17,7 +17,19 @@
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json",
     "./locale/*.json": "./locale/*.json",
-    "./icon": "./icon.svg"
+    "./icon": "./icon.svg",
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./types": {
+      "types": "./lib/types/remote.d.ts",
+      "default": "./lib/types/remote.js"
+    }
   },
   "files": [
     "lib/index.js",
@@ -34,16 +46,13 @@
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
-    "docs/images/pause-controls.webp"
+    "docs/images/pause-controls.webp",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts",
+    "lib/typert.remote-client.d.ts.map"
   ],
-  "scripts": {
-    "build:host": "tsc -p tsconfig.json",
-    "build:client": "tsc -p tsconfig.client.json && tsdown",
-    "build": "npm run build:host && npm run build:client && node scripts/trim-build-whitespace.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
-    "test": "vitest run",
-    "verify": "npm run typecheck && npm run build && npm run test"
-  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -66,7 +75,6 @@
     "@deepseek-ai/dsh-client-ui-conversation": "*",
     "@deepseek-ai/dsh-client-ui-renderer": "*",
     "@deepseek-ai/dsh-client-ui-session": "*",
-    "@deepseek-ai/dsh-commands": "*",
     "@deepseek-ai/dsh-goal": "*",
     "@deepseek-ai/dsh-jobs": "*",
     "@deepseek-ai/dsh-llm": "*",
@@ -74,15 +82,16 @@
     "@deepseek-ai/dsh-subagent": "*",
     "@deepseek-ai/dsh-session": "*",
     "@deepseek-ai/dsh-session-query": "*",
-    "@deepseek-ai/dsh-agent-preset-registry": "*"
+    "@deepseek-ai/dsh-agent-preset-registry": "*",
+    "@deepseek-ai/dsh-typert-protocol": "*"
   },
   "dependencies": {
-    "zod": "4.4.3"
+    "zod": "4.6.6"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "link:../../deepseek-harness/vendor/cordis",
-    "@deepseek-ai/cordis-plugin-include": "1.0.6",
-    "@deepseek-ai/cordis-plugin-loader": "1.0.2",
+    "@deepseek-ai/cordis-plugin-include": "1.1.0",
+    "@deepseek-ai/cordis-plugin-loader": "1.1.0",
     "@deepseek-ai/dsh-agent": "link:../../deepseek-harness/packages/core/agent",
     "@deepseek-ai/dsh-agent-loop": "link:../../deepseek-harness/packages/core/agent-loop",
     "@deepseek-ai/dsh-agent-loop-testkit": "link:../../deepseek-harness/packages/test-support/agent-loop-testkit",
@@ -94,7 +103,6 @@
     "@deepseek-ai/dsh-client-ui-renderer": "link:../../deepseek-harness/packages/client/ui-renderer",
     "@deepseek-ai/dsh-client-ui-session": "link:../../deepseek-harness/packages/client/ui-session",
     "@deepseek-ai/dsh-client-ui-slots": "link:../../deepseek-harness/packages/client/ui-slots",
-    "@deepseek-ai/dsh-commands": "link:../../deepseek-harness/packages/interaction/commands",
     "@deepseek-ai/dsh-goal": "link:../../deepseek-harness/packages/goal/goal",
     "@deepseek-ai/dsh-goal-round-driver": "link:../../deepseek-harness/packages/goal/goal-round-driver",
     "@deepseek-ai/dsh-jobs": "link:../../deepseek-harness/packages/jobs/jobs",
@@ -122,7 +130,9 @@
     "react": "^18.2.0",
     "tsdown": "0.22.2",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "vitest": "^3.0.0",
+    "@deepseek-ai/dsh-typert-protocol": "link:../../deepseek-harness/packages/typert/protocol",
+    "@deepseek-ai/dsh-typert-generator": "link:../../deepseek-harness/packages/typert/generator"
   },
   "license": "MIT",
   "engines": {
@@ -146,5 +156,14 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build:host": "tsc -p tsconfig.json",
+    "build:client": "tsc -p tsconfig.client.json && tsdown",
+    "build": "npm run generate:typert && npm run build:host && npm run build:client && node scripts/trim-build-whitespace.mjs",
+    "typecheck": "npm run generate:typert && tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "test": "vitest run",
+    "verify": "npm run typecheck && npm run build && npm run test",
+    "generate:typert": "node scripts/generate-typert.mjs"
   }
-}
+}

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

@@ -1,253 +0,0 @@
-/**
- * The re-read burst both browser controls share: a handful of reads after
- * something moved, and silence once it settles.
- *
- * What a control reads is published through the host's command channel, and
- * every read is two durable `command/run|done` records in the address session's
- * log plus an aggregate read on the host. Reading is therefore something the
- * host announces and the user asks for, never a heartbeat:
- *
- * - the host announces a transition by registering or unregistering the paused
- *   session's marker commands, and — for a phase change, which no registration
- *   of its own would show — by registering that session's status verb again.
- *   Each of those emits `commands/change`, and that event, plus the user's own
- *   press or decision, is what starts a burst;
- * - one transition announces itself several times: a park registers two or three
- *   marker commands per session and a phase change re-registers one, and the host
- *   emits one `commands/change` per step. The burst therefore waits out a short
- *   `windowMs` before its first read and any trigger inside that window
- *   postpones it, so the announcements of one transition start one burst rather
- *   than one each;
- * - a change that arrives within `ACTION_ABSORB_MS` of the user's own action is
- *   that action's own consequence, not news: the action already read the host,
- *   so the answer is on screen, and the unregistrations it caused — one event
- *   per marker command, measured seconds apart, which the window above cannot
- *   merge — would only be read back. Such a change is absorbed, and each one
- *   absorbed pushes the window out, because a storm that keeps arriving is
- *   still the same storm. The window always closes: the first change after
- *   `ACTION_ABSORB_MS` of quiet is news again, and a user action reads on its
- *   own whatever the window says;
- * - an absorbed change is deferred rather than lost: a control whose action left
- *   a phase still moving asks for one look at the moment the window closes
- *   ({@link ReadBurst.recheckAfterEcho}), which is the read that finds a
- *   transition the window hid — the park can reach its final phase inside that
- *   window and never announce anything again. One look per action, and only
- *   while the state it left is still moving;
- * - a burst is a fixed short list of waits, so at most that many reads answer
- *   one transition, however long the page stays open;
- * - a read that finds the verdict settled ends the burst at once, and the last
- *   reading stays on screen — "the park is settled" is not a state change, so
- *   it must not be re-asked;
- * - a read that finds a phase still moving ends it just as fast. Every phase
- *   transition is announced at its source, the flush that resolves `parking`
- *   into `safe` included, and that announcement is the very event that starts
- *   the next burst — so watching a moving phase from here spends records on a
- *   transition that will speak for itself;
- * - what the burst still owes after a read is delivery: the read one
- *   announcement bought, and one more when a change lands while a pass is in
- *   flight, which that pass cannot have answered. The bound is a bound, not a
- *   heartbeat: a phase that never settles is left on screen unread until
- *   something else moves;
- * - the bound is a trade, taken knowingly: a reading left on screen when the
- *   burst runs out is the host's own last answer, and the next trigger — a
- *   forwarded change, a press, or the shell handing a control its session again
- *   — reads the truth again. A reading nobody answered is never rendered as a
- *   confident state. A longer watch is a longer list of waits, at a linear price
- *   in the address session's log;
- * - while the page is hidden no read is armed at all, and the wait a burst
- *   still owed is armed again when the page comes back: hidden time is neither
- *   charged to the burst nor lost from it.
- *
- * A burst is not restarted by a trigger that lands while one is running: every
- * read it still owes happens after that trigger, so absorbing it loses nothing
- * and a storm of registry changes costs one burst rather than one each.
- * @module dsh-pause-session/client/burst
- */
-/** Whether the page is on screen, as the shell reports it. */
-export type PageVisibility = () => boolean;
-/**
- * One control's burst policy.
- *
- * `waitsMs` is the whole bound: a burst spends at most one read per wait, and
- * an empty list turns bursting off entirely — which is how a test or a
- * composition disables it without touching anything else.
- */
-export interface BurstPolicy {
-    /** How long the burst collects triggers before its first wait starts. */
-    readonly windowMs: number;
-    /** Waits between the reads of one burst, in order; the first follows a trigger. */
-    readonly waitsMs: readonly number[];
-    /** Whether the page is on screen now. */
-    readonly visible: PageVisibility;
-}
-/** The policy every control uses unless a caller says otherwise. */
-export declare const DEFAULT_BURST_POLICY: BurstPolicy;
-/**
- * How long after a client action a registry change is that action's own echo.
- *
- * A press, a release, a decision, a goal switch and an opened panel each read
- * the host as they run, so their answer is already on screen when the host
- * announces what they did — one `commands/change` per marker command, measured
- * 0.44 s to 2.04 s apart, a cadence the coalescing window cannot merge. Reading
- * those back is paying for an answer the user already has.
- *
- * The window is what makes `commands/change` mean "something moved that this
- * browser did not do". It is refreshed by every change it absorbs, so a storm
- * that keeps arriving stays absorbed rather than leaking one read per change,
- * and it ends for good `ACTION_ABSORB_MS` after the last change: a change after
- * that is news, and so is the next user action, which reads on its own.
- *
- * The margin over the measured 2.04 s gap is deliberate: a transition's own
- * storm has to fit inside the window for the whole storm to stay absorbed.
- */
-export declare const ACTION_ABSORB_MS = 2500;
-/**
- * The waits one burst uses when its first wait is `first`: four reads spread
- * over roughly ten times that. Long enough that a read a hidden page or an
- * in-flight pass deferred is still taken, short enough that a state which never
- * settles costs a handful of log records rather than a night of them.
- * @param first - milliseconds before the burst's first read, after its window; `<= 0` disables bursting.
- * @returns the waits, in order; empty when bursting is disabled.
- */
-export declare function burstWaits(first: number): readonly number[];
-/** Start and clear one timer, spelled so a test can drive the clock. */
-export interface BurstClock {
-    /**
-     * @param callback - the read to run.
-     * @param ms - how long to wait.
-     * @returns the scheduled timer.
-     */
-    set(callback: () => void, ms: number): ReturnType<typeof setTimeout>;
-    /**
-     * @param timer - the timer to clear.
-     */
-    clear(timer: ReturnType<typeof setTimeout>): void;
-}
-/**
- * One control's re-read burst. Every method is safe to call in any order and as
- * often as the caller likes: a trigger starts at most one burst, and one burst
- * never arms more than one read at a time.
- */
-export declare class ReadBurst {
-    private readonly onRead;
-    private readonly policy;
-    private readonly clock;
-    /** The armed wait, when one is counting down. */
-    private timer;
-    /** Whether the burst is waiting out its collection window rather than a wait between reads. */
-    private window;
-    /** Waits this burst has not spent yet, front first. */
-    private left;
-    /** Whether a burst is in progress: it may be collecting, waiting, reading, or reading again. */
-    private running;
-    /** The absorption window a client action opened, while one is open. */
-    private absorbed;
-    /** Whether a control asked for the one look owed when the echo window closes. */
-    private recheck;
-    /**
-     * @param onRead - one more read. Called only for a read the burst owes and the page can show.
-     * @param policy - the collection window, the waits, and the visibility source.
-     * @param clock - the timer implementation.
-     */
-    constructor(onRead: () => void, policy: BurstPolicy, clock?: BurstClock);
-    /** Whether this control bursts at all. */
-    get enabled(): boolean;
-    /** Whether one more read is already counting down. */
-    get armed(): boolean;
-    /** Whether a burst is in progress, with or without a read counting down. */
-    get live(): boolean;
-    /** Whether a change right now is a client action's own echo. */
-    get absorbing(): boolean;
-    /**
-     * The user acted on this control and the action reads: a press, a release, a
-     * decision, a goal switch, an opened panel. Its read is the answer, and the
-     * registry changes it sets off announce themselves for a while afterwards, so
-     * until the window closes a trigger is that echo rather than news.
-     *
-     * Called as the action is taken, before its read lands, because the echo can
-     * arrive while the action is still running.
-     */
-    absorb(): void;
-    /**
-     * Ask for one read at the moment the echo window closes, because the action's
-     * own read left a state that is still moving.
-     *
-     * The echo window swallows a transition announced inside it — the forwarded
-     * event carries no payload, so nothing distinguishes a marker registration
-     * from a phase change — and after the window no change is guaranteed to come:
-     * the transition that was hidden may be the last one this park makes. The
-     * look owed here is the read that finds it, one per action, and it is not a
-     * watch: once the window has closed, every further change is news and buys its
-     * own read. A control whose action left a settled state owes nothing and asks
-     * for nothing.
-     */
-    recheckAfterEcho(): void;
-    /**
-     * Something moved — a registry change. The burst first waits out its
-     * collection window, and every trigger that lands inside it restarts that
-     * window: the two or three registrations of one park start one burst rather
-     * than one each. A burst already past its window takes this as covered —
-     * every read it still owes happens after the change.
-     *
-     * @returns whether the change is news rather than a client action's own echo.
-     * The echo announces what the action's read already answered, so only a news
-     * trigger is a change a control still owes a read for; a change that lands
-     * while a burst is under way is covered by the read that burst already owes.
-     * `false` also for a disabled burst, which reads nothing at all.
-     */
-    trigger(): boolean;
-    /**
-     * The control knows it still owes a read: a change that is news has arrived,
-     * or a reading just revealed something only a read can answer. A call outside
-     * any burst starts one. Absorption never applies here — this is not a change
-     * some action caused, it is a read the control already knows it needs.
-     */
-    next(): void;
-    /**
-     * Nothing is moving: end the burst and forget it. The last reading stays
-     * published, and the next trigger starts a fresh burst. Two things outlive
-     * this: an action's absorption window, which is about what the action caused
-     * rather than about the state, and the one look it may still owe — see
-     * {@link recheckAfterEcho}.
-     */
-    stop(): void;
-    /** Drop the armed wait. A burst that is still owed its read survives it; see {@link checkVisibility}. */
-    cancel(): void;
-    /**
-     * Re-evaluate one page-visibility change. Going off screen drops the armed
-     * wait — a hidden page is not being read — and coming back arms it again, so
-     * the burst resumes where it stopped instead of being spent while nobody was
-     * looking. A burst still collecting resumes its window, restarted from the
-     * moment the page came back: a trigger that arrived while it was hidden still
-     * postpones the read.
-     */
-    checkVisibility(): void;
-    /** Spend the next wait of the burst, or end it when the bound is reached. */
-    private owe;
-    /**
-     * (Re)start the collection window. While the page is hidden nothing is armed
-     * — hidden time is not charged to the burst — and a trigger that lands then
-     * is still collected, because coming back starts a whole window.
-     */
-    private armWindow;
-    /** Put back whatever the burst still owed: its window, or the wait after a read. */
-    private arm;
-    /**
-     * (Re)start the absorption window a client action opened. A hidden page keeps
-     * absorbing: this window is about what the action caused, not about what the
-     * page is doing. When the window closes, the one look an unsettled action owes
-     * is taken; the window is restarted by every change it absorbs, so that look
-     * waits for the echo to actually stop.
-     */
-    private armAbsorb;
-    /** Close the absorption window: changes are news again. */
-    private cancelAbsorb;
-    /**
-     * Arm one wait, spending it when it fires. The wait stays in `left` until
-     * then, so a page hidden mid-wait takes the whole wait again: hidden time is
-     * neither charged to the burst nor lost from it.
-     */
-    private armWait;
-    /** Whether the page counts as on screen now, with an absent `document` read as on screen. */
-    private visibleNow;
-}