workflow: drop the determinism bans (unimplemented-resume pre-support)

The Date.now()/Math.random()/argless-new-Date() bans existed solely to
keep scripts resume-compatible for the deferred journaling/resume
feature. Pre-support for an unimplemented feature is speculative cost:
scripts may now read the clock freely; implementing resume reintroduces
the bans as a script-contract tightening. The RFC's shipped-state
description is updated in place, the tool DESCRIPTION drops the
constraint sentence (the pinned text-turn header follows), and the
engine README's trust-premise paragraph now leans on absent globals
alone.

packages/workflow/workflow-vm/README.md

@@ -4,13 +4,13 @@ The first [`WorkflowService`](../workflow/README.md) implementation: an in-proce
 
 ## Trust premise
 
-Workflow scripts are **model-written** — the same trust level as the model's existing bash access — so this engine defends against **buggy** scripts, never hostile ones. vm is NOT a security boundary and no attempt is made to contain adversarial values: property reads on script values may run script code (a getter, a `toString`, a proxy trap) on the host stack, and a script determined to hang the process can simply spin past its first await (see the limitations below). Concretely, the context is **escapable by construction**: `node:vm` shares object machinery with the host, so a script can reach the host `Function` constructor (`globalThis.constructor.constructor`) and from it `process` and every Node builtin — the absent globals and determinism bans are API surface that keeps honest scripts portable and resume-compatible, not walls. What the engine DOES guarantee, because benign scripts hit these constantly: `result` never rejects, a dropped hook promise never becomes an unhandled rejection (the app boot layer exits the process on those), values that JSON cannot carry are rejected **loud** instead of silently mangled, and hook misuse is fatal instead of dissolving into a per-item `null`. Genuine sandboxing is an engine swap behind the seam (worker-thread/isolated-vm, where the boundary is serialization by construction), not incremental host-side defenses here.
+Workflow scripts are **model-written** — the same trust level as the model's existing bash access — so this engine defends against **buggy** scripts, never hostile ones. vm is NOT a security boundary and no attempt is made to contain adversarial values: property reads on script values may run script code (a getter, a `toString`, a proxy trap) on the host stack, and a script determined to hang the process can simply spin past its first await (see the limitations below). Concretely, the context is **escapable by construction**: `node:vm` shares object machinery with the host, so a script can reach the host `Function` constructor (`globalThis.constructor.constructor`) and from it `process` and every Node builtin — the absent globals are API surface that keeps honest scripts portable, not walls. What the engine DOES guarantee, because benign scripts hit these constantly: `result` never rejects, a dropped hook promise never becomes an unhandled rejection (the app boot layer exits the process on those), values that JSON cannot carry are rejected **loud** instead of silently mangled, and hook misuse is fatal instead of dissolving into a per-item `null`. Genuine sandboxing is an engine swap behind the seam (worker-thread/isolated-vm, where the boundary is serialization by construction), not incremental host-side defenses here.
 
 ## The script contract it executes
 
 - **Meta extraction** (`extractMeta`): a string/comment-aware brace scanner finds the leading `export const meta` literal (template interpolation rejected — the literal must be pure), evaluates it ALONE in an empty timed vm context, materializes the result to plain JSON data, validates the shape (`name`/`description` required; unknown fields rejected loud), and blanks the statement line-preservingly so error stacks keep the script's own line numbers.
 - **Hooks**: `agent(prompt, {label, phase, schema, model})` (schema = the [structured-output subset](../../core/tools/README.md), forwarded as `outputSchema`; result = validated object, or final text without a schema; a failed child resolves `null`), `parallel(thunks)`, `pipeline(items, ...stages)` with NO cross-stage barrier and `(prev, item, index)` stage callbacks, `phase(title)`, `log(message)`, and the `args` global. Anything else — `effort`/`isolation`/`agentType`, unknown options, malformed arguments, schemas outside the subset — throws a FATAL `WorkflowError` that `parallel`/`pipeline` re-throw rather than nulling (see the seam README's failure discipline).
-- **Determinism bans**: `Date.now()`, `Math.random()`, and argless `new Date()` throw (kept even though resume is deferred, so scripts stay resume-compatible); no timers, filesystem, or Node APIs are injected into the context (absence is API surface, not containment — see the trust premise).
+- **No ambient APIs**: no timers, filesystem, or Node APIs are injected into the context (absence is API surface, not containment — see the trust premise).
 
 ## The value boundary
 

packages/workflow/workflow-vm/src/runtime.ts

@@ -75,25 +75,6 @@ const SUPPORTED_AGENT_OPTIONS = new Set(['label', 'phase', 'schema', 'model'])
 /** Deferred Claude Code options we name explicitly in the rejection message. */
 const DEFERRED_AGENT_OPTIONS = new Set(['effort', 'isolation', 'agentType'])
 
-/** The in-context prelude that bans the nondeterminism sources (kept even though resume is deferred, so scripts stay resume-compatible). */
-const DETERMINISM_PRELUDE = `
-{
-  const banned = (name) => () => {
-    throw new Error(name + ' is not available in workflow scripts (runs must stay deterministic for future resume support; pass timestamps in via args)')
-  }
-  Math.random = banned('Math.random()')
-  Date.now = banned('Date.now()')
-  const RealDate = Date
-  globalThis.Date = new Proxy(RealDate, {
-    construct(target, args, newTarget) {
-      if (args.length === 0) banned('argless new Date()')()
-      return Reflect.construct(target, args, newTarget)
-    },
-    apply: banned('Date()'),
-  })
-}
-`
-
 /** Flatten a child's final output blocks to text (the non-schema `agent()` result). */
 function outputText(blocks: ContentBlock[]): string {
   return blocks
@@ -167,7 +148,6 @@ export class WorkflowExecution {
     }
 
     this.context = vm.createContext({}, { name: `workflow:${meta.name}` })
-    vm.runInContext(DETERMINISM_PRELUDE, this.context)
     // A run that settles without ever being abandoned leaves `abandoned`
     // permanently pending or rejecting into the void — consume it so a late
     // grace timer cannot surface an unhandled rejection.

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

@@ -413,16 +413,7 @@ describe('dsh-workflow-vm', () => {
     })
   })
 
-  describe('determinism bans and the value boundary', () => {
-    it('Date.now, Math.random, and argless new Date throw; parameterized Date stays usable', async () => {
-      const { ctx, parent } = await setup()
-      expect((await run(ctx, parent, script('return Date.now()'))).error).toContain('Date.now() is not available')
-      expect((await run(ctx, parent, script('return Math.random()'))).error).toContain('Math.random() is not available')
-      expect((await run(ctx, parent, script('return new Date().toISOString()'))).error).toContain('argless new Date()')
-      const ok = await run(ctx, parent, script('return new Date(0).getTime()'))
-      expect(ok.value).toBe(0)
-    })
-
+  describe('the value boundary', () => {
     it('args are cloned at start: a script scribbling on them cannot mutate the caller\'s object', async () => {
       const { ctx, parent } = await setup()
       const hostArgs = { files: ['a.ts'], nested: { deep: [1, 2] } }