@deepseek-ai/dsh-tool-workflow 0.0.1-rc.1 → 0.0.1-rc.3

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/workflow/tool-workflow/README.md
-README.md: 29896bee0f78a1d1764c3908965325fcecbf7b53
-README.zh.md: 12e1ecd8932120c74384a289530954422ba145f2
+README.md: 918fe5b9aff74b3b959107ec1eebfd7966afe6d1
+README.zh.md: f7e62560a1b581cf64d78dc379b821d17f29b3aa

package/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-The model-facing **`workflow` tool**: run a JavaScript orchestration script that fans out subagents, and return the script's final value. This package owns the model-facing schema and run lifecycle over [`ctx.workflows`](../workflow/README.md); script parsing, execution, caps, and cancellation live behind the seam, while the consumer retains ownership of the parent-facing schema and result envelope.
+The model-facing **`workflow` tool**: run a JavaScript orchestration script that fans out subagents, and return the script's final value. This package owns the model-facing schema and run lifecycle over [`ctx.workflowEngine`](../workflow/README.md); script parsing, execution, caps, and cancellation live behind the seam, while the consumer retains ownership of the parent-facing schema and result envelope.
 
 ## What the model sees
 
@@ -12,6 +12,10 @@ Three parameters: `meta` (required identity data: `name`, `description`, and opt
 
 Collection is synchronous (like [`dsh-tool-subagent`](../../subagent/tool-subagent/README.md)): `execute` starts a run and awaits `run.result` inside a `try/finally` that always disposes the run, so the script and its children reach quiescence on every path. `exec.signal` is bridged to `run.cancel()` (including the already-aborted-before-start case). A non-`completed` stop reason maps to an `isError` result reporting the reason—never partial output as success; a parse/meta failure thrown synchronously by `start()` becomes an `isError` the model can correct from. Completion returns canonical `{ runId, agentsStarted, result }`; the Native renderer preserves the meta name, agent count, and JSON value, truncating only that projection at `maxResultChars`.
 
+For a root transport execution (`exec.parent` absent), the tool also projects the run into the calling Agent's Session: run-start after `start()` returns, matching member starts and endings filtered by `run.id`, then run-end only after `run.result` is available and `dispose()` has reached quiescence. Nested transport calls execute normally but write no workflow record. The first failed Session append disables later recording for that run, emits one warning, and leaves either no record or a legal continuous prefix without changing the tool result or cleanup.
+
+The browser-safe `@deepseek-ai/dsh-tool-workflow/types` subpath owns these four log-only event payloads and their `SessionEventMap` declaration. The package invariant rejects duplicate starts, unpaired members, terminal events with open members, and updates after run-end on both cold load and live append while accepting missing terminal suffixes.
+
 ## Render intent
 
 Decided up front (per the [render-intent Agent Note](../../../.agents/notes/implemented/architecture/2026-07-02-tool-render-intent-union.md)): a `generic` card titled `workflow: <meta.name>`, read directly from `args.meta.name` (presentation is a pure function of args and does not ask the engine to parse); the script text rides as `rawInput`. The result keeps the generic card.
@@ -75,6 +79,7 @@ Append-only; newly visible content follows the reusable request prefix and does
 
 ## Known Limitations and Deferred Work
 
-- **The parent turn blocks until the whole workflow settles** — there is no background start/poll surface, and cancellation discards partial output as an error.
+- **The parent turn blocks until the whole workflow settles** — there is no background start/poll API, and cancellation discards partial output as an error.
 - **`args` must be an object and Native result text is bounded** — callers wrap top-level arrays/scalars in a field; the canonical workflow result remains complete, while JSON beyond `maxResultChars` is truncated in the model-facing projection rather than stored behind a retrieval handle.
 - **Workflow policy is fixed per tool registration** — provider selection, caps, and tool name are deployment config, not model-call arguments.
+- **Durable records are top-level and observational** — nested Code Mode dispatches are not recorded, and a recording failure intentionally degrades to an incomplete prefix rather than changing execution.

package/README.zh.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-面向模型的 **`workflow` 工具**：运行一段扇出 subagent 的 JavaScript 编排脚本，并返回脚本的最终值。本包负责基于 [`ctx.workflows`](../workflow/README.md) 定义面向模型的 schema 和运行生命周期；脚本解析、执行、上限与取消位于 seam 之后，消费方仍负责面向父级的 schema 和结果包络。
+面向模型的 **`workflow` 工具**：运行一段扇出 subagent 的 JavaScript 编排脚本，并返回脚本的最终值。本包负责基于 [`ctx.workflowEngine`](../workflow/README.md) 定义面向模型的 schema 和运行生命周期；脚本解析、执行、上限与取消位于 seam 之后，消费方仍负责面向父级的 schema 和结果包络。
 
 ## 模型看到的内容
 
@@ -10,7 +10,11 @@
 
 ## 生命周期
 
-收集是同步的（类似 [`dsh-tool-subagent`](../../subagent/tool-subagent/README.md)）：`execute` 启动运行并等待 `run.result`；这些操作位于 `try/finally` 中，该结构总会 dispose（资源释放）运行，使脚本及其子 agent（智能体）在每条路径上完全停稳。`exec.signal` 会桥接到 `run.cancel()`，包括启动前已经中止的情况。非 `completed` 结束原因会映射为报告原因的 `isError` 结果，绝不会把局部输出当作成功；`start()` 同步抛出的解析/meta 失败会变成模型可据以修正的 `isError`。完成时返回规范值 `{ runId, agentsStarted, result }`；Native 渲染器保留 meta 名称、agent 数量和 JSON 值，只会在 `maxResultChars` 处截断该投影。
+收集是同步的（类似 [`dsh-tool-subagent`](../../subagent/tool-subagent/README.md)）：`execute` 启动运行并等待 `run.result`；这些操作位于 `try/finally` 中，该结构总会 dispose（资源释放）运行，使脚本及其子 agent（智能体）在每条路径上完全停稳。`exec.signal` 会桥接到 `run.cancel()`，包括启动前已经中止的情况。非 `completed` 结束原因会映射为报告原因的 `isError` 结果，绝不会把局部输出当作成功；`start()` 同步抛出的解析／meta 失败会变成模型可据以修正的 `isError`。完成时返回规范值 `{ runId, agentsStarted, result }`；Native 渲染器保留 meta 名称、agent 数量和 JSON 值，只会在 `maxResultChars` 处截断该投影。
+
+对于根 transport 执行（`exec.parent` 缺省），工具还会把运行投影到调用 Agent 的 Session：`start()` 返回后写 run-start，只记录 `run.id` 匹配的成员开始与结束，并且只在 `run.result` 已取得且 `dispose()` 完全停稳后写 run-end。嵌套 transport 调用照常执行，但不写工作流记录。任一次 Session append 首次失败后，本运行会停止后续记录并只告警一次，留下空记录或合法连续前缀，同时不改变工具结果和清理。
+
+浏览器安全的 `@deepseek-ai/dsh-tool-workflow/types` 子路径拥有这四类 log-only 事件 payload 及其 `SessionEventMap` 声明。包 invariant 会在冷加载和实时追加时拒绝重复 start、未配对成员、仍有开放成员的终点和 run-end 后更新，同时允许缺失终态后缀的连续前缀。
 
 ## 渲染意图
 
@@ -75,6 +79,7 @@ Use the <toolName> tool ONLY when the user explicitly asks for a workflow or for
 
 ## 已知限制与暂缓事项
 
-- **父级轮次会阻塞到整个工作流结算**：没有后台启动/轮询接口，取消会把局部输出作为错误丢弃。
-- **`args` 必须是对象，Native 结果文本有界**：调用方把顶层数组/标量包装到字段中；规范工作流结果保持完整，超过 `maxResultChars` 的 JSON 会在面向模型的投影中截断，而不是存储在检索句柄背后。
+- **父级轮次会阻塞到整个工作流结算**：没有后台启动／轮询接口，取消会丢弃局部输出并返回错误。
+- **`args` 必须是对象，Native 结果文本有界**：调用方把顶层数组／标量包装到字段中；规范工作流结果保持完整，超过 `maxResultChars` 的 JSON 会在面向模型的投影中截断，而不是存储在检索句柄背后。
 - **每次工具注册的工作流策略固定**：提供方选择、上限和工具名称属于部署配置，不是模型调用参数。
+- **持久记录只覆盖顶层且只供观察**：嵌套 Code Mode dispatch 不记录；记录故障会刻意退化为不完整前缀，而不改变执行。

package/lib/index.js

@@ -4,7 +4,7 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 /**
 * The model-facing `workflow` tool: run a JavaScript orchestration script that fans out
 * subagents, and return the script's final value. It owns the model-facing schema and run lifecycle; script
-* parsing, execution, caps, and cancellation live behind `ctx.workflows`
+* parsing, execution, caps, and cancellation live behind `ctx.workflowEngine`
 * (`@deepseek-ai/dsh-workflow`), so a hardened engine swaps in without touching what the model
 * sees. Execution awaits `run.result` and always disposes the run; non-completed reasons become tool
 * errors, and background collection remains deferred. Presentation is an args-only generic card
@@ -15,13 +15,77 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 const name = "tool-workflow";
 const inject = [
 	"tools",
-	"workflows",
+	"workflowEngine",
 	"systemPrompt"
 ];
 const Config = z.object({
 	toolName: z.string().default("workflow"),
 	maxResultChars: z.natural().min(1).default(5e4)
 });
+/** Render a contained recording failure without trusting the thrown value. */
+function renderRecordingError(error) {
+	try {
+		return String(error);
+	} catch {
+		return "[unrenderable thrown value]";
+	}
+}
+/**
+* Project active top-level workflow runs into their parent Sessions without
+* letting recording failure affect tool execution.
+*/
+function createWorkflowRecorder(ctx) {
+	const active = /* @__PURE__ */ new Map();
+	const append = (session, type, data) => {
+		const appendRecord = session.append.bind(session);
+		try {
+			appendRecord(type, data);
+			return true;
+		} catch (error) {
+			ctx.logger.warn(`tool-workflow: disabled durable record after ${type} append failed: ${renderRecordingError(error)}`);
+			return false;
+		}
+	};
+	ctx.on("workflow/agent-start", (info, agent) => {
+		const session = active.get(info.id);
+		if (session === void 0) return;
+		if (!append(session, "tool-workflow/agent-start", {
+			runId: info.id,
+			seq: agent.seq,
+			label: agent.label,
+			...agent.phase === void 0 ? {} : { phase: agent.phase },
+			childId: agent.childId
+		})) active.delete(info.id);
+	});
+	ctx.on("workflow/agent-end", (info, agent) => {
+		const session = active.get(info.id);
+		if (session === void 0) return;
+		if (!append(session, "tool-workflow/agent-end", {
+			runId: info.id,
+			seq: agent.seq,
+			outcome: agent.outcome
+		})) active.delete(info.id);
+	});
+	return {
+		start(session, run) {
+			if (append(session, "tool-workflow/run-start", {
+				runId: run.id,
+				name: run.meta.name
+			})) active.set(run.id, session);
+		},
+		finish(runId, stopReason) {
+			const session = active.get(runId);
+			if (session !== void 0) append(session, "tool-workflow/run-end", {
+				runId,
+				stopReason
+			});
+			active.delete(runId);
+		},
+		abandon: (runId) => {
+			active.delete(runId);
+		}
+	};
+}
 /**
 * The script-authoring contract, embedded in the tool description. This IS the
 * model-facing spec: the meta block, the hooks and their exact semantics, and
@@ -70,6 +134,7 @@ function renderResult(name, agentsStarted, value, maxChars) {
 }
 function apply(ctx, config) {
 	const { toolName, maxResultChars } = config;
+	const recorder = createWorkflowRecorder(ctx);
 	ctx.systemPrompt.section({
 		name: `tool:${toolName}`,
 		order: 115,
@@ -166,19 +231,22 @@ function apply(ctx, config) {
 		async execute(args, exec) {
 			const parent = exec.agent;
 			if (!parent) throw new Error("workflow tool requires a calling agent (exec.agent was undefined)");
-			const run = ctx.workflows.start({
+			const run = ctx.workflowEngine.start({
 				script: args.script,
 				meta: args.meta,
 				...args.args !== void 0 ? { args: args.args } : {},
 				parent,
 				signal: exec.signal
 			});
+			const recordsRun = exec.parent === void 0;
+			if (recordsRun) recorder.start(parent.session, run);
 			const onAbort = () => {
 				run.cancel("parent step aborted");
 			};
 			exec.signal.addEventListener("abort", onAbort, { once: true });
+			let result;
 			try {
-				const result = await run.result;
+				result = await run.result;
 				const error = stopReasonError(result);
 				if (error !== void 0) throw new Error(error);
 				return {
@@ -188,7 +256,16 @@ function apply(ctx, config) {
 				};
 			} finally {
 				exec.signal.removeEventListener("abort", onAbort);
-				await run.dispose();
+				try {
+					await run.dispose();
+					if (recordsRun) {
+						/* v8 ignore next -- WorkflowRun.result never rejects by contract, so result is assigned before finally. */
+						if (result === void 0) throw new Error("workflow run settled without a result");
+						recorder.finish(run.id, result.stopReason);
+					}
+				} finally {
+					if (recordsRun) recorder.abandon(run.id);
+				}
 			}
 		},
 		presentCall: (args) => presentWorkflowCall(args),

package/lib/invariant.js

@@ -1,23 +1,129 @@
 //#region lib/types/invariant.js
-/**
-* Package-owned invariant companion for `@deepseek-ai/dsh-tool-workflow`.
-* @module @deepseek-ai/dsh-tool-workflow/invariant
-*/
+/** Package-owned durable workflow-record invariants. @module @deepseek-ai/dsh-tool-workflow/invariant */
 const PACKAGE_NAME = "@deepseek-ai/dsh-tool-workflow";
 /** Cordis companion plugin name. */
 const name = "tool-workflow-invariant";
-/** Service required before the companion can reserve package ownership. */
+/** Services required to validate existing and newly appended Session logs. */
 const inject = ["invariants"];
-/**
-* No runtime invariant: this model-facing adapter has no independent lifecycle stream; execution
-* relations are owned by the capability seam it calls.
-*/
-const install = () => {};
-/**
-* Register this package's invariant companion.
-* @param ctx - Cordis context carrying the invariant service.
-* @returns the installed registration's disposer after setup succeeds.
-*/
+/** Whether this package owns the candidate Session event. */
+function isWorkflowRecordEvent(event) {
+	return event.type.startsWith("tool-workflow/");
+}
+/** Require a durable opaque identity to be a non-empty string. */
+function stringId(value, label, fail) {
+	if (typeof value !== "string" || value.length === 0) fail(`${label} must be a non-empty string`);
+	return value;
+}
+/** Require one workflow member's 1-based sequence identity. */
+function memberSeq(value, fail) {
+	if (!Number.isSafeInteger(value) || value < 1) fail("tool-workflow member seq must be a positive safe integer");
+	return value;
+}
+/** Read one plain payload field without trusting restored plugin data. */
+function recordOf(event, fail) {
+	const data = event.data;
+	if (data === null || typeof data !== "object" || Array.isArray(data)) fail(`${event.type} data must be a JSON object`);
+	return data;
+}
+/** Copy only the run one candidate can mutate; other committed states stay shared. */
+function cloneTraceForEvent(source, event, fail) {
+	const trace = new Map(source);
+	if (event.type === "tool-workflow/run-start") return trace;
+	const runId = stringId(recordOf(event, fail).runId, `${event.type} runId`, fail);
+	const run = source.get(runId);
+	if (run !== void 0) trace.set(runId, {
+		ended: run.ended,
+		members: new Map(run.members)
+	});
+	return trace;
+}
+/** Require the named run to exist and remain open. */
+function openRun(trace, runId, eventType, fail) {
+	const run = trace.get(runId);
+	if (run === void 0) fail(`${eventType} has no matching tool-workflow/run-start for run ${runId}`);
+	if (run.ended) fail(`${eventType} appears after tool-workflow/run-end for run ${runId}`);
+	return run;
+}
+/** Advance the workflow-record fold with one relevant Session event. */
+function applyEvent(trace, event, fail) {
+	const data = recordOf(event, fail);
+	const runId = stringId(data.runId, `${event.type} runId`, fail);
+	switch (event.type) {
+		case "tool-workflow/run-start":
+			if (typeof data.name !== "string" || data.name.length === 0) fail("tool-workflow/run-start name must be a non-empty string");
+			if (trace.has(runId)) fail(`tool-workflow/run-start repeats run ${runId}`);
+			trace.set(runId, {
+				ended: false,
+				members: /* @__PURE__ */ new Map()
+			});
+			return;
+		case "tool-workflow/agent-start": {
+			const run = openRun(trace, runId, event.type, fail);
+			const seq = memberSeq(data.seq, fail);
+			if (typeof data.label !== "string") fail("tool-workflow/agent-start label must be a string");
+			if (data.phase !== void 0 && typeof data.phase !== "string") fail("tool-workflow/agent-start phase must be a string when present");
+			stringId(data.childId, "tool-workflow/agent-start childId", fail);
+			if (run.members.has(seq)) fail(`tool-workflow/agent-start repeats member seq ${seq} in run ${runId}`);
+			run.members.set(seq, false);
+			return;
+		}
+		case "tool-workflow/agent-end": {
+			const run = openRun(trace, runId, event.type, fail);
+			const seq = memberSeq(data.seq, fail);
+			if (data.outcome !== "completed" && data.outcome !== "failed" && data.outcome !== "cancelled") fail(`tool-workflow/agent-end outcome ${String(data.outcome)} is invalid`);
+			const ended = run.members.get(seq);
+			if (ended === void 0) fail(`tool-workflow/agent-end has no matching member seq ${seq} in run ${runId}`);
+			if (ended) fail(`tool-workflow/agent-end repeats member seq ${seq} in run ${runId}`);
+			run.members.set(seq, true);
+			return;
+		}
+		case "tool-workflow/run-end": {
+			const run = openRun(trace, runId, event.type, fail);
+			if (data.stopReason !== "completed" && data.stopReason !== "cancelled" && data.stopReason !== "error") fail(`tool-workflow/run-end stopReason ${String(data.stopReason)} is invalid`);
+			const openMembers = [...run.members].filter(([, ended]) => !ended).map(([seq]) => seq);
+			if (openMembers.length > 0) fail(`tool-workflow/run-end leaves member seq ${openMembers.join(", ")} open in run ${runId}`);
+			run.ended = true;
+			run.members.clear();
+			return;
+		}
+		default: fail(`unknown tool-workflow event type ${event.type}`);
+	}
+}
+/** Install an independent incremental fold over every attached Session. */
+const install = Object.assign((ctx, fail) => {
+	const traces = /* @__PURE__ */ new WeakMap();
+	const staged = /* @__PURE__ */ new WeakMap();
+	const seed = (session) => {
+		const trace = /* @__PURE__ */ new Map();
+		for (const event of session.events.filter(isWorkflowRecordEvent)) applyEvent(trace, event, fail);
+		traces.set(session, trace);
+		return trace;
+	};
+	ctx.sessions.list().forEach(seed);
+	ctx.on("session/created", (session) => {
+		seed(session);
+	}, { global: true });
+	ctx.on("internal/dispatch", (_mode, eventName, args) => {
+		if (eventName !== "session/event") return;
+		const [session, event] = args;
+		if (!isWorkflowRecordEvent(event)) return;
+		const trace = cloneTraceForEvent(traces.get(session), event, fail);
+		applyEvent(trace, event, fail);
+		staged.set(event, {
+			session,
+			trace
+		});
+	}, { global: true });
+	ctx.on("session/event", (session, event) => {
+		if (!isWorkflowRecordEvent(event)) return;
+		const candidate = staged.get(event);
+		/* v8 ignore next 2 -- internal/dispatch stages the exact session/event callback arguments. */
+		if (candidate === void 0 || candidate.session !== session) return fail("session/event reached publication without matching workflow-record validation");
+		staged.delete(event);
+		traces.set(session, candidate.trace);
+	}, { global: true });
+}, { inject: ["sessions"] });
+/** Register this package's invariant companion. */
 const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
 //#endregion
 export { apply, inject, name };

package/lib/types/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * The model-facing `workflow` tool: run a JavaScript orchestration script that fans out
  * subagents, and return the script's final value. It owns the model-facing schema and run lifecycle; script
- * parsing, execution, caps, and cancellation live behind `ctx.workflows`
+ * parsing, execution, caps, and cancellation live behind `ctx.workflowEngine`
  * (`@deepseek-ai/dsh-workflow`), so a hardened engine swaps in without touching what the model
  * sees. Execution awaits `run.result` and always disposes the run; non-completed reasons become tool
  * errors, and background collection remains deferred. Presentation is an args-only generic card

package/lib/types/index.js

@@ -0,0 +1,278 @@
+/**
+ * The model-facing `workflow` tool: run a JavaScript orchestration script that fans out
+ * subagents, and return the script's final value. It owns the model-facing schema and run lifecycle; script
+ * parsing, execution, caps, and cancellation live behind `ctx.workflowEngine`
+ * (`@deepseek-ai/dsh-workflow`), so a hardened engine swaps in without touching what the model
+ * sees. Execution awaits `run.result` and always disposes the run; non-completed reasons become tool
+ * errors, and background collection remains deferred. Presentation is an args-only generic card
+ * titled from `meta.name`. Explicit-ask usage guidance is registered as the tool's own prompt
+ * section rather than deployment persona prose.
+ * @module @deepseek-ai/dsh-tool-workflow
+ */
+import z from '@deepseek-ai/schemastery';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'tool-workflow';
+export const inject = ['tools', 'workflowEngine', 'systemPrompt'];
+export const Config = z.object({
+    toolName: z.string().default('workflow'),
+    maxResultChars: z.natural().min(1).default(50_000),
+});
+/** Render a contained recording failure without trusting the thrown value. */
+function renderRecordingError(error) {
+    try {
+        return String(error);
+    }
+    catch {
+        return '[unrenderable thrown value]';
+    }
+}
+/**
+ * Project active top-level workflow runs into their parent Sessions without
+ * letting recording failure affect tool execution.
+ */
+function createWorkflowRecorder(ctx) {
+    const active = new Map();
+    const append = (session, type, data) => {
+        // These four package-owned events are all log-only. Narrowing the generic
+        // append face here discharges Session.append's conditional options tuple.
+        const appendRecord = session.append.bind(session);
+        try {
+            appendRecord(type, data);
+            return true;
+        }
+        catch (error) {
+            ctx.logger.warn(`tool-workflow: disabled durable record after ${type} append failed: ${renderRecordingError(error)}`);
+            return false;
+        }
+    };
+    ctx.on('workflow/agent-start', (info, agent) => {
+        const session = active.get(info.id);
+        if (session === undefined)
+            return;
+        const data = {
+            runId: info.id,
+            seq: agent.seq,
+            label: agent.label,
+            ...agent.phase === undefined ? {} : { phase: agent.phase },
+            childId: agent.childId,
+        };
+        if (!append(session, 'tool-workflow/agent-start', data))
+            active.delete(info.id);
+    });
+    ctx.on('workflow/agent-end', (info, agent) => {
+        const session = active.get(info.id);
+        if (session === undefined)
+            return;
+        const data = {
+            runId: info.id,
+            seq: agent.seq,
+            outcome: agent.outcome,
+        };
+        if (!append(session, 'tool-workflow/agent-end', data))
+            active.delete(info.id);
+    });
+    return {
+        start(session, run) {
+            if (append(session, 'tool-workflow/run-start', { runId: run.id, name: run.meta.name })) {
+                active.set(run.id, session);
+            }
+        },
+        finish(runId, stopReason) {
+            const session = active.get(runId);
+            if (session !== undefined)
+                append(session, 'tool-workflow/run-end', { runId, stopReason });
+            active.delete(runId);
+        },
+        abandon: (runId) => { active.delete(runId); },
+    };
+}
+/**
+ * The script-authoring contract, embedded in the tool description. This IS the
+ * model-facing spec: the meta block, the hooks and their exact semantics, and
+ * the supported schema subset.
+ */
+const DESCRIPTION = `Run a JavaScript workflow script that orchestrates subagents at scale. Use this for work that fans out across many independent pieces — an audit over many files, a migration, multi-angle research, adversarial verification of findings — where you write the orchestration as a script instead of delegating turn by turn.
+
+The workflow's identity rides the \`meta\` parameter as JSON: required \`name\` (short kebab-case) and \`description\` strings, optional \`whenToUse\` string and \`phases\` array (\`{title, detail?, provider?, model?}\`). The \`script\` parameter is the plain JavaScript body ONLY (NOT TypeScript, and NO \`export const meta\` statement — meta is a parameter, not code), running with top-level await; end with \`return <value>\` — the value must be JSON-serializable and is this tool's result.
+
+Script-body hooks:
+- \`agent(prompt, opts?): Promise<any>\` — run one subagent to completion. Without \`opts.schema\` it resolves to the child's final text; with \`opts.schema\` (an object-rooted JSON Schema using ONLY type/properties/required/additionalProperties/items/enum/const/oneOf — no pattern/format/numeric bounds) it resolves to the validated object. Resolves \`null\` when the child fails (filter with \`.filter(Boolean)\`). Other opts: \`label\` (display), \`phase\` (progress group), and independent \`provider\`/\`model\` LLM target overrides (either may be provided alone). Anything else (\`effort\`/\`isolation\`/\`agentType\`) is rejected loudly.
+- \`pipeline(items, ...stages): Promise<any[]>\` — run each item through the stages independently with NO barrier between stages (prefer this for multi-stage work). Each stage receives \`(prev, item, index)\`. An ordinary stage throw drops that ITEM to \`null\` and skips its remaining stages.
+- \`parallel(thunks): Promise<any[]>\` — run zero-argument functions concurrently and await ALL of them (a barrier; use only when a stage genuinely needs every prior result together). A throwing thunk resolves to \`null\`.
+- \`phase(title)\` — start a progress phase; \`log(message)\` — narrate progress; \`args\` — the tool call's \`args\` input, verbatim.
+
+Misused hooks (bad arguments, unknown options, unsupported schemas, tripped caps) throw errors that ALWAYS kill the script — they never dissolve into a per-item \`null\`.
+
+Constraints: concurrency and total-agent caps apply; no filesystem, network, timers, or Node.js APIs are provided — the agents do the work, the script only coordinates them. The run executes in the foreground: this call returns when the whole script finishes.`;
+/** The pending-state card: a generic card titled by the workflow's meta name. */
+function presentWorkflowCall(args) {
+    return {
+        card: 'generic',
+        title: `workflow: ${args.meta.name}`,
+        rawInput: args.script,
+    };
+}
+/** The completed-state card: keep the pending title; render the result content as-is. */
+function presentWorkflowResult(args, result) {
+    void args;
+    void result;
+    return { card: 'generic' };
+}
+/** A non-`completed` stop reason means the script did not finish cleanly. */
+function stopReasonError(result) {
+    switch (result.stopReason) {
+        case 'completed':
+            return undefined;
+        case 'cancelled':
+            return `workflow run was cancelled${result.error !== undefined ? ` (${result.error})` : ''}`;
+        case 'error':
+            return `workflow run failed: ${result.error ?? 'unknown error'}`;
+        /* v8 ignore start -- defensive: WorkflowStopReason is a closed union, exhaustive by construction; a future variant fails here loudly */
+        default:
+            return `workflow run ended abnormally (${String(result.stopReason)})`;
+        /* v8 ignore stop */
+    }
+}
+/** Render the run's outcome text: the meta name, agent count, and the JSON value (capped). */
+function renderResult(name, agentsStarted, value, maxChars) {
+    // The engine returns JSON data (null for a valueless script), so stringify never yields undefined.
+    const rendered = JSON.stringify(value, null, 2);
+    const clipped = rendered.length > maxChars
+        ? `${rendered.slice(0, maxChars)}\n… [truncated: ${rendered.length - maxChars} more characters]`
+        : rendered;
+    return `workflow "${name}" completed (${agentsStarted} agent${agentsStarted === 1 ? '' : 's'}).\nReturn value:\n${clipped}`;
+}
+export function apply(ctx, config) {
+    // schemastery (the exported Config schema) has already filled the defaulted
+    // fields; the assertion records that resolution, not a hidden fallback.
+    const { toolName, maxResultChars } = config;
+    const recorder = createWorkflowRecorder(ctx);
+    // Usage policy ships with the tool (the master convention: tool guidance
+    // lives in tool plugins as prompt sections, not in the deployment persona).
+    ctx.systemPrompt.section({
+        name: `tool:${toolName}`,
+        order: 115,
+        text: `Use the ${toolName} tool ONLY when the user explicitly asks for a workflow or for large multi-agent orchestration: you write a JavaScript script (the tool description documents the exact format) that fans work out across many subagents with phases and structured results. For one or two delegations, prefer plain subagent calls.`,
+    });
+    ctx.tools.register(defineTool({
+        name: toolName,
+        description: DESCRIPTION,
+        parameters: {
+            script: {
+                type: 'string',
+                required: true,
+                description: 'The plain-JS workflow script body (top-level await allowed; NO `export const meta` statement; end with `return <json-value>`).',
+            },
+            meta: {
+                type: 'object',
+                additionalProperties: true,
+                required: true,
+                description: 'The workflow identity block (plain JSON — never code).',
+                properties: {
+                    name: { type: 'string', required: true, description: 'Short kebab-case workflow name.' },
+                    description: { type: 'string', required: true, description: 'One-line description of what the workflow does.' },
+                    whenToUse: { type: 'string', description: 'Optional guidance on when this workflow applies.' },
+                    phases: {
+                        type: 'array',
+                        description: 'Optional phase declarations matched by phase() calls.',
+                        items: {
+                            type: 'object',
+                            additionalProperties: true,
+                            properties: {
+                                title: { type: 'string', required: true, description: 'The phase title phase() calls match by exact string.' },
+                                detail: { type: 'string', description: 'Optional one-line description of the phase.' },
+                                provider: { type: 'string', description: 'Optional provider override this phase is expected to use.' },
+                                model: { type: 'string', description: 'Optional model override this phase is expected to use.' },
+                            },
+                        },
+                    },
+                },
+            },
+            args: {
+                type: 'object',
+                additionalProperties: true,
+                description: 'Optional JSON input exposed to the script as the `args` global (wrap a bare list as a field, e.g. {"files": [...]}).',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    runId: { type: 'string', required: true },
+                    agentsStarted: { type: 'integer', required: true },
+                    result: { type: 'json', required: true },
+                },
+            },
+            render: (args, value) => [{
+                    type: 'text',
+                    text: renderResult(args.meta.name, value.agentsStarted, value.result, maxResultChars),
+                }],
+        },
+        async execute(args, exec) {
+            const parent = exec.agent;
+            if (!parent) {
+                // The loop sets `exec.agent` for every model-driven call; its absence
+                // means a non-agent caller invoked the tool directly, which has no
+                // parent to attribute the children to. Fail loud rather than guess.
+                throw new Error('workflow tool requires a calling agent (exec.agent was undefined)');
+            }
+            // Meta/body validation failures (META_INVALID/SCRIPT_PARSE) throw
+            // synchronously here and become isError results via the registry — the
+            // model sees the violation list and can correct the call.
+            const run = ctx.workflowEngine.start({
+                script: args.script,
+                meta: args.meta,
+                ...args.args !== undefined ? { args: args.args } : {},
+                parent,
+                signal: exec.signal,
+            });
+            const recordsRun = exec.parent === undefined;
+            // The shipped worker-thread engine publishes member events from later
+            // worker messages, after start() returns and this run record is active.
+            if (recordsRun)
+                recorder.start(parent.session, run);
+            // Bridge the tool's abort signal to the run: if the parent step is aborted while the
+            // script is in flight, cancel the whole run. The signal also enters the engine directly, but
+            // this local bridge preserves the tool contract even if an implementation ignores it.
+            const onAbort = () => { run.cancel('parent step aborted'); };
+            exec.signal.addEventListener('abort', onAbort, { once: true });
+            let result;
+            try {
+                result = await run.result;
+                const error = stopReasonError(result);
+                if (error !== undefined) {
+                    // Map a non-clean finish to an isError result (the registry turns a
+                    // throw into an isError). Report the reason, not partial output.
+                    throw new Error(error);
+                }
+                return {
+                    runId: run.id,
+                    agentsStarted: result.agentsStarted,
+                    result: result.value,
+                };
+            }
+            finally {
+                exec.signal.removeEventListener('abort', onAbort);
+                try {
+                    // Keep member listeners alive through disposal: an engine may
+                    // synthesize cancelled member endings while reaching quiescence.
+                    await run.dispose();
+                    if (recordsRun) {
+                        /* v8 ignore next -- WorkflowRun.result never rejects by contract, so result is assigned before finally. */
+                        if (result === undefined)
+                            throw new Error('workflow run settled without a result');
+                        recorder.finish(run.id, result.stopReason);
+                    }
+                }
+                finally {
+                    if (recordsRun)
+                        recorder.abandon(run.id);
+                }
+            }
+        },
+        presentCall: args => presentWorkflowCall(args),
+        presentResult: (args, result) => presentWorkflowResult(args, result),
+    }));
+}
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -1,16 +1,9 @@
-/**
- * Package-owned invariant companion for `@deepseek-ai/dsh-tool-workflow`.
- * @module @deepseek-ai/dsh-tool-workflow/invariant
- */
+/** Package-owned durable workflow-record invariants. @module @deepseek-ai/dsh-tool-workflow/invariant */
 import type { Context } from '@deepseek-ai/cordis';
 /** Cordis companion plugin name. */
 export declare const name = "tool-workflow-invariant";
-/** Service required before the companion can reserve package ownership. */
+/** Services required to validate existing and newly appended Session logs. */
 export declare const inject: string[];
-/**
- * Register this package's invariant companion.
- * @param ctx - Cordis context carrying the invariant service.
- * @returns the installed registration's disposer after setup succeeds.
- */
+/** Register this package's invariant companion. */
 export declare const apply: (ctx: Context) => Promise<() => void>;
 //# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,151 @@
+/** Package-owned durable workflow-record invariants. @module @deepseek-ai/dsh-tool-workflow/invariant */
+const PACKAGE_NAME = '@deepseek-ai/dsh-tool-workflow';
+/** Cordis companion plugin name. */
+export const name = 'tool-workflow-invariant';
+/** Services required to validate existing and newly appended Session logs. */
+export const inject = ['invariants'];
+/** Whether this package owns the candidate Session event. */
+function isWorkflowRecordEvent(event) {
+    return event.type.startsWith('tool-workflow/');
+}
+/** Require a durable opaque identity to be a non-empty string. */
+function stringId(value, label, fail) {
+    if (typeof value !== 'string' || value.length === 0)
+        fail(`${label} must be a non-empty string`);
+    return value;
+}
+/** Require one workflow member's 1-based sequence identity. */
+function memberSeq(value, fail) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        fail('tool-workflow member seq must be a positive safe integer');
+    }
+    return value;
+}
+/** Read one plain payload field without trusting restored plugin data. */
+function recordOf(event, fail) {
+    const data = event.data;
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        fail(`${event.type} data must be a JSON object`);
+    }
+    return data;
+}
+/** Copy only the run one candidate can mutate; other committed states stay shared. */
+function cloneTraceForEvent(source, event, fail) {
+    const trace = new Map(source);
+    if (event.type === 'tool-workflow/run-start')
+        return trace;
+    const data = recordOf(event, fail);
+    const runId = stringId(data.runId, `${event.type} runId`, fail);
+    const run = source.get(runId);
+    if (run !== undefined) {
+        trace.set(runId, { ended: run.ended, members: new Map(run.members) });
+    }
+    return trace;
+}
+/** Require the named run to exist and remain open. */
+function openRun(trace, runId, eventType, fail) {
+    const run = trace.get(runId);
+    if (run === undefined)
+        fail(`${eventType} has no matching tool-workflow/run-start for run ${runId}`);
+    if (run.ended)
+        fail(`${eventType} appears after tool-workflow/run-end for run ${runId}`);
+    return run;
+}
+/** Advance the workflow-record fold with one relevant Session event. */
+function applyEvent(trace, event, fail) {
+    const data = recordOf(event, fail);
+    const runId = stringId(data.runId, `${event.type} runId`, fail);
+    switch (event.type) {
+        case 'tool-workflow/run-start': {
+            if (typeof data.name !== 'string' || data.name.length === 0) {
+                fail('tool-workflow/run-start name must be a non-empty string');
+            }
+            if (trace.has(runId))
+                fail(`tool-workflow/run-start repeats run ${runId}`);
+            trace.set(runId, { ended: false, members: new Map() });
+            return;
+        }
+        case 'tool-workflow/agent-start': {
+            const run = openRun(trace, runId, event.type, fail);
+            const seq = memberSeq(data.seq, fail);
+            if (typeof data.label !== 'string')
+                fail('tool-workflow/agent-start label must be a string');
+            if (data.phase !== undefined && typeof data.phase !== 'string') {
+                fail('tool-workflow/agent-start phase must be a string when present');
+            }
+            stringId(data.childId, 'tool-workflow/agent-start childId', fail);
+            if (run.members.has(seq))
+                fail(`tool-workflow/agent-start repeats member seq ${seq} in run ${runId}`);
+            run.members.set(seq, false);
+            return;
+        }
+        case 'tool-workflow/agent-end': {
+            const run = openRun(trace, runId, event.type, fail);
+            const seq = memberSeq(data.seq, fail);
+            if (data.outcome !== 'completed' && data.outcome !== 'failed' && data.outcome !== 'cancelled') {
+                fail(`tool-workflow/agent-end outcome ${String(data.outcome)} is invalid`);
+            }
+            const ended = run.members.get(seq);
+            if (ended === undefined)
+                fail(`tool-workflow/agent-end has no matching member seq ${seq} in run ${runId}`);
+            if (ended)
+                fail(`tool-workflow/agent-end repeats member seq ${seq} in run ${runId}`);
+            run.members.set(seq, true);
+            return;
+        }
+        case 'tool-workflow/run-end': {
+            const run = openRun(trace, runId, event.type, fail);
+            if (data.stopReason !== 'completed' && data.stopReason !== 'cancelled' && data.stopReason !== 'error') {
+                fail(`tool-workflow/run-end stopReason ${String(data.stopReason)} is invalid`);
+            }
+            const openMembers = [...run.members].filter(([, ended]) => !ended).map(([seq]) => seq);
+            if (openMembers.length > 0) {
+                fail(`tool-workflow/run-end leaves member seq ${openMembers.join(', ')} open in run ${runId}`);
+            }
+            run.ended = true;
+            run.members.clear();
+            return;
+        }
+        default:
+            fail(`unknown tool-workflow event type ${event.type}`);
+    }
+}
+/** Install an independent incremental fold over every attached Session. */
+const install = Object.assign((ctx, fail) => {
+    const traces = new WeakMap();
+    const staged = new WeakMap();
+    const seed = (session) => {
+        const trace = new Map();
+        for (const event of session.events.filter(isWorkflowRecordEvent))
+            applyEvent(trace, event, fail);
+        traces.set(session, trace);
+        return trace;
+    };
+    ctx.sessions.list().forEach(seed);
+    ctx.on('session/created', (session) => { seed(session); }, { global: true });
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName !== 'session/event')
+            return;
+        const [session, event] = args;
+        if (!isWorkflowRecordEvent(event))
+            return;
+        // session/event dispatch follows list() or session/created seeding.
+        const trace = cloneTraceForEvent(traces.get(session), event, fail);
+        applyEvent(trace, event, fail);
+        staged.set(event, { session, trace });
+    }, { global: true });
+    ctx.on('session/event', (session, event) => {
+        if (!isWorkflowRecordEvent(event))
+            return;
+        const candidate = staged.get(event);
+        /* v8 ignore next 2 -- internal/dispatch stages the exact session/event callback arguments. */
+        if (candidate === undefined || candidate.session !== session) {
+            return fail('session/event reached publication without matching workflow-record validation');
+        }
+        staged.delete(event);
+        traces.set(session, candidate.trace);
+    }, { global: true });
+}, { inject: ['sessions'] });
+/** Register this package's invariant companion. */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//# sourceMappingURL=invariant.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Browser-safe durable workflow-record events written by the model-facing
+ * workflow tool into its calling parent Session.
+ *
+ * @module @deepseek-ai/dsh-tool-workflow/types
+ */
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { WorkflowAgentOutcome, WorkflowRunId, WorkflowStopReason } from '@deepseek-ai/dsh-workflow/types';
+/** Opens one durable top-level workflow run record. */
+export interface ToolWorkflowRunStartData {
+    readonly runId: WorkflowRunId;
+    readonly name: string;
+}
+/** Records one workflow member after its child Session is published. */
+export interface ToolWorkflowAgentStartData {
+    readonly runId: WorkflowRunId;
+    readonly seq: number;
+    readonly label: string;
+    readonly phase?: string;
+    readonly childId: SessionId;
+}
+/** Settles one previously started workflow member. */
+export interface ToolWorkflowAgentEndData {
+    readonly runId: WorkflowRunId;
+    readonly seq: number;
+    readonly outcome: WorkflowAgentOutcome;
+}
+/** Settles one workflow run after its live resources reach quiescence. */
+export interface ToolWorkflowRunEndData {
+    readonly runId: WorkflowRunId;
+    readonly stopReason: WorkflowStopReason;
+}
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * Opens one top-level workflow record.
+         * @param data - stable run identity and display name.
+         */
+        'tool-workflow/run-start': ToolWorkflowRunStartData;
+        /**
+         * Records one published workflow member.
+         * @param data - run identity, member sequence, display identity, and child Session.
+         */
+        'tool-workflow/agent-start': ToolWorkflowAgentStartData;
+        /**
+         * Records one member settlement.
+         * @param data - run identity, paired member sequence, and outcome.
+         */
+        'tool-workflow/agent-end': ToolWorkflowAgentEndData;
+        /**
+         * Closes one workflow record after cleanup.
+         * @param data - stable run identity and terminal reason.
+         */
+        'tool-workflow/run-end': ToolWorkflowRunEndData;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,8 @@
+/**
+ * Browser-safe durable workflow-record events written by the model-facing
+ * workflow tool into its calling parent Session.
+ *
+ * @module @deepseek-ai/dsh-tool-workflow/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-tool-workflow",
-  "description": "Model-facing workflow tool: run a JavaScript orchestration script over ctx.workflows",
-  "version": "0.0.1-rc.1",
+  "description": "Model-facing workflow tool: run a JavaScript orchestration script over ctx.workflowEngine",
+  "version": "0.0.1-rc.3",
   "publishConfig": {
     "access": "restricted"
   },
@@ -22,37 +22,43 @@
       "types": "./lib/types/invariant.d.ts",
       "default": "./lib/invariant.js"
     },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
     "./src/*": "./src/*",
     "./package.json": "./package.json"
   },
   "files": [
     "lib/index.js",
     "lib/invariant.js",
+    "lib/types/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-workflow": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.3",
     "@deepseek-ai/cordis": "^4.0.1-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1"
+    "@deepseek-ai/dsh-workflow": "^0.0.1-rc.3"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1-rc.1"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-subagent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-workflow": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-workflow-workerthread": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-subagent": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-workflow": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-workflow-worker-thread": "^0.0.1-rc.3",
     "@deepseek-ai/cordis": "^4.0.1-rc.1"
   }
 }