@argszero/cordis-plugin-subagent-wait 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 argszero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# cordis-plugin-subagent-wait
+
+`wait_for_agent` for the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (`dsh`).
+
+A thin orchestration helper for **continuable background subagents**: it blocks — under a bounded timeout —
+until a specific continuable child is **terminal**, instead of forcing the parent to re-derive completion by
+polling `list_agents` (whose `idle` status collapses "between turns" and "waiting on its own children").
+
+## Why
+
+`list_agents` reports a child's status as `running | idle | ready`. But `idle` is ambiguous:
+
+- an `idle` child may simply be between turns;
+- **an `idle` child may be blocked-waiting on its own grandchildren** — and is *not* terminal.
+
+So a parent that polls `list_agents` and treats `status !== 'running'` as "done" can hang on a child that is
+actually waiting on its own descendants. `status === 'ready'` (only in storage) is also **not** a terminal
+result to collect — it means "resumable, not finished."
+
+`wait_for_agent` solves this by keying on the **settlement signal**, not a status read: the harness's
+continuation manager publishes a `subagent-settled` notice (a typed message source, `form: notice`, carrying
+the child's `senderSessionId`) into the **parent agent's inbox** exactly when the child settles and is
+disposed. This plugin binds to that signal (via the `agent/inbox/inserted` event) and falls back to a bounded
+registry/status read, so a blocked-waiting child is never mistaken for terminal.
+
+## Install
+
+```sh
+npm install @argszero/cordis-plugin-subagent-wait
+```
+
+Mount the plugin into your `dsh` profile (it registers the `wait_for_agent` tool):
+
+```yaml
+# cordis.yml
+plugins:
+  "@argszero/cordis-plugin-subagent-wait": {}
+```
+
+> Requires the subagent continuation runtime (`@deepseek-ai/dsh-subagent` is a peer dependency). The tool
+> is a thin model-facing adapter over `ctx.subagents` and the live Agent registry.
+
+> **Version pin.** The `@deepseek-ai/dsh-*` `latest` dist-tag is frozen at an old `0.0.1-rc.1`; the current
+> harness line is published under `next` (`0.1.2-rc.1`). This plugin's peer range (`>=0.1.0`) resolves to
+> `next` and **excludes** the stale `latest`. If you install by tag, prefer:
+>
+> ```sh
+> npm install @argszero/cordis-plugin-subagent-wait @deepseek-ai/dsh-tools@next @deepseek-ai/dsh-subagent@next
+> ```
+
+## Usage
+
+After starting a **continuable** background subagent, call `wait_for_agent` to block until it settles:
+
+```
+wait_for_agent agent_id="<child session id>" timeout_ms=30000
+```
+
+Returns:
+
+```json
+{ "settled": true, "status": "settled", "agent_id": "<child session id>" }
+```
+
+When the timeout lapses (and the child is still alive), `settled` is `false` and `status` reflects the
+observed runtime status (`running` / `idle` / `ready`). A `false` result means "the child may still be
+running" — not "the child failed."
+
+### Parameters
+
+| param | type | default | description |
+|-------|------|---------|-------------|
+| `agent_id` | `string` | — (required) | The durable session id of your direct continuable child. |
+| `timeout_ms` | `number` | `30000` | Max milliseconds to block. Capped at `300000`. |
+
+## Exported helper
+
+The same logic is available as a parent-side helper for other plugins:
+
+```ts
+import { waitForAgent } from '@argszero/cordis-plugin-subagent-wait'
+import type { Context } from '@deepseek-ai/cordis'
+
+const { settled, status } = await waitForAgent(ctx, parentAgent, childId, {
+  signal,            // caller cancellation
+  timeoutMs: 30_000, // bounded wait (default 30s)
+})
+// settled: true  → the child disposed (terminal)
+// status: 'idle'  → timeout, child alive but between turns (NOT terminal)
+```
+
+## Design notes
+
+- **Keyed on settlement, not status.** The wait binds to the `subagent-settled` notice carrying the child id,
+  and re-checks registry terminality (disposal) as a fallback. An `idle` child waiting on its own
+  grandchildren never satisfies the wait.
+- **Timeout is mandatory.** A model-facing tool must never be left awaiting a child that never settles, so
+  the wait is always bounded.
+- **Cooperative cancellation.** The wait observes the tool's `signal` and resolves promptly on abort.
+- **Composes public surface only.** It widens no core interface: it consumes `agent/inbox/inserted` (a
+  registered typed event), `ctx.subagents.listChildren()`, and the live Agent registry. The core
+  `wait_for_agent` primitive, if upstream adopts one, stays a separate harness concern.
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A thin orchestration helper for continuable background subagents: a
+ * `wait_for_agent` model-facing tool (and a parent-side `waitForAgent`
+ * helper) that blocks — under a bounded timeout — until a specific
+ * continuable child is terminal, instead of forcing the parent to re-derive
+ * completion by polling `list_agents` (whose `idle` status collapses
+ * "between turns" and "waiting on its own children").
+ *
+ * The wait is keyed on the *settlement signal*, not a status read: the
+ * continuation manager publishes a `subagent-settled` notice
+ * (`SubagentSettledMessageSource`, `form: notice`) carrying the child's
+ * `senderSessionId` into the parent agent's inbox exactly when the child
+ * settles. `wait_for_agent` binds to that typed source kind (and falls back to
+ * a bounded registry/status read), so an `idle` child that is merely
+ * blocked-waiting on its own grandchildren is never mistaken for terminal.
+ *
+ * This composes *existing public surface* — the `agent/inbox/inserted` event,
+ * `ctx.subagents.listChildren()`, and the live Agent registry — and widens no
+ * core interface. It is the orchestration-layer package the community invited
+ * (see the subagent continuation discussion); the core `wait_for_agent`
+ * primitive, if any, stays a separate harness concern.
+ *
+ * @module @argszero/cordis-plugin-subagent-wait
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+export declare const name = "tool-subagent-wait";
+export declare const inject: string[];
+/** Default maximum milliseconds the wait may block before returning the current status. */
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+/** Per-call cap so a single tool invocation cannot block a step indefinitely. */
+export declare const MAX_TIMEOUT_MS = 300000;
+/** Observed terminal/status shape returned by {@link waitForAgent}. */
+export type WaitStatus = 'settled' | 'running' | 'idle' | 'ready';
+/** One result: whether the child became terminal, plus its observed status. */
+export interface WaitResult {
+    readonly settled: boolean;
+    readonly status: WaitStatus;
+}
+/**
+ * Block until `childId` reaches agent terminality, or `timeoutMs` elapses, or
+ * `signal` aborts. Returns the terminal/observed status so the caller can
+ * distinguish "settled" from "still running at timeout."
+ *
+ * @param ctx - context carrying the live Agent registry and the parent's
+ *   scope for `agent/inbox/inserted` subscription.
+ * @param parent - the exact calling agent whose inbox carries the
+ *   `subagent-settled` notice.
+ * @param childId - the durable child session id to wait on.
+ * @param options - `signal` for cancellation and `timeoutMs` bound.
+ */
+export declare function waitForAgent(ctx: Context, parent: Agent, childId: SessionId, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<WaitResult>;
+/**
+ * Register the `wait_for_agent` tool.
+ * @param ctx - context carrying the tool registry, subagent service, and live Agent registry.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAe,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGtE,eAAO,MAAM,IAAI,uBAAuB,CAAA;AACxC,eAAO,MAAM,MAAM,UAAmC,CAAA;AAEtD,2FAA2F;AAC3F,eAAO,MAAM,kBAAkB,QAAS,CAAA;AAExC,iFAAiF;AACjF,eAAO,MAAM,cAAc,SAAU,CAAA;AAErC,uEAAuE;AACvE,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAA;AAEjE,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;CAC5B;AAcD;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,KAAK,EACb,OAAO,EAAE,SAAS,EAClB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACzD,OAAO,CAAC,UAAU,CAAC,CA+DrB;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAqDxC"}

package/lib/index.js

@@ -0,0 +1,175 @@
+/**
+ * A thin orchestration helper for continuable background subagents: a
+ * `wait_for_agent` model-facing tool (and a parent-side `waitForAgent`
+ * helper) that blocks — under a bounded timeout — until a specific
+ * continuable child is terminal, instead of forcing the parent to re-derive
+ * completion by polling `list_agents` (whose `idle` status collapses
+ * "between turns" and "waiting on its own children").
+ *
+ * The wait is keyed on the *settlement signal*, not a status read: the
+ * continuation manager publishes a `subagent-settled` notice
+ * (`SubagentSettledMessageSource`, `form: notice`) carrying the child's
+ * `senderSessionId` into the parent agent's inbox exactly when the child
+ * settles. `wait_for_agent` binds to that typed source kind (and falls back to
+ * a bounded registry/status read), so an `idle` child that is merely
+ * blocked-waiting on its own grandchildren is never mistaken for terminal.
+ *
+ * This composes *existing public surface* — the `agent/inbox/inserted` event,
+ * `ctx.subagents.listChildren()`, and the live Agent registry — and widens no
+ * core interface. It is the orchestration-layer package the community invited
+ * (see the subagent continuation discussion); the core `wait_for_agent`
+ * primitive, if any, stays a separate harness concern.
+ *
+ * @module @argszero/cordis-plugin-subagent-wait
+ */
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'tool-subagent-wait';
+export const inject = ['tools', 'subagents', 'agents'];
+/** Default maximum milliseconds the wait may block before returning the current status. */
+export const DEFAULT_TIMEOUT_MS = 30_000;
+/** Per-call cap so a single tool invocation cannot block a step indefinitely. */
+export const MAX_TIMEOUT_MS = 300_000;
+/** Whether one child is terminal according to the live Agent registry. */
+function isAgentTerminal(agents, id) {
+    return agents.get(id) === undefined;
+}
+/** Whether an inserted inbox message is the settlement notice for `childId`. */
+function isSettlementFor(message, childId) {
+    const source = message.source;
+    return source.kind === 'subagent-settled'
+        && source.senderSessionId === childId;
+}
+/**
+ * Block until `childId` reaches agent terminality, or `timeoutMs` elapses, or
+ * `signal` aborts. Returns the terminal/observed status so the caller can
+ * distinguish "settled" from "still running at timeout."
+ *
+ * @param ctx - context carrying the live Agent registry and the parent's
+ *   scope for `agent/inbox/inserted` subscription.
+ * @param parent - the exact calling agent whose inbox carries the
+ *   `subagent-settled` notice.
+ * @param childId - the durable child session id to wait on.
+ * @param options - `signal` for cancellation and `timeoutMs` bound.
+ */
+export async function waitForAgent(ctx, parent, childId, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    // A terminal child is one the registry no longer holds. This is the
+    // settlement-by-disposal path: the continuation manager disposes the
+    // AgentHandle when a continuable child settles, so its absence IS terminal.
+    if (isAgentTerminal(ctx.agents, childId)) {
+        return { settled: true, status: 'settled' };
+    }
+    const signal = options.signal;
+    return new Promise((resolve) => {
+        let done = false;
+        let disposeInbox;
+        let removeAbort;
+        let timer;
+        const finish = (settled, status) => {
+            if (done)
+                return;
+            done = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (disposeInbox !== undefined)
+                disposeInbox();
+            if (removeAbort !== undefined) {
+                signal?.removeEventListener('abort', onAbort);
+                removeAbort = undefined;
+            }
+            resolve({ settled, status });
+        };
+        const onInserted = (payload) => {
+            // Scope-filtered dispatch delivers only this agent's messages, but the
+            // listener is registered on the shared ctx — filter by the exact parent.
+            if (payload.agent !== parent)
+                return;
+            if (!isSettlementFor(payload.message, childId))
+                return;
+            finish(true, 'settled');
+        };
+        const onAbort = () => finish(false, 'running');
+        // A settlement notice establishes terminality, but the notice may have
+        // already been claimed from the inbox before we subscribed. Close that
+        // window by re-checking registry terminality after subscribing.
+        disposeInbox = ctx.on('agent/inbox/inserted', onInserted);
+        if (signal !== undefined) {
+            signal.addEventListener('abort', onAbort, { once: true });
+            removeAbort = () => signal.removeEventListener('abort', onAbort);
+        }
+        timer = setTimeout(() => {
+            // Timeout: re-read the live registry. If the child disposed during the
+            // wait boundary, report settled; otherwise report the observed status.
+            const agent = ctx.agents.get(childId);
+            const observed = agent === undefined
+                ? 'settled'
+                : agent.status === 'running' ? 'running' : 'idle';
+            finish(agent === undefined, observed);
+        }, timeoutMs);
+        // Unref so the timer does not keep the process alive on a long idle wait.
+        timer.unref();
+        // Post-subscription re-check: the child may have settled between the
+        // initial status read and our listener registration.
+        if (isAgentTerminal(ctx.agents, childId))
+            finish(true, 'settled');
+    });
+}
+/**
+ * Register the `wait_for_agent` tool.
+ * @param ctx - context carrying the tool registry, subagent service, and live Agent registry.
+ */
+export function apply(ctx) {
+    ctx.tools.register(defineTool({
+        name: 'wait_for_agent',
+        description: 'Block until a direct continuable background subagent reaches terminality (settles and is disposed), '
+            + 'or until a bounded timeout elapses. Use this instead of repeatedly calling `list_agents` and '
+            + 'interpreting `idle`: an `idle` child may simply be waiting on its own children, and is NOT terminal. '
+            + 'This call keys on the settlement signal (the `subagent-settled` notice the manager sends to your '
+            + 'inbox when the child finishes), so it is correct even when the child is blocked-waiting on '
+            + 'grandchildren. Returns `true` when the child settled, `false` when the timeout lapsed (the child may '
+            + 'still be running). A timeout is mandatory so a model is never left awaiting a child that never settles.',
+        parameters: {
+            agent_id: {
+                type: 'string',
+                required: true,
+                description: 'The agent id of your direct continuable child to wait on.',
+            },
+            timeout_ms: {
+                type: 'number',
+                description: 'Maximum milliseconds to block before returning the current status. '
+                    + `Defaults to ${DEFAULT_TIMEOUT_MS} (${DEFAULT_TIMEOUT_MS / 1000}s), capped at ${MAX_TIMEOUT_MS / 1000}s.`,
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    settled: { type: 'boolean', required: true },
+                    status: { type: 'string', required: true, enum: ['settled', 'running', 'idle', 'ready'] },
+                    agent_id: { type: 'string', required: true },
+                },
+            },
+            render: (args, value) => [{
+                    type: 'text',
+                    text: value.settled
+                        ? `agent ${args.agent_id} settled`
+                        : `agent ${args.agent_id} is ${value.status} after waiting (timeout)`,
+                }],
+        },
+        async execute(args, exec) {
+            const parent = exec.agent;
+            if (!parent) {
+                throw new Error('wait_for_agent requires a calling agent (exec.agent was undefined)');
+            }
+            const timeoutMs = args.timeout_ms === undefined ? DEFAULT_TIMEOUT_MS : Math.min(args.timeout_ms, MAX_TIMEOUT_MS);
+            const result = await waitForAgent(ctx, parent, brandString(args.agent_id), {
+                signal: exec.signal,
+                timeoutMs,
+            });
+            return { settled: result.settled, status: result.status, agent_id: args.agent_id };
+        },
+    }));
+}
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

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

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@argszero/cordis-plugin-subagent-wait",
+  "description": "wait_for_agent for the dsh harness: block until a continuable background subagent settles (via the subagent-settled notice) instead of polling list_agents and misreading idle.",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.0 <5",
+    "@deepseek-ai/dsh-tools": ">=0.1.0",
+    "@deepseek-ai/dsh-subagent": ">=0.1.0",
+    "@deepseek-ai/dsh-agent": ">=0.1.0",
+    "@deepseek-ai/dsh-session": ">=0.1.0",
+    "@deepseek-ai/dsh-brand": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-agents": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "prepack": "tsc -p .",
+    "test": "node test/logic.test.mjs"
+  },
+  "engines": {
+    "node": "^22.19 || >=24"
+  },
+  "keywords": [
+    "deepseek",
+    "dsh",
+    "cordis",
+    "plugin",
+    "subagent",
+    "wait",
+    "orchestration",
+    "continuable"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/argszero/cordis-plugin-subagent-wait.git"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.0 <5",
+    "@deepseek-ai/dsh-tools": ">=0.1.0",
+    "@deepseek-ai/dsh-subagent": ">=0.1.0",
+    "@deepseek-ai/dsh-agent": ">=0.1.0",
+    "@deepseek-ai/dsh-session": ">=0.1.0",
+    "@deepseek-ai/dsh-brand": ">=0.1.0",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@types/node": "^22.20.1"
+  }
+}