@xneog/dsh-tool-workflow 0.1.0-20260818184352-4561870be6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+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.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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: 918fe5b9aff74b3b959107ec1eebfd7966afe6d1
+README.zh.md: f7e62560a1b581cf64d78dc379b821d17f29b3aa

package/README.md

@@ -0,0 +1,85 @@
+# @xneog/dsh-tool-workflow
+
+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.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
+
+Three parameters: `meta` (required identity data: `name`, `description`, and optional progress annotations), `script` (required plain JavaScript body — no `export const meta` statement; the tool description carries the complete authoring contract), and `args` (optional JSON object exposed to the script as the `args` global; wrap a bare list in a field so the wire schema stays honest). The plugin also contributes a `tool:<toolName>` system-prompt section carrying the usage policy — use the tool only on an explicit user ask for a workflow / large orchestration; prefer plain subagent calls for one or two delegations — per the convention that tool guidance ships with the tool plugin, never in the deployment persona.
+
+## Lifecycle
+
+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 `@xneog/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.
+
+## Config
+
+| Key | Default | Meaning |
+|---|---|---|
+| `toolName` | `workflow` | The model-facing tool name to register. |
+| `maxResultChars` | `50000` | Rendered-result ceiling; longer JSON is truncated with a notice. |
+
+## Model Experience
+
+### System prompt
+
+#### What the model sees
+
+Every parent request in this plugin's registration scope receives the workflow guidance below. A scoped tool restriction can hide the schema without removing this independently registered guidance.
+
+##### Workflow guidance
+
+```markdown
+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.
+```
+
+#### Token effect
+
+Small fixed guidance cost per request while the plugin is active.
+
+#### KV Cache effect
+
+Prefix-stable while the plugin scope and guidance text are unchanged. Activation or disposal may invalidate reuse from this prompt section.
+
+### Tool schema
+
+#### What the model sees
+
+When visible, the generated default [`workflow` schema](../../../docs/tool-catalog.md#deepseek-aidsh-tool-workflow) carries the complete JavaScript hook and metadata contract; `toolName` can rename the definition, and the model submits script, metadata, and optional args.
+
+#### Token effect
+
+Substantial fixed schema cost on each request where the tool is visible.
+
+#### KV Cache effect
+
+Prefix-stable while `toolName`, definition, and visibility are unchanged. Renaming, plugin lifecycle, or scoped restrictions may invalidate reuse from this schema.
+
+### Tool-call history and result
+
+#### What the model sees
+
+The full model-written script, metadata, and args remain in the assistant tool call. Success is exactly `workflow "<name>" completed (<count> agent<optional-s>).`, newline, `Return value:`, newline, and pretty-printed data-dependent JSON; a cap adds `… [truncated: <omitted> more characters]` on a new line. Failures are exactly `Error: workflow run was cancelled`, optionally suffixed ` (<error>)`, `Error: workflow run failed: <error-or-unknown error>`, or defensively `Error: workflow run ended abnormally (<reason>)`; a call without an owning agent becomes `Error: workflow tool requires a calling agent (exec.agent was undefined)`. Intermediate child messages are omitted.
+
+#### Token effect
+
+Call tokens can be large and remain until compaction. Result rendering is capped by `maxResultChars`; child-model tokens are separate from the parent's retained context.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+## Known Limitations and Deferred Work
+
+- **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

@@ -0,0 +1,85 @@
+# @xneog/dsh-tool-workflow
+
+[English](README.md) | 中文
+
+面向模型的 **`workflow` 工具**：运行一段扇出 subagent 的 JavaScript 编排脚本，并返回脚本的最终值。本包负责基于 [`ctx.workflowEngine`](../workflow/README.md) 定义面向模型的 schema 和运行生命周期；脚本解析、执行、上限与取消位于 seam 之后，消费方仍负责面向父级的 schema 和结果包络。
+
+## 模型看到的内容
+
+工具有三个参数：`meta`（必需的身份数据：`name`、`description` 和可选的进度注解）、`script`（必需的纯 JavaScript 脚本体，不含 `export const meta` 语句；工具描述包含完整的编写约定）以及 `args`（可选 JSON 对象，作为全局变量 `args` 向脚本公开；裸列表应包装到字段中，使协议 schema 如实表达形态）。插件还会贡献一个 `tool:<toolName>` 系统提示词段，其中包含使用策略：只有用户明确要求工作流／大型编排时才使用该工具；一两项委派优先使用普通 subagent 调用。这遵循工具指导随工具插件交付、绝不放入部署 persona 的约定。
+
+## 生命周期
+
+收集是同步的（类似 [`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 首次失败后，本运行会停止后续记录并只告警一次，留下空记录或合法连续前缀，同时不改变工具结果和清理。
+
+浏览器安全的 `@xneog/dsh-tool-workflow/types` 子路径拥有这四类 log-only 事件 payload 及其 `SessionEventMap` 声明。包 invariant 会在冷加载和实时追加时拒绝重复 start、未配对成员、仍有开放成员的终点和 run-end 后更新，同时允许缺失终态后缀的连续前缀。
+
+## 渲染意图
+
+渲染意图预先确定（见[渲染意图 Agent Note](../../../.agents/notes/implemented/architecture/2026-07-02-tool-render-intent-union.md)）：使用一个 `generic` 卡片，标题为 `workflow: <meta.name>`，直接从 `args.meta.name` 读取（呈现是参数的纯函数，不要求引擎解析）；脚本文本作为 `rawInput` 携带。结果继续使用 generic 卡片。
+
+## 配置
+
+| 键 | 默认值 | 含义 |
+|---|---|---|
+| `toolName` | `workflow` | 要注册的面向模型工具名称。 |
+| `maxResultChars` | `50000` | 渲染结果上限；更长的 JSON 会被截断并附上提示。 |
+
+## 模型体验
+
+### 系统提示词
+
+#### 模型看到的内容
+
+在该插件的注册作用域内，每个父级请求都会收到下方的工作流指导。作用域工具限制可以隐藏 schema，而不移除这段独立注册的指导。
+
+##### 工作流指导
+
+```markdown
+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.
+```
+
+#### Token 影响
+
+插件启用期间，每个请求都会产生少量固定的指导 token 开销。
+
+#### KV Cache 影响
+
+只要插件作用域和指导文本不变，前缀就保持稳定。启用或 dispose 可能会使从该提示词段起的缓存复用失效。
+
+### 工具 schema
+
+#### 模型看到的内容
+
+工具可见时，已生成的默认 [`workflow` schema](../../../docs/tool-catalog.md#deepseek-aidsh-tool-workflow) 包含完整的 JavaScript 钩子与元数据约定；`toolName` 可以重命名该定义，模型会提交脚本、元数据和可选 args。
+
+#### Token 影响
+
+工具可见时，每个请求都会产生较大的固定 schema token 开销。
+
+#### KV Cache 影响
+
+只要 `toolName`、定义和可见性不变，前缀就保持稳定。重命名、插件生命周期或作用域限制可能会使从该 schema 起的缓存复用失效。
+
+### 工具调用历史与结果
+
+#### 模型看到的内容
+
+由模型编写的完整脚本、元数据和 args 会保留在 assistant 工具调用中。成功结果精确为 `workflow "<name>" completed (<count> agent<optional-s>).`、换行、`Return value:`、换行，以及经过美化打印且依赖数据的 JSON；达到上限时，会在新行添加 `… [truncated: <omitted> more characters]`。失败结果精确为 `Error: workflow run was cancelled`（可以追加后缀 ` (<error>)`）、`Error: workflow run failed: <error-or-unknown error>` 或防御性的 `Error: workflow run ended abnormally (<reason>)`；没有所属 agent 的调用变为 `Error: workflow tool requires a calling agent (exec.agent was undefined)`。中间子 agent 消息会被省略。
+
+#### Token 影响
+
+调用 token 可能很多，并会保留到压缩（compaction）为止。结果渲染受 `maxResultChars` 限制；子模型 token 与父级保留的上下文相互独立。
+
+#### KV Cache 影响
+
+仅追加；新增可见内容位于可复用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+## 已知限制与暂缓事项
+
+- **父级轮次会阻塞到整个工作流结算**：没有后台启动／轮询接口，取消会丢弃局部输出并返回错误。
+- **`args` 必须是对象，Native 结果文本有界**：调用方把顶层数组／标量包装到字段中；规范工作流结果保持完整，超过 `maxResultChars` 的 JSON 会在面向模型的投影中截断，而不是存储在检索句柄背后。
+- **每次工具注册的工作流策略固定**：提供方选择、上限和工具名称属于部署配置，不是模型调用参数。
+- **持久记录只覆盖顶层且只供观察**：嵌套 Code Mode dispatch 不记录；记录故障会刻意退化为不完整前缀，而不改变执行。

package/lib/index.js

@@ -0,0 +1,276 @@
+import z from "@xneog/schemastery";
+import { defineTool } from "@xneog/dsh-tools";
+//#region lib/types/index.js
+/**
+* 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`
+* (`@xneog/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 @xneog/dsh-tool-workflow
+*/
+const name = "tool-workflow";
+const inject = [
+	"tools",
+	"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
+* 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) {
+	return { card: "generic" };
+}
+/** A non-`completed` stop reason means the script did not finish cleanly. */
+function stopReasonError(result) {
+	switch (result.stopReason) {
+		case "completed": return;
+		case "cancelled": return `workflow run was cancelled${result.error !== void 0 ? ` (${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)})`;
+	}
+}
+/** Render the run's outcome text: the meta name, agent count, and the JSON value (capped). */
+function renderResult(name, agentsStarted, value, maxChars) {
+	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}`;
+}
+function apply(ctx, config) {
+	const { toolName, maxResultChars } = config;
+	const recorder = createWorkflowRecorder(ctx);
+	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) throw new Error("workflow tool requires a calling agent (exec.agent was undefined)");
+			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 {
+				result = await run.result;
+				const error = stopReasonError(result);
+				if (error !== void 0) throw new Error(error);
+				return {
+					runId: run.id,
+					agentsStarted: result.agentsStarted,
+					result: result.value
+				};
+			} finally {
+				exec.signal.removeEventListener("abort", onAbort);
+				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),
+		presentResult: (args, result) => presentWorkflowResult(args, result)
+	}));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,129 @@
+//#region lib/types/invariant.js
+/** Package-owned durable workflow-record invariants. @module @xneog/dsh-tool-workflow/invariant */
+const PACKAGE_NAME = "@xneog/dsh-tool-workflow";
+/** Cordis companion plugin name. */
+const name = "tool-workflow-invariant";
+/** Services required to validate existing and newly appended Session logs. */
+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 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

@@ -0,0 +1,25 @@
+/**
+ * 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`
+ * (`@xneog/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 @xneog/dsh-tool-workflow
+ */
+import type { Context } from '@xneog/cordis';
+import z from '@xneog/schemastery';
+export declare const name = "tool-workflow";
+export declare const inject: string[];
+/** Config: the model-facing tool name plus result rendering caps. */
+export interface Config {
+    /** The model-facing tool name to register (default `workflow`). */
+    toolName?: string;
+    /** Rendered-result ceiling, in characters: a longer JSON value is truncated with a notice (default 50000). */
+    maxResultChars?: number;
+}
+export declare const Config: z<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

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`
+ * (`@xneog/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 @xneog/dsh-tool-workflow
+ */
+import z from '@xneog/schemastery';
+import { defineTool } from '@xneog/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

@@ -0,0 +1,9 @@
+/** Package-owned durable workflow-record invariants. @module @xneog/dsh-tool-workflow/invariant */
+import type { Context } from '@xneog/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "tool-workflow-invariant";
+/** Services required to validate existing and newly appended Session logs. */
+export declare const inject: string[];
+/** 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 @xneog/dsh-tool-workflow/invariant */
+const PACKAGE_NAME = '@xneog/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 @xneog/dsh-tool-workflow/types
+ */
+import type { SessionId } from '@xneog/dsh-session/types';
+import type { WorkflowAgentOutcome, WorkflowRunId, WorkflowStopReason } from '@xneog/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 '@xneog/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 @xneog/dsh-tool-workflow/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@xneog/dsh-tool-workflow",
+  "description": "Model-facing workflow tool: run a JavaScript orchestration script over ctx.workflowEngine",
+  "version": "0.1.0-20260818184352-4561870be6",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gomes007-alt/xneog-harness.git",
+    "directory": "packages/workflow/tool-workflow"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "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": "MIT",
+  "peerDependencies": {
+    "@xneog/dsh-agent": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-invariants": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-llm": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-session": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-system-prompt": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-tools": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-workflow": "0.1.0-20260818184352-4561870be6",
+    "@xneog/cordis": "0.1.0-20260818184352-4561870be6"
+  },
+  "dependencies": {
+    "@xneog/schemastery": "0.1.0-20260818184352-4561870be6"
+  },
+  "devDependencies": {
+    "@xneog/dsh-agent": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-invariants": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-llm": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-session": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-subagent": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-system-prompt": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-tools": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-workflow": "0.1.0-20260818184352-4561870be6",
+    "@xneog/dsh-workflow-worker-thread": "0.1.0-20260818184352-4561870be6",
+    "@xneog/cordis": "0.1.0-20260818184352-4561870be6"
+  }
+}