workflow: swap the engine's internals to node:worker_threads

In-place port of dsh-workflow-vm from the in-process node:vm execution
to one worker thread per run (the workflow-workerthread engine of
PR #215, adopted as THE engine): the script's vm context moves inside
the worker, agent() bridges to ctx.subagents over the message port
(host.ts/protocol.ts/session.ts/worker.ts are new; runtime.ts loses the
abandon channel — the host's grace timer force-settles and TERMINATES
instead), start() pre-parses the body host-side to keep the seam's
synchronous SCRIPT_PARSE throw, and a ready→go handshake keeps a run
cancelled before start from ever executing the body. start() no longer
blocks the host, termination is real, and the value boundary is
serialization by construction. The package keeps its name until the
follow-up rename commit; scripts see the identical hook surface, and
the seam-contract tests hardened ahead of this swap pass unchanged.

The run and child-RPC surfaces are class-shaped rather than literal
bundles: WorkerRun IMPLEMENTS the seam's WorkflowRun (id/meta are its
own clone, separate from event payloads') and start() returns the
instance directly — interface parity with the seam is compiler-checked;
worker-side, ChildRpcBridge (implements ChildPort; callId allocation +
pending book-keeping settled by onChild* entry points) and
RpcChildHandle (every member an RPC keyed by its callId) carry names in
stacks. ChildPort's method is startAgent — it names what it starts,
matching the script-side agent() hook and the agentsStarted /
workflow/agent-* vocabulary; the Child* type names deliberately stay
(the worker side is cordis- and subagent-free; these are reduced JSON
projections, not the seam's types).

Review findings from the reference PR are folded in rather than
re-introduced:
- cancel() drives BOTH child-cancel channels host-side: the request
  signal aborts AND each registered child's explicit cancel() is
  called — a worker wedged in a synchronous spin cannot relay its own
  ChildCancel RPCs (regression: cancel-only provider + wedged worker).
- All host warn paths render through the total renderThrown; a child
  dispose() rejecting a value whose coercion throws still acks
  ChildDisposed instead of wedging the script's finally (regression).
- built-worker.e2e.ts is wired into builtBinSmokeGate and the AGENTS.md
  CI sequence — the built lib/worker.js resolution contract now runs in
  an automated gate.
- workflow/end payload pinned on the worker-death path (with the
  cancelled and grace-force-settle pins riding the ported spec).
- Real-Worker scripted timing budgets widened (50-300ms → 150-1000ms)
  for starved CI hosts.

Workspace plumbing: the "./worker" subpath export sanctions the second
runtime bundle (check-workspace-constraints), tsdown builds two
single-entry passes, tsx becomes a devDependency for the unbuilt worker
spawn.

packages/workflow/workflow-vm/tests/workflow.e2e.ts

@@ -9,16 +9,14 @@ import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import * as LlmDeepSeek from '@deepseek-ai/dsh-llm-deepseek'
 import SubagentService from '@deepseek-ai/dsh-subagent'
 import * as Spawn from '@deepseek-ai/dsh-subagent-spawn'
-import * as ToolWorkflow from '@deepseek-ai/dsh-tool-workflow'
-import { CallId } from '@deepseek-ai/dsh-llm'
-import VmWorkflowEngine from '../src/index.ts'
+import WorkerWorkflowEngine from '../src/index.ts'
 
 /**
- * With-key e2e for the workflow engine: a REAL script drives REAL spawn
- * children against the live DeepSeek API — one plain child and one schema'd
- * child through the real structured-output runtime — and the run's value,
- * events, and child sessions are asserted from the outside (never the
- * script's self-report alone). Key-gated (self-skips without
+ * With-key e2e: a REAL script in a REAL worker thread
+ * drives REAL spawn children against the live DeepSeek API — one plain child
+ * and one schema'd child through the real structured-output runtime — and
+ * the run's value, events, and child sessions are asserted from the outside
+ * (never the script's self-report alone). Key-gated (self-skips without
  * DEEPSEEK_API_KEY).
  */
 
@@ -40,14 +38,13 @@ async function harness(): Promise<Context> {
   await built.plugin(LlmDeepSeek, { models: ['deepseek-v4-flash'] })
   await built.plugin(SubagentService)
   await built.plugin(Spawn, { providerName: 'spawn' })
-  await built.plugin(VmWorkflowEngine, { provider: 'spawn' })
-  await built.plugin(ToolWorkflow, {})
+  await built.plugin(WorkerWorkflowEngine, { provider: 'spawn' })
   return built
 }
 
 const SCRIPT = `export const meta = {
-  name: 'e2e-arithmetic',
-  description: 'two real children: one prose, one structured',
+  name: 'e2e-worker-arithmetic',
+  description: 'two real children through a worker thread: one prose, one structured',
   phases: [{ title: 'Ask' }, { title: 'Judge' }],
 }
 phase('Ask')
@@ -61,12 +58,12 @@ const judged = await agent(
 )
 return { prose, containsFour: judged === null ? null : judged.containsFour }`
 
-describe.skipIf(!process.env.DEEPSEEK_API_KEY)('workflow engine with-key e2e', () => {
-  it('runs a two-phase script over real children, one through the structured runtime', async () => {
+describe.skipIf(!process.env.DEEPSEEK_API_KEY)('worker workflow engine with-key e2e', () => {
+  it('runs a two-phase script in a worker thread over real children, one through the structured runtime', async () => {
     ctx = await harness()
     const parentHandle = ctx.agents.create({
-      agentId: AgentId('wf-e2e-parent'),
-      sessionId: 'wf-e2e-session' as never,
+      agentId: AgentId('wf-worker-e2e-parent'),
+      sessionId: 'wf-worker-e2e-session' as never,
       agentOptions: { model: 'deepseek-v4-flash' },
     })
 
@@ -102,30 +99,4 @@ describe.skipIf(!process.env.DEEPSEEK_API_KEY)('workflow engine with-key e2e', (
     }
     await parentHandle.dispose()
   }, 240_000)
-
-  it('the workflow TOOL runs the same path through the real registry pipeline', async () => {
-    ctx = await harness()
-    const parentHandle = ctx.agents.create({
-      agentId: AgentId('wf-e2e-tool-parent'),
-      sessionId: 'wf-e2e-tool-session' as never,
-      agentOptions: { model: 'deepseek-v4-flash' },
-    })
-
-    const result = await ctx.tools.execute({
-      callId: CallId('wf-e2e-call'),
-      name: 'workflow',
-      arguments: {
-        script: `export const meta = { name: 'e2e-tool', description: 'one real child via the tool' }
-const answer = await agent('Reply with exactly one word: the capital of France.')
-return { answer }`,
-      },
-      agent: parentHandle.agent,
-    })
-
-    expect(result.isError).toBe(false)
-    const text = (result.content[0] as { text: string }).text
-    expect(text).toContain('workflow "e2e-tool" completed (1 agent)')
-    expect(text.toLowerCase()).toContain('paris')
-    await parentHandle.dispose()
-  }, 240_000)
 })