@xemahq/dsl 0.5.5 → 0.5.7

package/src/workflow/lib/compiler/gate-defaults.ts

@@ -0,0 +1,153 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// ── Workflow-level decision-gate defaults (`defaults.gate`) ──
+//
+// Gate-heavy workflows (e.g. the software-dev product-development pipeline)
+// repeat the same decision-gate configuration on every gate job:
+// timeoutSeconds, onTimeout, autonomyMode, recipients, policy. `defaults.gate`
+// lets the author declare that configuration ONCE at the workflow level; the
+// compiler folds it into each gate job's `with:` before any other compile
+// pass runs, so downstream validation, expression compilation, and the
+// CompiledRun snapshot all observe the merged document — expressions inside
+// defaults compile per-job exactly as if written inline.
+//
+// Merge contract (deterministic, no silent deep-merging):
+//   • Applies ONLY to jobs whose `uses:` resolves to the `xema/decision-gate`
+//     action id — matched on the resolved ref's id, regardless of version.
+//   • Fills ABSENT `with:` keys only. Explicit per-gate values always win.
+//   • Fill is per top-level key: a gate that declares its own `policy` or
+//     `recipients` keeps that value verbatim — there is no partial merge
+//     inside a key's object/array value.
+//   • Fail-fast validation: every `defaults.gate` key must be declared in
+//     the resolved gate manifest's `inputs.properties` (guards drift between
+//     the DSL schema's closed key set and the pinned gate action version).
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { WorkflowErrorCode } from '@xemahq/kernel-contracts/workflow';
+import { WorkflowDslError } from '../errors';
+import { compileExpression, extractInterpolations } from '../expression';
+import type { WorkflowDocument, WorkflowGateDefaults } from '../types';
+import type { ResolvedRef } from './types';
+
+/**
+ * Canonical action id of the decision-gate primitive. `defaults.gate`
+ * targets jobs by this id — never by the raw `uses:` string — so any
+ * pinned version (`xema/decision-gate@1.2.0`, `@2.x`, …) participates.
+ */
+export const DECISION_GATE_ACTION_ID = 'xema/decision-gate';
+
+/**
+ * Fold `defaults.gate` into every decision-gate job's `with:` block and
+ * return the (possibly rewritten) document. Pure: never mutates the input.
+ *
+ * Runs BEFORE all other compile passes so the merged `with:` flows through
+ * expression validation, needs-shape validation, review rewriting, the
+ * action input-schema pin, and the snapshot hash exactly like authored
+ * values.
+ *
+ * Jobs whose `uses:` is missing from `resolvedRefs` are skipped here — the
+ * per-job compile loop already fails them with `DSL_UNKNOWN_ACTION`, and
+ * pre-empting that error would reorder author-facing diagnostics.
+ */
+export function applyGateDefaults(
+  workflow: WorkflowDocument,
+  resolvedRefs: Readonly<Record<string, ResolvedRef>>,
+): WorkflowDocument {
+  const gate = workflow.defaults?.gate;
+  if (gate === undefined) return workflow;
+  const gateEntries = Object.entries(gate).filter(
+    ([, value]) => value !== undefined,
+  );
+  if (gateEntries.length === 0) return workflow;
+
+  // Validate every `${{ … }}` expression inside the defaults block up
+  // front — even when no gate job consumes it. A malformed expression in
+  // `defaults.gate` is an authoring error regardless of merge fan-out;
+  // deferring it until a gate job appears would be a silent latency.
+  for (const ext of extractInterpolations(
+    gate as Readonly<Record<string, unknown>>,
+    ['defaults', 'gate'],
+  )) {
+    compileExpression(ext.source);
+  }
+
+  let anyChanged = false;
+  const rewrittenJobs: Record<string, WorkflowDocument['jobs'][string]> = {};
+  for (const [jobKey, job] of Object.entries(workflow.jobs)) {
+    const resolved = resolvedRefs[job.uses];
+    if (
+      resolved === undefined ||
+      resolved.isReusableWorkflow ||
+      resolved.id !== DECISION_GATE_ACTION_ID
+    ) {
+      rewrittenJobs[jobKey] = job;
+      continue;
+    }
+
+    assertGateDefaultKeysDeclared(jobKey, gate, resolved);
+
+    const authored = job.with ?? {};
+    let jobChanged = false;
+    const merged: Record<string, unknown> = { ...authored };
+    for (const [key, value] of gateEntries) {
+      if (Object.hasOwn(authored, key)) continue;
+      merged[key] = value;
+      jobChanged = true;
+    }
+    if (!jobChanged) {
+      rewrittenJobs[jobKey] = job;
+      continue;
+    }
+    anyChanged = true;
+    rewrittenJobs[jobKey] = { ...job, with: merged };
+  }
+
+  if (!anyChanged) return workflow;
+  return { ...workflow, jobs: rewrittenJobs };
+}
+
+/**
+ * Fail-fast subset check: every `defaults.gate` key must be a declared
+ * input of the resolved gate action version. The JSON schema already
+ * closes the key set to the canonical decision-gate input names; this
+ * check guards manifest drift (e.g. a future gate version renaming or
+ * dropping an input while a workflow still defaults it).
+ *
+ * Skipped only when the manifest declares no introspectable
+ * `inputs.properties` map — nothing to prove against; the worker's
+ * pinned input-schema validation still rejects unknown keys at dispatch.
+ */
+function assertGateDefaultKeysDeclared(
+  jobKey: string,
+  gate: WorkflowGateDefaults,
+  resolved: ResolvedRef,
+): void {
+  const inputs = resolved.actionManifest?.spec.inputs;
+  const properties =
+    inputs && typeof inputs === 'object'
+      ? (inputs as { properties?: unknown }).properties
+      : undefined;
+  if (
+    properties === null ||
+    properties === undefined ||
+    typeof properties !== 'object' ||
+    Array.isArray(properties)
+  ) {
+    return;
+  }
+  const declared = properties as Readonly<Record<string, unknown>>;
+  for (const [key, value] of Object.entries(gate)) {
+    if (value === undefined) continue;
+    if (Object.hasOwn(declared, key)) continue;
+    throw new WorkflowDslError(
+      WorkflowErrorCode.DSL_SEMANTIC_INVALID,
+      `defaults.gate.${key} is not a declared input of ${resolved.id}@${resolved.version} (consumed by job '${jobKey}'). Declared inputs: [${Object.keys(declared).sort((a, b) => a.localeCompare(b)).join(', ')}].`,
+      {
+        jobKey,
+        key,
+        actionId: resolved.id,
+        actionVersion: resolved.version,
+        declaredInputs: Object.keys(declared),
+      },
+    );
+  }
+}

package/src/workflow/lib/compiler/index.ts

@@ -1,4 +1,5 @@
 export { compileWorkflow } from './compile';
+export { DECISION_GATE_ACTION_ID, applyGateDefaults } from './gate-defaults';
 export { canonicalJsonSha256, canonicalJsonStringify } from './canonical-json';
 export { compileManifestSource } from './manifest-source';
 export { getWorkspaceManifestContract, isAgentShapedAction } from './action-shape';

package/src/workflow/lib/compiler/payload-reach-in.ts

@@ -1,5 +1,5 @@
 // ═══════════════════════════════════════════════════════════════════════════
-// ── Payload reach-in validation (plan §C.1) ──
+// ── Payload reach-in validation ──
 //
 // Workflow YAML supports two flavours of `needs.<X>.outputs.<name>.<field>`:
 //
@@ -74,7 +74,7 @@ function lookupOutputBindingSpecRef(
  * Decision table for each `<name>.<field>`:
  *   • `<field>` is an ArtifactRef envelope field → OK (no payload fetch).
  *   • Upstream activity manifest declares `outputBindings.<name>.deliverableSpecRef`
- *     (plan §B per-output binding) → use that spec; otherwise fall back
+ *     (per-output binding) → use that spec; otherwise fall back
  *     to the upstream job's `with.deliverableSpecRef`. Then:
  *       - resolved spec has `topLevelKeys` and `<field>` is one → OK.
  *       - resolved spec has `topLevelKeys` and `<field>` is NOT one →
@@ -136,7 +136,7 @@ export function validatePayloadReachIns(
 /**
  * Walk every reach-in for a single job and emit one pin per
  * `(upstreamJobKey, specRef)` pair. Pins drive the runtime spec-version
- * assertion (plan §C.1 risks-and-mitigations) — the worker pre-fetches
+ * assertion — the worker pre-fetches
  * the artifact and refuses to proceed when its `schemaVersion` doesn't
  * match the pin's `specVersion`.
  *
@@ -203,8 +203,8 @@ function resolveReachInPin(
     return null;
   }
 
-  // Prefer per-output binding from the upstream activity manifest
-  // (plan §B). Falls back to the job-level `with.deliverableSpecRef`
+  // Prefer per-output binding from the upstream activity manifest.
+  // Falls back to the job-level `with.deliverableSpecRef`
   // when no per-output binding is declared OR when the reach-in's
   // outputName is one of the indexed sentinels.
   let specRef: string | null = null;
@@ -431,7 +431,7 @@ function validateReachIn(
     return;
   }
 
-  // Per-output binding from the upstream activity manifest (plan §B)
+  // Per-output binding from the upstream activity manifest
   // wins over the job-level `with.deliverableSpecRef` when present.
   const perOutputBinding =
     access.outputName === '<indexed>' || access.outputName === '<byKey>'

package/src/workflow/lib/compiler/review-step.ts

@@ -75,15 +75,15 @@ interface ReviewWithShape {
 /**
  * Per-job redraft-strategy descriptor carried on the IR `redraft` block
  * when the producer step has a matrix strategy. Mirrors the worker
- * consumer in `biomes/workflow-runtime/api/workflow-runtime-worker/src/workflows/review.workflow.ts`
- * — kept JSON-serializable so the IR survives Temporal payload encoding.
+ * consumer that runs the review workflow — kept JSON-serializable so the
+ * IR survives Temporal payload encoding.
  *
  * `static` entries are already cartesian-expanded at compile time;
  * `dynamic.fromExpression` is the producer's expression body (already
  * `${{ … }}`-stripped) which the parent dispatcher evaluates against
  * the review step's expression context before spawning the child
  * workflow. `keyBy` is informational only — per-CU keyed targeting is
- * a Phase-2 feature; Phase 1 always re-runs every matrix entry.
+ * a planned future feature; today every matrix entry is always re-run.
  */
 export type ReviewRedraftStrategyIR =
   | {

package/src/workflow/lib/duration.ts

@@ -7,7 +7,8 @@ import { WorkflowDslError } from './errors';
  * no silent zero fallback — callers must pass a value that matches the
  * schema pattern (already enforced by Ajv upstream).
  *
- * Cap: hours limited to 8760 (= 365 days). The cap is a sanity guard
+ * Cap: total duration limited to 8760h (= 365 days), regardless of the
+ * unit used. The cap is a sanity guard
  * against typos (`100000h` ≈ 11 years), not a policy bound — real
  * human-driven flows (compliance reviews, multi-stakeholder approvals,
  * SCM PRs that go a quarter without merging) routinely take months.
@@ -30,19 +31,13 @@ export function parseDurationMs(literal: string): number {
   }
   const value = Number.parseInt(match[1]!, 10);
   const unit = match[2] as 's' | 'm' | 'h';
-  if (unit === 'h' && value > MAX_HOURS) {
+  const ms = unit === 's' ? value * 1_000 : unit === 'm' ? value * 60_000 : value * 3_600_000;
+  if (ms > MAX_HOURS * 3_600_000) {
     throw new WorkflowDslError(
       WorkflowErrorCode.DSL_SCHEMA_INVALID,
       `Duration exceeds cap of ${MAX_HOURS}h: ${literal}`,
       { literal, maxHours: MAX_HOURS },
     );
   }
-  switch (unit) {
-    case 's':
-      return value * 1_000;
-    case 'm':
-      return value * 60_000;
-    case 'h':
-      return value * 3_600_000;
-  }
+  return ms;
 }

package/src/workflow/lib/expression/context.ts

@@ -3,8 +3,8 @@ import type { TriggerPayload } from '@xemahq/kernel-contracts/workflow';
 /**
  * Per-run, read-only cache of pre-fetched artifact payloads keyed by
  * `versionId`. Populated by the workflow runtime BEFORE each step's
- * expressions are evaluated — see `biomes/workflow-runtime/api/workflow-runtime-worker` for the
- * fetch + cache plumbing. The evaluator only ever reads from this map;
+ * expressions are evaluated, which owns the fetch + cache plumbing.
+ * The evaluator only ever reads from this map;
  * concurrent reads are safe by construction (no writes once frozen for a
  * step). Empty when no expression in scope reaches into a typed
  * payload or invokes `fromJSON(ref)`.

package/src/workflow/lib/expression/evaluator.ts

@@ -172,8 +172,8 @@ function evalCall(node: CallNode, ctx: ExpressionContext): unknown {
  *      evaluator runs. A cache miss is a runtime infra bug, not an
  *      author bug, so it carries a runtime-coded error.
  *
- * This is the §C.2 escape hatch. Authors who want compile-time field
- * validation use the typed reach-in (`outputs.foo.field`, §C.1).
+ * This is the untyped escape hatch. Authors who want compile-time field
+ * validation use the typed reach-in (`outputs.foo.field`).
  */
 function evalFromJson(node: CallNode, ctx: ExpressionContext): unknown {
   const argNode = singleArg(node, 'fromJSON');

package/src/workflow/lib/expression/walk-artifact-refs.ts

@@ -1,6 +1,6 @@
 // ═══════════════════════════════════════════════════════════════════════════
 // ── Runtime walker — find every AST sub-expression that resolves to an
-//    ArtifactRef the runtime must pre-fetch (plan §C.1 / §C.2). ──
+//    ArtifactRef the runtime must pre-fetch. ──
 //
 // Two flavours of pre-fetch target:
 //
@@ -202,7 +202,7 @@ export function extractUpstreamJobKey(node: ExpressionNode): string | null {
  * known there.
  *
  * Pair with `extractUpstreamJobKey` to resolve per-output spec pins at
- * runtime (plan §B). Falling back to `null` is the cue the prefetch
+ * runtime. Falling back to `null` is the cue the prefetch
  * helper uses to consult the job-level pin instead.
  */
 export function extractUpstreamOutputName(

package/src/workflow/lib/serializer.ts

@@ -8,7 +8,7 @@ import type { WorkflowDocument } from './types';
  * Note on comment preservation: this serializer does NOT carry over
  * source comments from the original YAML — it dumps the AST verbatim.
  * Use it when the canonical representation lives in the AST (e.g. the
- * canvas editor in PR 5.x) and the YAML view is a derived presentation.
+ * canvas editor) and the YAML view is a derived presentation.
  * If you need to apply a single mutation to existing hand-authored YAML
  * while keeping comments + key ordering intact, use the `yaml`
  * package's CST/Document API directly (follow-up; not in this PR).

package/src/workflow/lib/types.ts

@@ -171,6 +171,32 @@ export interface WorkflowConcurrencyDeclaration {
 export interface WorkflowDefaults {
   readonly retry?: WorkflowRetryDeclaration;
   readonly timeout?: string;
+  readonly gate?: WorkflowGateDefaults;
+}
+
+/**
+ * Workflow-level defaults for decision-gate jobs (`defaults.gate`).
+ *
+ * For every job whose `uses:` resolves to the `xema/decision-gate` action
+ * (matched on the action id, regardless of version), the compiler fills
+ * each ABSENT `with:` key from this block before any other compile pass
+ * runs. Explicit per-gate values always win, and the fill happens per
+ * top-level key only — a gate that declares its own `policy` /
+ * `recipients` keeps that value verbatim (no partial merge inside it).
+ *
+ * Every value may be a `${{ … }}` expression; merged values compile and
+ * evaluate per-job exactly as if they had been written inline. The key
+ * set is closed by the JSON schema AND cross-validated at compile time
+ * against the resolved gate manifest's declared `inputs` (fail-fast on
+ * drift between the schema's key set and the pinned gate version).
+ */
+export interface WorkflowGateDefaults {
+  readonly timeoutSeconds?: unknown;
+  readonly onTimeout?: unknown;
+  readonly autonomyMode?: unknown;
+  readonly recipients?: unknown;
+  readonly policy?: unknown;
+  readonly escalationChain?: unknown;
 }
 
 export interface WorkflowRetryDeclaration {
@@ -263,7 +289,7 @@ export interface ActionManifestSpec {
   readonly inputs: Readonly<Record<string, unknown>>;
   readonly outputs: Readonly<Record<string, unknown>>;
   /**
-   * Per-output deliverable-spec bindings (plan §B per-output bindings).
+   * Per-output deliverable-spec bindings.
    * Each entry pins a named output to a deliverable-spec ref like
    * `agent-summary@1.0.0`. The DSL compiler consults this first when
    * resolving typed payload reach-in (`outputs.<name>.<field>`); it

package/src/workflow/lib/validate.ts

@@ -137,7 +137,7 @@ function parseAndValidate<T>(
       { kind },
     );
   }
-  // Plan §G shorthand: `needs: <string>` → `[<string>]`. Normalize
+  // Shorthand: `needs: <string>` → `[<string>]`. Normalize
   // BEFORE validation so the schema stays strict (one canonical shape)
   // and the rest of the compiler never branches on shorthand. Workflow +
   // reusable-workflow documents both have `jobs: { <key>: { needs?... } }`;
@@ -151,7 +151,7 @@ function parseAndValidate<T>(
 /**
  * Mutates `doc.jobs.<key>.needs` from `<string>` to `[<string>]` in
  * place. Authors can write either form; the canonical form is the
- * array. Documented in plan §G under "Simplified DSL".
+ * array. Documented under "Simplified DSL".
  */
 function normalizeJobNeedsShorthand(doc: object): void {
   const jobs = (doc as { jobs?: unknown }).jobs;

package/src/workspace-manifest/lib/compile.ts

@@ -580,8 +580,7 @@ function compileWorkingFiles(
     }
     // `binaryFormat` is the closed-enum hint that signals a companion
     // binary (XLSX/PPTX/DOCX/PDF) lives alongside the synopsis. Validate now so
-    // a typo cannot reach the worker as a silent no-op — see
-    // `.claude/plans/xlsx-pptx-binary-kb-attachment.md` D6.
+    // a typo cannot reach the worker as a silent no-op.
     const binaryFormatRaw = wf.sourceRef['binaryFormat'];
     if (
       typeof binaryFormatRaw === 'string' &&

package/src/workspace-manifest/lib/interpolate.ts

@@ -42,7 +42,7 @@ export function interpolate(
   basePath = '$',
 ): { readonly resolved: unknown; readonly issues: readonly InterpolationIssue[] } {
   const issues: InterpolationIssue[] = [];
-  const resolved = walk(value, ctx, basePath, issues);
+  const resolved = walk(value, ctx, basePath, issues, new Set());
   return { resolved, issues };
 }
 
@@ -51,16 +51,42 @@ function walk(
   ctx: InterpolationContext,
   path: string,
   issues: InterpolationIssue[],
+  seen: Set<object>,
 ): unknown {
   if (typeof value === 'string') return interpolateString(value, ctx, path, issues);
   if (Array.isArray(value)) {
-    return value.map((item, idx) => walk(item, ctx, `${path}[${idx}]`, issues));
+    // Reject cyclic structures (e.g. self-referential YAML anchors) with a
+    // clear error rather than recursing until the stack overflows.
+    if (seen.has(value)) {
+      throw new Error(`interpolate: circular reference at ${path}`);
+    }
+    seen.add(value);
+    const out = value.map((item, idx) => walk(item, ctx, `${path}[${idx}]`, issues, seen));
+    seen.delete(value);
+    return out;
   }
   if (value !== null && typeof value === 'object') {
+    if (seen.has(value)) {
+      throw new Error(`interpolate: circular reference at ${path}`);
+    }
+    seen.add(value);
     const out: Record<string, unknown> = {};
     for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
-      out[key] = walk(child, ctx, `${path}.${key}`, issues);
+      const resolvedChild = walk(child, ctx, `${path}.${key}`, issues, seen);
+      // Assign `__proto__` as an own data property instead of invoking the
+      // prototype setter, which would silently drop the key and reparent `out`.
+      if (key === '__proto__') {
+        Object.defineProperty(out, key, {
+          value: resolvedChild,
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        });
+      } else {
+        out[key] = resolvedChild;
+      }
     }
+    seen.delete(value);
     return out;
   }
   return value;

package/src/workspace-manifest/lib/resolve-extends.ts

@@ -1,9 +1,9 @@
 // ═══════════════════════════════════════════════════════════════════════════
 // ── WorkspaceManifest `extends:` resolver ──
 //
-// Section 4.4 of the engineering plan. Provides a deterministic merge
-// primitive plus a thin orchestrator the composer / preview endpoint /
-// llm-registry calls to materialize the effective manifest.
+// Provides a deterministic merge primitive plus a thin orchestrator the
+// composer / preview endpoint / llm-registry calls to materialize the
+// effective manifest.
 //
 // Design constraints:
 //   • Single-level extends only. The base MUST NOT carry its own

package/src/workspace-manifest/lib/schema.ts

@@ -31,7 +31,7 @@ const SlugRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 const VersionRegex = /^\d+\.\d+\.\d+$/;
 
 /**
- * Upper bound on authored node-level `instructions` (WS5 Phase B: author a
+ * Upper bound on authored node-level `instructions` (author a
  * migrated agent as `base agent slug + instructions`). A prompt fragment
  * layered onto the referenced agent definition's intrinsic system prompt —
  * the same lever as `AgentNode.instructions`. The cap is a sanity
@@ -330,6 +330,17 @@ export const ManifestSlotPersistenceOverrideSchema = z
       ),
     branchSuffix: GitPushBranchSuffixEnumSchema.optional(),
     concurrencyMode: GitPushConcurrencyModeEnumSchema.optional(),
+    mergeTarget: z
+      .string()
+      .min(1)
+      .regex(
+        /^[a-zA-Z0-9][a-zA-Z0-9._\-/]*$/,
+        'mergeTarget must be a git-safe branch name ([A-Za-z0-9._-/], no leading slash)',
+      )
+      .refine((v) => !v.includes('..'), {
+        message: 'mergeTarget must not contain `..` segments',
+      })
+      .optional(),
   })
   .strict();
 
@@ -641,7 +652,7 @@ export const WorkspaceManifestMetadataSchema = z.object({
    * Optional in the YAML for additive rollout; the compiler defaults
    * absent values to `[workflow, agent-session]` so existing
    * manifests keep compiling. New biome/org manifests SHOULD declare
-   * this explicitly — Phase 9 sweeps the shipped manifests.
+   * this explicitly — a later step sweeps the shipped manifests.
    */
   surfaceCompat: z
     .array(ManifestSurfaceEnumSchema)

package/src/workspace-manifest/lib/types.ts

@@ -210,6 +210,13 @@ export interface ManifestSlotPersistenceOverride {
   readonly branchPrefix: string;
   readonly branchSuffix?: import('@xemahq/kernel-contracts/workflow').ManifestGitPushBranchSuffix;
   readonly concurrencyMode?: import('@xemahq/kernel-contracts/workflow').ManifestGitPushConcurrencyMode;
+  /**
+   * Fully-qualified long-lived branch the per-session branch auto-merges
+   * into on pause (per-session-branch + auto-merge model). Mirrors
+   * `SlotPersistencePolicy.git-push.mergeTarget` in
+   * `@xemahq/kernel-contracts/agent-workspace`.
+   */
+  readonly mergeTarget?: string;
 }
 
 export interface ManifestPersistence {
@@ -312,7 +319,7 @@ export interface ManifestAgentBlock {
    */
   readonly defaultModel?: ManifestModelRef;
   /**
-   * Optional node-level instructions (WS5 Phase B authoring path). A prompt
+   * Optional node-level instructions. A prompt
    * fragment layered ONTO the referenced base agent's intrinsic system
    * prompt — the same lever as `AgentNode.instructions`, exposed here
    * so a WorkspaceManifest can author a migrated agent as
@@ -329,7 +336,7 @@ export interface ManifestAgentBlock {
    */
   readonly promptMode?: PromptMergeMode;
   /**
-   * Optional per-agent permission override (WS5 kernel extension). A partial
+   * Optional per-agent permission override. A partial
    * OpenCode-style `PermissionMap` deep-merged (per top-level key) over the
    * referenced base agent's authored permission before the system tiers run.
    * Lets a generic base agent be specialized into a bounded role (read-only
@@ -365,7 +372,7 @@ export interface ManifestSubAgent {
   readonly alias?: string;
   readonly defaultModel?: ManifestModelRef;
   /**
-   * Optional node-level instructions for this delegate (WS5 Phase B). Same
+   * Optional node-level instructions for this delegate. Same
    * `base agent slug + instructions` lever as the primary agent block;
    * layered onto the referenced agent's intrinsic system prompt. May
    * reference `${input.x}`. Bounded by `MAX_AGENT_INSTRUCTIONS_LENGTH`.