@xemahq/dsl 0.5.6 → 0.5.8

package/src/workflow/index.ts

@@ -57,6 +57,8 @@ export {
 export { dispatchInputsToJsonSchema } from './lib/dispatch-inputs/to-json-schema';
 export { serializeWorkflowDocument } from './lib/serializer';
 export {
+  DECISION_GATE_ACTION_ID,
+  applyGateDefaults,
   canonicalJsonSha256,
   canonicalJsonStringify,
   compileManifestSource,
@@ -85,6 +87,7 @@ export type {
   WorkflowCallDeclaration,
   WorkflowConcurrencyDeclaration,
   WorkflowDefaults,
+  WorkflowGateDefaults,
   WorkflowDispatchDeclaration,
   WorkflowDocument,
   WorkflowDynamicStrategyDeclaration,

package/src/workflow/lib/compiler/canonical-json.ts

@@ -14,7 +14,7 @@ import { createHash } from 'node:crypto';
  *   - Symbols / functions are forbidden (throws).
  */
 export function canonicalJsonStringify(value: unknown): string {
-  return stringify(value);
+  return stringify(value, new Set());
 }
 
 /** Convenience: canonical stringify + sha256 hex. */
@@ -22,7 +22,7 @@ export function canonicalJsonSha256(value: unknown): string {
   return createHash('sha256').update(canonicalJsonStringify(value), 'utf8').digest('hex');
 }
 
-function stringify(value: unknown): string {
+function stringify(value: unknown, seen: Set<object>): string {
   if (value === null) return 'null';
   if (value === undefined) {
     throw new Error('canonicalJsonStringify: undefined is not serializable');
@@ -36,17 +36,30 @@ function stringify(value: unknown): string {
   }
   if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (Array.isArray(value)) {
-    return `[${value.map(stringify).join(',')}]`;
+    // Guard against circular references (e.g. cyclic YAML anchors) so a
+    // self-referential input yields a clear error instead of a stack overflow.
+    if (seen.has(value)) {
+      throw new Error('canonicalJsonStringify: circular reference is not serializable');
+    }
+    seen.add(value);
+    const out = `[${value.map((child) => stringify(child, seen)).join(',')}]`;
+    seen.delete(value);
+    return out;
   }
   if (typeof value === 'object') {
+    if (seen.has(value)) {
+      throw new Error('canonicalJsonStringify: circular reference is not serializable');
+    }
+    seen.add(value);
     const record = value as Record<string, unknown>;
     const keys = Object.keys(record).sort();
     const entries: string[] = [];
     for (const key of keys) {
       const child = record[key];
       if (child === undefined) continue; // drop undefined; do not emit
-      entries.push(`${JSON.stringify(key)}:${stringify(child)}`);
+      entries.push(`${JSON.stringify(key)}:${stringify(child, seen)}`);
     }
+    seen.delete(value);
     return `{${entries.join(',')}}`;
   }
   throw new Error(`canonicalJsonStringify: unsupported type ${typeof value}`);

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

@@ -25,6 +25,7 @@ import {
   validateConcurrencyGroupTemplate,
 } from './concurrency';
 import { topologicalSort } from './dag';
+import { applyGateDefaults } from './gate-defaults';
 import { bindTriggerInputs } from './inputs';
 import { compileStrategy } from './matrix';
 import { compileManifestSource } from './manifest-source';
@@ -74,7 +75,13 @@ import type {
  *   8. Emit CompiledRun with a deterministic sha256.
  */
 export function compileWorkflow(input: CompileInput): CompiledRun {
-  const { workflow, workflowRef, trigger, resolvedRefs, workflowDefinitionVersionSha256 } = input;
+  const { workflowRef, trigger, resolvedRefs, workflowDefinitionVersionSha256 } = input;
+
+  // Fold `defaults.gate` into every decision-gate job's `with:` BEFORE any
+  // other pass — expression validation, needs-shape validation, and the
+  // snapshot all observe the merged document, so defaults behave exactly
+  // like inline-authored values. Explicit per-gate keys always win.
+  const workflow = applyGateDefaults(input.workflow, resolvedRefs);
 
   const inputs = bindTriggerInputs(workflow, trigger, input.previewMode ?? false);
   const vars: Readonly<Record<string, unknown>> = workflow.vars ?? {};
@@ -156,7 +163,7 @@ export function compileWorkflow(input: CompileInput): CompiledRun {
   // shape).
   validateDeliverableValueExpressions(workflow, input.resolvedDeliverableSpecs ?? {});
 
-  // §C.1 payload reach-in validation: `needs.<X>.outputs.<name>.<field>`
+  // Payload reach-in validation: `needs.<X>.outputs.<name>.<field>`
   // chains where `<field>` is not an ArtifactRef envelope field reach
   // INTO the artifact's parsed payload. The validator asserts the
   // upstream job has a schema-bearing `with.deliverableSpecRef` and
@@ -235,11 +242,11 @@ export function compileWorkflow(input: CompileInput): CompiledRun {
     );
 
     // Validate `if` expression shape now — runtime evaluator only fails on
-    // unknown bindings after this point. Plan §G shorthand: rewrite a
+    // unknown bindings after this point. Shorthand: rewrite a
     // bare `needs.<X>` reference to `needs.<X>.outcome == 'ok'` so the
     // evaluator sees the explicit success check (an envelope object is
-    // truthy even on failure — silent always-true is the trap §G
-    // explicitly avoids).
+    // truthy even on failure — silent always-true is the trap this
+    // rewrite explicitly avoids).
     const ifExpression = payload.if !== undefined
       ? (() => {
           const body = stripInterpolation(payload.if!);
@@ -260,7 +267,7 @@ export function compileWorkflow(input: CompileInput): CompiledRun {
     // `x-installation-resource` field in the `with:` block and confirm
     // its value is bound to the calling installation. Rejects unbound
     // walletIds (etc.) BEFORE the dispatch creates a run, instead of
-    // failing 3 activities later when integration-adapters refuses to
+    // failing 3 activities later when connector-gateway-api refuses to
     // mint credentials. Skips entirely for system / org-wide dispatches.
     validateInstallationResourceBindings({
       jobKey: key,
@@ -397,7 +404,7 @@ function assertNoVarsBriefcaseCollision(
  * safe with this compiler's closed enum.
  */
 /**
- * Plan §G shorthand: rewrite a bare `needs.<X>` reference at the top
+ * Shorthand: rewrite a bare `needs.<X>` reference at the top
  * level of an `if:` expression to `needs.<X>.outcome == 'ok'`. Authors
  * write `if: needs.draft` to mean "run if draft succeeded"; without
  * this rewrite the evaluator sees the upstream's envelope object

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/inputs.ts

@@ -60,7 +60,7 @@ export function bindTriggerInputs(
     }
     case WorkflowTriggerKind.WEBHOOK: {
       // Webhook does not declare typed inputs at the workflow level —
-      // validation of the canonical envelope happens at integration-adapters-api.
+      // validation of the canonical envelope happens at connector-gateway-api.
       return trigger.payload;
     }
   }

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/installation-resource-kind.ts

@@ -12,7 +12,7 @@
  *      how to query bound resources of that kind from biome-host-api.
  */
 export enum InstallationResourceKind {
-  /** SMTP / IMAP wallet — `OrgIntegrationCredential` row attached to the installation. */
+  /** SMTP / IMAP wallet — `OrgConnectionCredential` row attached to the installation. */
   Wallet = 'wallet',
   /** SCM repository binding on the installation. */
   Repo = 'repo',

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

@@ -98,22 +98,22 @@ export interface WorkflowRequiresDeclaration {
   /** Wallet names; must match `^[a-z][a-z0-9-]{0,62}$`. */
   readonly wallets?: readonly string[];
   /**
-   * Integration adapter kinds the workflow consumes. Biome-shipped
+   * Connector adapter kinds the workflow consumes. Biome-shipped
    * workflows declare these so `biome-host-api` can cross-validate
-   * them against the biome's manifest `integrationRequirements` at
+   * them against the biome's manifest `connectorRequirements` at
    * boot. Stand-alone workflows (not biome-owned) may also declare
    * them as documentation; dispatch-time enforcement only kicks in
    * for biome-gated runs.
    */
-  readonly integrations?: readonly WorkflowIntegrationRequirement[];
+  readonly connectors?: readonly WorkflowConnectorRequirement[];
 }
 
-export interface WorkflowIntegrationRequirement {
+export interface WorkflowConnectorRequirement {
   /** Adapter kind slug (e.g. `scm`, `tracker`, `documentation`). */
   readonly adapterKind: string;
   /** Capability slugs the workflow exercises against the adapter. */
   readonly capabilities: readonly string[];
-  /** Whether the workflow can degrade if the integration is unbound. */
+  /** Whether the workflow can degrade if the connector is unbound. */
   readonly optional?: boolean;
 }
 
@@ -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 {
@@ -181,7 +207,7 @@ export interface WorkflowRetryDeclaration {
   readonly nonRetryableErrorTypes?: readonly string[];
 }
 
-export type WorkflowPermissions = Partial<Record<'repos' | 'kb' | 'backlog' | 'integrations' | 'artifacts' | 'memory', PermissionScope>>;
+export type WorkflowPermissions = Partial<Record<'repos' | 'kb' | 'backlog' | 'connectors' | 'artifacts' | 'memory', PermissionScope>>;
 
 export interface WorkflowJobDeclaration {
   readonly title?: string;
@@ -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