agent-relay 3.2.0 → 3.2.1

package/dist/index.cjs

@@ -33433,6 +33433,131 @@ var import_promises3 = require("node:fs/promises");
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_yaml2 = __toESM(require_dist(), 1);
 
+// packages/sdk/dist/spawn-from-env.js
+var BYPASS_FLAGS = {
+  claude: { flag: "--dangerously-skip-permissions" },
+  codex: {
+    flag: "--dangerously-bypass-approvals-and-sandbox",
+    aliases: ["--full-auto"]
+  },
+  gemini: {
+    flag: "--yolo",
+    aliases: ["-y"]
+  }
+};
+function getBypassFlagConfig(cli) {
+  const baseCli = cli.includes(":") ? cli.split(":")[0] : cli;
+  return BYPASS_FLAGS[baseCli];
+}
+function parseSpawnEnv(env = process.env) {
+  const AGENT_NAME = env.AGENT_NAME;
+  const AGENT_CLI = env.AGENT_CLI;
+  const RELAY_API_KEY = env.RELAY_API_KEY;
+  const missing = [];
+  if (!AGENT_NAME)
+    missing.push("AGENT_NAME");
+  if (!AGENT_CLI)
+    missing.push("AGENT_CLI");
+  if (!RELAY_API_KEY)
+    missing.push("RELAY_API_KEY");
+  if (missing.length > 0) {
+    throw new Error(`[spawn-from-env] Missing required environment variables: ${missing.join(", ")}`);
+  }
+  return {
+    AGENT_NAME,
+    AGENT_CLI,
+    RELAY_API_KEY,
+    AGENT_TASK: env.AGENT_TASK || void 0,
+    AGENT_ARGS: env.AGENT_ARGS || void 0,
+    AGENT_CWD: env.AGENT_CWD || void 0,
+    AGENT_CHANNELS: env.AGENT_CHANNELS || void 0,
+    RELAY_BASE_URL: env.RELAY_BASE_URL || void 0,
+    BROKER_BINARY_PATH: env.BROKER_BINARY_PATH || void 0,
+    AGENT_MODEL: env.AGENT_MODEL || void 0,
+    AGENT_DISABLE_DEFAULT_BYPASS: env.AGENT_DISABLE_DEFAULT_BYPASS || void 0
+  };
+}
+function parseArgs(raw) {
+  if (!raw)
+    return [];
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed))
+        return parsed.map(String);
+    } catch {
+    }
+  }
+  return trimmed.split(/\s+/).filter(Boolean);
+}
+function resolveSpawnPolicy(input) {
+  const extraArgs = parseArgs(input.AGENT_ARGS);
+  const channels = input.AGENT_CHANNELS ? input.AGENT_CHANNELS.split(",").map((c) => c.trim()).filter(Boolean) : ["general"];
+  const disableBypass = input.AGENT_DISABLE_DEFAULT_BYPASS === "1";
+  const bypassConfig = getBypassFlagConfig(input.AGENT_CLI);
+  let bypassApplied = false;
+  const args = [...extraArgs];
+  const bypassValues = bypassConfig ? [bypassConfig.flag, ...bypassConfig.aliases ?? []] : [];
+  const hasBypassAlready = bypassValues.some((value) => args.includes(value));
+  if (bypassConfig && !disableBypass && !hasBypassAlready) {
+    args.push(bypassConfig.flag);
+    bypassApplied = true;
+  }
+  return {
+    name: input.AGENT_NAME,
+    cli: input.AGENT_CLI,
+    args,
+    channels,
+    task: input.AGENT_TASK,
+    cwd: input.AGENT_CWD,
+    model: input.AGENT_MODEL,
+    bypassApplied
+  };
+}
+async function spawnFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const parsed = parseSpawnEnv(env);
+  const policy = resolveSpawnPolicy(parsed);
+  console.log(`[spawn-from-env] Spawning agent: name=${policy.name} cli=${policy.cli} channels=${policy.channels.join(",")} bypass=${policy.bypassApplied}`);
+  if (policy.task) {
+    console.log(`[spawn-from-env] Task: ${policy.task.slice(0, 200)}${policy.task.length > 200 ? "..." : ""}`);
+  }
+  const relay = new AgentRelay({
+    binaryPath: options.binaryPath ?? parsed.BROKER_BINARY_PATH,
+    brokerName: options.brokerName ?? `broker-${policy.name}`,
+    channels: policy.channels,
+    cwd: policy.cwd ?? process.cwd(),
+    env
+  });
+  relay.onAgentSpawned = (agent) => {
+    console.log(`[spawn-from-env] Agent spawned: ${agent.name}`);
+  };
+  relay.onAgentReady = (agent) => {
+    console.log(`[spawn-from-env] Agent ready: ${agent.name}`);
+  };
+  relay.onAgentExited = (agent) => {
+    console.log(`[spawn-from-env] Agent exited: ${agent.name} code=${agent.exitCode ?? "none"} signal=${agent.exitSignal ?? "none"}`);
+  };
+  try {
+    const agent = await relay.spawnPty({
+      name: policy.name,
+      cli: policy.cli,
+      args: policy.args,
+      channels: policy.channels,
+      task: policy.task
+    });
+    const exitReason = await agent.waitForExit();
+    console.log(`[spawn-from-env] Exit reason: ${exitReason}`);
+    return { exitReason, exitCode: agent.exitCode };
+  } catch (err) {
+    console.error(`[spawn-from-env] Error:`, err);
+    throw err;
+  } finally {
+    await relay.shutdown();
+  }
+}
+
 // packages/sdk/dist/workflows/custom-steps.js
 var import_node_fs2 = require("node:fs");
 var import_node_path6 = __toESM(require("node:path"), 1);
@@ -33906,15 +34031,34 @@ var WorkflowTrajectory = class {
     });
     await this.flush();
   }
+  async stepCompletionDecision(stepName, decision) {
+    if (!this.enabled || !this.trajectory)
+      return;
+    const modeLabel = decision.mode === "marker" ? "marker-based" : `${decision.mode}-based`;
+    const reason = decision.reason ? ` \u2014 ${decision.reason}` : "";
+    const evidence = this.formatCompletionEvidenceSummary(decision.evidence);
+    const evidenceSuffix = evidence ? ` (${evidence})` : "";
+    this.addEvent(decision.mode === "marker" ? "completion-marker" : "completion-evidence", `"${stepName}" ${modeLabel} completion${reason}${evidenceSuffix}`, "medium", {
+      stepName,
+      completionMode: decision.mode,
+      reason: decision.reason,
+      evidence: decision.evidence
+    });
+    await this.flush();
+  }
   /** Record step completed — captures what was accomplished. */
-  async stepCompleted(step, output, attempt) {
+  async stepCompleted(step, output, attempt, decision) {
     if (!this.enabled || !this.trajectory)
       return;
     const suffix = attempt > 1 ? ` (after ${attempt} attempts)` : "";
     const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
     const lastMeaningful = lines.at(-1) ?? "";
     const completion = lastMeaningful.length > 0 && lastMeaningful.length < 100 ? lastMeaningful : output.trim().slice(0, 120) || "(no output)";
-    this.addEvent("finding", `"${step.name}" completed${suffix} \u2192 ${completion}`, "medium");
+    if (decision) {
+      await this.stepCompletionDecision(step.name, decision);
+    }
+    const modeSuffix = decision ? ` [${decision.mode}]` : "";
+    this.addEvent("finding", `"${step.name}" completed${suffix}${modeSuffix} \u2192 ${completion}`, "medium");
     await this.flush();
   }
   /** Record step failed — categorizes root cause for actionable diagnosis. */
@@ -34157,6 +34301,22 @@ var WorkflowTrajectory = class {
       event.raw = raw;
     chapter.events.push(event);
   }
+  formatCompletionEvidenceSummary(evidence) {
+    if (!evidence)
+      return void 0;
+    const parts = [];
+    if (evidence.summary)
+      parts.push(evidence.summary);
+    if (evidence.signals?.length)
+      parts.push(`signals=${evidence.signals.join(", ")}`);
+    if (evidence.channelPosts?.length)
+      parts.push(`channel=${evidence.channelPosts.join(" | ")}`);
+    if (evidence.files?.length)
+      parts.push(`files=${evidence.files.join(", ")}`);
+    if (evidence.exitCode !== void 0)
+      parts.push(`exit=${evidence.exitCode}`);
+    return parts.length > 0 ? parts.join("; ") : void 0;
+  }
   async flush() {
     if (!this.trajectory)
       return;
@@ -34196,6 +34356,14 @@ var SpawnExitError = class extends Error {
     this.exitSignal = exitSignal ?? void 0;
   }
 };
+var WorkflowCompletionError = class extends Error {
+  completionReason;
+  constructor(message, completionReason) {
+    super(message);
+    this.name = "WorkflowCompletionError";
+    this.completionReason = completionReason;
+  }
+};
 var _resolvedCursorCli;
 function resolveCursorCli() {
   if (_resolvedCursorCli !== void 0)
@@ -34259,6 +34427,12 @@ var WorkflowRunner = class _WorkflowRunner {
   lastActivity = /* @__PURE__ */ new Map();
   /** Runtime-name lookup for agents participating in supervised owner flows. */
   supervisedRuntimeAgents = /* @__PURE__ */ new Map();
+  /** Runtime-name lookup for active step agents so channel messages can be attributed to a step. */
+  runtimeStepAgents = /* @__PURE__ */ new Map();
+  /** Per-step completion evidence collected across output, channel, files, and tool side-effects. */
+  stepCompletionEvidence = /* @__PURE__ */ new Map();
+  /** Expected owner/worker identities per step so coordination signals can be validated by sender. */
+  stepSignalParticipants = /* @__PURE__ */ new Map();
   /** Resolved named paths from the top-level `paths` config, keyed by name → absolute directory. */
   resolvedPaths = /* @__PURE__ */ new Map();
   constructor(options = {}) {
@@ -34339,6 +34513,423 @@ var WorkflowRunner = class _WorkflowRunner {
     }
     return resolved;
   }
+  static EVIDENCE_IGNORED_DIRS = /* @__PURE__ */ new Set([
+    ".git",
+    ".agent-relay",
+    ".trajectories",
+    "node_modules"
+  ]);
+  getStepCompletionEvidence(stepName) {
+    const record2 = this.stepCompletionEvidence.get(stepName);
+    if (!record2)
+      return void 0;
+    const evidence = structuredClone(record2.evidence);
+    return this.filterStepEvidenceBySignalProvenance(stepName, evidence);
+  }
+  getOrCreateStepEvidenceRecord(stepName) {
+    const existing = this.stepCompletionEvidence.get(stepName);
+    if (existing)
+      return existing;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record2 = {
+      evidence: {
+        stepName,
+        lastUpdatedAt: now,
+        roots: [],
+        output: {
+          stdout: "",
+          stderr: "",
+          combined: ""
+        },
+        channelPosts: [],
+        files: [],
+        process: {},
+        toolSideEffects: [],
+        coordinationSignals: []
+      },
+      baselineSnapshots: /* @__PURE__ */ new Map(),
+      filesCaptured: false
+    };
+    this.stepCompletionEvidence.set(stepName, record2);
+    return record2;
+  }
+  initializeStepSignalParticipants(stepName, ownerSender, workerSender) {
+    this.stepSignalParticipants.set(stepName, {
+      ownerSenders: /* @__PURE__ */ new Set(),
+      workerSenders: /* @__PURE__ */ new Set()
+    });
+    this.rememberStepSignalSender(stepName, "owner", ownerSender);
+    this.rememberStepSignalSender(stepName, "worker", workerSender);
+  }
+  rememberStepSignalSender(stepName, participant, ...senders) {
+    const participants = this.stepSignalParticipants.get(stepName) ?? {
+      ownerSenders: /* @__PURE__ */ new Set(),
+      workerSenders: /* @__PURE__ */ new Set()
+    };
+    this.stepSignalParticipants.set(stepName, participants);
+    const target = participant === "owner" ? participants.ownerSenders : participants.workerSenders;
+    for (const sender of senders) {
+      const trimmed = sender?.trim();
+      if (trimmed)
+        target.add(trimmed);
+    }
+  }
+  resolveSignalParticipantKind(role) {
+    const roleLC = role?.toLowerCase().trim();
+    if (!roleLC)
+      return void 0;
+    if (/\b(owner|lead|supervisor)\b/.test(roleLC))
+      return "owner";
+    if (/\b(worker|specialist|engineer|implementer)\b/.test(roleLC))
+      return "worker";
+    return void 0;
+  }
+  isSignalFromExpectedSender(stepName, signal) {
+    const expectedParticipant = signal.kind === "worker_done" ? "worker" : signal.kind === "lead_done" ? "owner" : void 0;
+    if (!expectedParticipant)
+      return true;
+    const participants = this.stepSignalParticipants.get(stepName);
+    if (!participants)
+      return true;
+    const allowedSenders = expectedParticipant === "owner" ? participants.ownerSenders : participants.workerSenders;
+    if (allowedSenders.size === 0)
+      return true;
+    const sender = signal.sender ?? signal.actor;
+    if (sender) {
+      return allowedSenders.has(sender);
+    }
+    const observedParticipant = this.resolveSignalParticipantKind(signal.role);
+    if (observedParticipant) {
+      return observedParticipant === expectedParticipant;
+    }
+    return signal.source !== "channel";
+  }
+  filterStepEvidenceBySignalProvenance(stepName, evidence) {
+    evidence.channelPosts = evidence.channelPosts.map((post) => {
+      const signals = post.signals.filter((signal) => this.isSignalFromExpectedSender(stepName, signal));
+      return {
+        ...post,
+        completionRelevant: signals.length > 0,
+        signals
+      };
+    });
+    evidence.coordinationSignals = evidence.coordinationSignals.filter((signal) => this.isSignalFromExpectedSender(stepName, signal));
+    return evidence;
+  }
+  beginStepEvidence(stepName, roots, startedAt) {
+    const record2 = this.getOrCreateStepEvidenceRecord(stepName);
+    const evidence = record2.evidence;
+    const now = startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    evidence.startedAt ??= now;
+    evidence.status = "running";
+    evidence.lastUpdatedAt = now;
+    for (const root of this.uniqueEvidenceRoots(roots)) {
+      if (!evidence.roots.includes(root)) {
+        evidence.roots.push(root);
+      }
+      if (!record2.baselineSnapshots.has(root)) {
+        record2.baselineSnapshots.set(root, this.captureFileSnapshot(root));
+      }
+    }
+  }
+  captureStepTerminalEvidence(stepName, output, process3, meta3) {
+    const record2 = this.getOrCreateStepEvidenceRecord(stepName);
+    const evidence = record2.evidence;
+    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const append = (current, next) => {
+      if (!next)
+        return current;
+      return current ? `${current}
+${next}` : next;
+    };
+    if (output.stdout) {
+      evidence.output.stdout = append(evidence.output.stdout, output.stdout);
+      for (const signal of this.extractCompletionSignals(output.stdout, "stdout", observedAt, meta3)) {
+        evidence.coordinationSignals.push(signal);
+      }
+    }
+    if (output.stderr) {
+      evidence.output.stderr = append(evidence.output.stderr, output.stderr);
+      for (const signal of this.extractCompletionSignals(output.stderr, "stderr", observedAt, meta3)) {
+        evidence.coordinationSignals.push(signal);
+      }
+    }
+    const combinedOutput = output.combined ?? [output.stdout, output.stderr].filter((value) => Boolean(value)).join("\n");
+    if (combinedOutput) {
+      evidence.output.combined = append(evidence.output.combined, combinedOutput);
+    }
+    if (process3) {
+      if (process3.exitCode !== void 0) {
+        evidence.process.exitCode = process3.exitCode;
+        evidence.coordinationSignals.push({
+          kind: "process_exit",
+          source: "process",
+          text: `Process exited with code ${process3.exitCode}`,
+          observedAt,
+          value: String(process3.exitCode)
+        });
+      }
+      if (process3.exitSignal !== void 0) {
+        evidence.process.exitSignal = process3.exitSignal;
+      }
+    }
+    evidence.lastUpdatedAt = observedAt;
+  }
+  finalizeStepEvidence(stepName, status, completedAt, completionReason) {
+    const record2 = this.stepCompletionEvidence.get(stepName);
+    if (!record2)
+      return;
+    const evidence = record2.evidence;
+    const observedAt = completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    evidence.status = status;
+    if (status !== "running") {
+      evidence.completedAt = observedAt;
+    }
+    evidence.lastUpdatedAt = observedAt;
+    if (!record2.filesCaptured) {
+      const existing = new Set(evidence.files.map((file2) => `${file2.kind}:${file2.path}`));
+      for (const root of evidence.roots) {
+        const before = record2.baselineSnapshots.get(root) ?? /* @__PURE__ */ new Map();
+        const after = this.captureFileSnapshot(root);
+        for (const change of this.diffFileSnapshots(before, after, root, observedAt)) {
+          const key = `${change.kind}:${change.path}`;
+          if (existing.has(key))
+            continue;
+          existing.add(key);
+          evidence.files.push(change);
+        }
+      }
+      record2.filesCaptured = true;
+    }
+    if (completionReason) {
+      const decision = this.buildStepCompletionDecision(stepName, completionReason);
+      if (decision) {
+        void this.trajectory?.stepCompletionDecision(stepName, decision);
+      }
+    }
+  }
+  recordStepToolSideEffect(stepName, effect) {
+    const record2 = this.getOrCreateStepEvidenceRecord(stepName);
+    const observedAt = effect.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    record2.evidence.toolSideEffects.push({
+      ...effect,
+      observedAt
+    });
+    record2.evidence.lastUpdatedAt = observedAt;
+  }
+  recordChannelEvidence(text, options = {}) {
+    const stepName = options.stepName ?? this.inferStepNameFromChannelText(text) ?? (options.actor ? this.runtimeStepAgents.get(options.actor)?.stepName : void 0);
+    if (!stepName)
+      return;
+    const record2 = this.getOrCreateStepEvidenceRecord(stepName);
+    const postedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const sender = options.sender ?? options.actor;
+    const signals = this.extractCompletionSignals(text, "channel", postedAt, {
+      sender,
+      actor: options.actor,
+      role: options.role
+    });
+    const channelPost = {
+      stepName,
+      text,
+      postedAt,
+      origin: options.origin ?? "runner_post",
+      completionRelevant: signals.length > 0,
+      sender,
+      actor: options.actor,
+      role: options.role,
+      target: options.target,
+      signals
+    };
+    record2.evidence.channelPosts.push(channelPost);
+    record2.evidence.coordinationSignals.push(...signals);
+    record2.evidence.lastUpdatedAt = postedAt;
+  }
+  extractCompletionSignals(text, source, observedAt, meta3) {
+    const signals = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (kind, signalText, value) => {
+      const trimmed = signalText.trim().slice(0, 280);
+      if (!trimmed)
+        return;
+      const key = `${kind}:${trimmed}:${value ?? ""}`;
+      if (seen.has(key))
+        return;
+      seen.add(key);
+      signals.push({
+        kind,
+        source,
+        text: trimmed,
+        observedAt,
+        sender: meta3?.sender,
+        actor: meta3?.actor,
+        role: meta3?.role,
+        value
+      });
+    };
+    for (const match of text.matchAll(/\bWORKER_DONE\b(?::\s*([^\n]+))?/gi)) {
+      add("worker_done", match[0], match[1]?.trim());
+    }
+    for (const match of text.matchAll(/\bLEAD_DONE\b(?::\s*([^\n]+))?/gi)) {
+      add("lead_done", match[0], match[1]?.trim());
+    }
+    for (const match of text.matchAll(/\bSTEP_COMPLETE:([A-Za-z0-9_.:-]+)/g)) {
+      add("step_complete", match[0], match[1]);
+    }
+    for (const match of text.matchAll(/\bOWNER_DECISION:\s*(COMPLETE|INCOMPLETE_RETRY|INCOMPLETE_FAIL|NEEDS_CLARIFICATION)\b/gi)) {
+      add("owner_decision", match[0], match[1].toUpperCase());
+    }
+    for (const match of text.matchAll(/\bREVIEW_DECISION:\s*(APPROVE|REJECT)\b/gi)) {
+      add("review_decision", match[0], match[1].toUpperCase());
+    }
+    if (/\bverification gate observed\b|\bverification passed\b/i.test(text)) {
+      add("verification_passed", this.firstMeaningfulLine(text) ?? text);
+    }
+    if (/\bverification failed\b/i.test(text)) {
+      add("verification_failed", this.firstMeaningfulLine(text) ?? text);
+    }
+    if (/\b(summary|handoff|ready for review|ready for handoff|task complete|work complete|completed work|finished work)\b/i.test(text)) {
+      add("task_summary", this.firstMeaningfulLine(text) ?? text);
+    }
+    return signals;
+  }
+  inferStepNameFromChannelText(text) {
+    const bracketMatch = text.match(/^\*\*\[([^\]]+)\]/);
+    if (bracketMatch?.[1])
+      return bracketMatch[1];
+    const markerMatch = text.match(/\bSTEP_COMPLETE:([A-Za-z0-9_.:-]+)/);
+    if (markerMatch?.[1])
+      return markerMatch[1];
+    return void 0;
+  }
+  uniqueEvidenceRoots(roots) {
+    return [...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path8.default.resolve(root)))];
+  }
+  captureFileSnapshot(root) {
+    const snapshot = /* @__PURE__ */ new Map();
+    if (!(0, import_node_fs4.existsSync)(root))
+      return snapshot;
+    const visit = (currentPath) => {
+      let entries;
+      try {
+        entries = (0, import_node_fs4.readdirSync)(currentPath, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory() && _WorkflowRunner.EVIDENCE_IGNORED_DIRS.has(entry.name)) {
+          continue;
+        }
+        const fullPath = import_node_path8.default.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+          visit(fullPath);
+          continue;
+        }
+        try {
+          const stats = (0, import_node_fs4.statSync)(fullPath);
+          if (!stats.isFile())
+            continue;
+          snapshot.set(fullPath, { mtimeMs: stats.mtimeMs, size: stats.size });
+        } catch {
+        }
+      }
+    };
+    try {
+      const stats = (0, import_node_fs4.statSync)(root);
+      if (stats.isFile()) {
+        snapshot.set(root, { mtimeMs: stats.mtimeMs, size: stats.size });
+        return snapshot;
+      }
+    } catch {
+      return snapshot;
+    }
+    visit(root);
+    return snapshot;
+  }
+  diffFileSnapshots(before, after, root, observedAt) {
+    const allPaths = /* @__PURE__ */ new Set([...before.keys(), ...after.keys()]);
+    const changes = [];
+    for (const filePath of allPaths) {
+      const prior = before.get(filePath);
+      const next = after.get(filePath);
+      let kind;
+      if (!prior && next) {
+        kind = "created";
+      } else if (prior && !next) {
+        kind = "deleted";
+      } else if (prior && next && (prior.mtimeMs !== next.mtimeMs || prior.size !== next.size)) {
+        kind = "modified";
+      }
+      if (!kind)
+        continue;
+      changes.push({
+        path: this.normalizeEvidencePath(filePath),
+        kind,
+        observedAt,
+        root
+      });
+    }
+    return changes.sort((a, b) => a.path.localeCompare(b.path));
+  }
+  normalizeEvidencePath(filePath) {
+    const relative = import_node_path8.default.relative(this.cwd, filePath);
+    if (!relative || relative === "")
+      return import_node_path8.default.basename(filePath);
+    return relative.startsWith("..") ? filePath : relative;
+  }
+  buildStepCompletionDecision(stepName, completionReason) {
+    let reason;
+    let mode;
+    switch (completionReason) {
+      case "completed_verified":
+        mode = "verification";
+        reason = "Verification passed";
+        break;
+      case "completed_by_evidence":
+        mode = "evidence";
+        reason = "Completion inferred from collected evidence";
+        break;
+      case "completed_by_owner_decision": {
+        const evidence = this.getStepCompletionEvidence(stepName);
+        const markerObserved = evidence?.coordinationSignals.some((signal) => signal.kind === "step_complete");
+        mode = markerObserved ? "marker" : "owner_decision";
+        reason = markerObserved ? "Legacy STEP_COMPLETE marker observed" : "Owner approved completion";
+        break;
+      }
+      default:
+        return void 0;
+    }
+    return {
+      mode,
+      reason,
+      evidence: this.buildTrajectoryCompletionEvidence(stepName)
+    };
+  }
+  buildTrajectoryCompletionEvidence(stepName) {
+    const evidence = this.getStepCompletionEvidence(stepName);
+    if (!evidence)
+      return void 0;
+    const signals = evidence.coordinationSignals.slice(-6).map((signal) => signal.value ?? signal.text);
+    const channelPosts = evidence.channelPosts.filter((post) => post.completionRelevant).slice(-3).map((post) => post.text.slice(0, 160));
+    const files = evidence.files.slice(0, 6).map((file2) => `${file2.kind}:${file2.path}`);
+    const summaryParts = [];
+    if (signals.length > 0)
+      summaryParts.push(`${signals.length} signal(s)`);
+    if (channelPosts.length > 0)
+      summaryParts.push(`${channelPosts.length} relevant channel post(s)`);
+    if (files.length > 0)
+      summaryParts.push(`${files.length} file change(s)`);
+    if (evidence.process.exitCode !== void 0) {
+      summaryParts.push(`exit=${evidence.process.exitCode}`);
+    }
+    return {
+      summary: summaryParts.length > 0 ? summaryParts.join(", ") : void 0,
+      signals: signals.length > 0 ? signals : void 0,
+      channelPosts: channelPosts.length > 0 ? channelPosts : void 0,
+      files: files.length > 0 ? files : void 0,
+      exitCode: evidence.process.exitCode
+    };
+  }
   // ── Progress logging ────────────────────────────────────────────────────
   /** Log a progress message with elapsed time since run start. */
   log(msg) {
@@ -35064,9 +35655,11 @@ ${err.suggestion}`);
       if (state.row.status === "failed") {
         state.row.status = "pending";
         state.row.error = void 0;
+        state.row.completionReason = void 0;
         await this.db.updateStep(state.row.id, {
           status: "pending",
           error: void 0,
+          completionReason: void 0,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
@@ -35085,6 +35678,8 @@ ${err.suggestion}`);
     this.currentConfig = config2;
     this.currentRunId = runId;
     this.runStartTime = Date.now();
+    this.runtimeStepAgents.clear();
+    this.stepCompletionEvidence.clear();
     this.log(`Starting workflow "${workflow2.name}" (${workflow2.steps.length} steps)`);
     this.trajectory = new WorkflowTrajectory(config2.trajectories, runId, this.cwd);
     try {
@@ -35188,8 +35783,24 @@ ${err.suggestion}`);
           const fromShort = msg.from.replace(/-[a-f0-9]{6,}$/, "");
           const toShort = msg.to.replace(/-[a-f0-9]{6,}$/, "");
           this.log(`[msg] ${fromShort} \u2192 ${toShort}: ${body}`);
+          if (this.channel && (msg.to === this.channel || msg.to === `#${this.channel}`)) {
+            const runtimeAgent = this.runtimeStepAgents.get(msg.from);
+            this.recordChannelEvidence(msg.text, {
+              sender: runtimeAgent?.logicalName ?? msg.from,
+              actor: msg.from,
+              role: runtimeAgent?.role,
+              target: msg.to,
+              origin: "relay_message",
+              stepName: runtimeAgent?.stepName
+            });
+          }
           const supervision = this.supervisedRuntimeAgents.get(msg.from);
           if (supervision?.role === "owner") {
+            this.recordStepToolSideEffect(supervision.stepName, {
+              type: "owner_monitoring",
+              detail: `Owner messaged ${msg.to}: ${msg.text.slice(0, 120)}`,
+              raw: { to: msg.to, text: msg.text }
+            });
             void this.trajectory?.ownerMonitoringEvent(supervision.stepName, supervision.logicalName, `Messaged ${msg.to}: ${msg.text.slice(0, 120)}`, { to: msg.to, text: msg.text });
           }
         };
@@ -35333,6 +35944,7 @@ ${err.suggestion}`);
               updatedAt: (/* @__PURE__ */ new Date()).toISOString()
             });
             this.emit({ type: "step:failed", runId, stepName, error: "Cancelled" });
+            this.finalizeStepEvidence(stepName, "failed");
           }
         }
         this.emit({ type: "run:cancelled", runId });
@@ -35370,6 +35982,7 @@ ${err.suggestion}`);
       this.lastIdleLog.clear();
       this.lastActivity.clear();
       this.supervisedRuntimeAgents.clear();
+      this.runtimeStepAgents.clear();
       this.log("Shutting down broker...");
       await this.relay?.shutdown();
       this.relay = void 0;
@@ -35457,7 +36070,8 @@ ${err.suggestion}`);
             status: state?.row.status === "completed" ? "completed" : "failed",
             attempts: (state?.row.retryCount ?? 0) + 1,
             output: state?.row.output,
-            verificationPassed: state?.row.status === "completed" && step.verification !== void 0
+            verificationPassed: state?.row.status === "completed" && step.verification !== void 0,
+            completionMode: state?.row.completionReason ? this.buildStepCompletionDecision(step.name, state.row.completionReason)?.mode : void 0
           });
         }
       }
@@ -35604,11 +36218,21 @@ ${trimmedOutput.slice(0, 200)}`);
     const maxRetries = step.retries ?? errorHandling?.maxRetries ?? 0;
     const retryDelay = errorHandling?.retryDelayMs ?? 1e3;
     let lastError;
+    let lastCompletionReason;
+    let lastExitCode;
+    let lastExitSignal;
     for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
       this.checkAborted();
+      lastExitCode = void 0;
+      lastExitSignal = void 0;
       if (attempt > 0) {
         this.emit({ type: "step:retrying", runId, stepName: step.name, attempt });
         this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${maxRetries + 1})`);
+        this.recordStepToolSideEffect(step.name, {
+          type: "retry",
+          detail: `Retrying attempt ${attempt + 1}/${maxRetries + 1}`,
+          raw: { attempt, maxRetries }
+        });
         state.row.retryCount = attempt;
         await this.db.updateStep(state.row.id, {
           retryCount: attempt,
@@ -35617,9 +36241,13 @@ ${trimmedOutput.slice(0, 200)}`);
         await this.delay(retryDelay);
       }
       state.row.status = "running";
+      state.row.error = void 0;
+      state.row.completionReason = void 0;
       state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.updateStep(state.row.id, {
         status: "running",
+        error: void 0,
+        completionReason: void 0,
         startedAt: state.row.startedAt,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -35634,30 +36262,36 @@ ${trimmedOutput.slice(0, 200)}`);
         return value !== void 0 ? String(value) : _match;
       });
       const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
+      this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
       try {
         if (this.executor?.executeDeterministicStep) {
           const result = await this.executor.executeDeterministicStep(step, resolvedCommand, stepCwd);
+          lastExitCode = result.exitCode;
           const failOnError = step.failOnError !== false;
           if (failOnError && result.exitCode !== 0) {
             throw new Error(`Command failed with exit code ${result.exitCode}: ${result.output.slice(0, 500)}`);
           }
           const output2 = step.captureOutput !== false ? result.output : `Command completed (exit code ${result.exitCode})`;
-          if (step.verification) {
-            this.runVerification(step.verification, output2, step.name);
-          }
+          this.captureStepTerminalEvidence(step.name, { stdout: result.output, combined: result.output }, { exitCode: result.exitCode });
+          const verificationResult2 = step.verification ? this.runVerification(step.verification, output2, step.name) : void 0;
           state.row.status = "completed";
           state.row.output = output2;
+          state.row.completionReason = verificationResult2?.completionReason;
           state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
           await this.db.updateStep(state.row.id, {
             status: "completed",
             output: output2,
+            completionReason: verificationResult2?.completionReason,
             completedAt: state.row.completedAt,
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           });
           await this.persistStepOutput(runId, step.name, output2);
           this.emit({ type: "step:completed", runId, stepName: step.name, output: output2 });
+          this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, verificationResult2?.completionReason);
           return;
         }
+        let commandStdout = "";
+        let commandStderr = "";
         const output = await new Promise((resolve3, reject) => {
           const child = (0, import_node_child_process3.spawn)("sh", ["-c", resolvedCommand], {
             stdio: "pipe",
@@ -35690,7 +36324,7 @@ ${trimmedOutput.slice(0, 200)}`);
           child.stderr?.on("data", (chunk) => {
             stderrChunks.push(chunk.toString());
           });
-          child.on("close", (code) => {
+          child.on("close", (code, signal) => {
             if (timer)
               clearTimeout(timer);
             if (abortHandler && abortSignal) {
@@ -35706,6 +36340,10 @@ ${trimmedOutput.slice(0, 200)}`);
             }
             const stdout = stdoutChunks.join("");
             const stderr = stderrChunks.join("");
+            commandStdout = stdout;
+            commandStderr = stderr;
+            lastExitCode = code ?? void 0;
+            lastExitSignal = signal ?? void 0;
             const failOnError = step.failOnError !== false;
             if (failOnError && code !== 0 && code !== null) {
               reject(new Error(`Command failed with exit code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
@@ -35722,28 +36360,35 @@ ${trimmedOutput.slice(0, 200)}`);
             reject(new Error(`Failed to execute command: ${err.message}`));
           });
         });
-        if (step.verification) {
-          this.runVerification(step.verification, output, step.name);
-        }
+        this.captureStepTerminalEvidence(step.name, {
+          stdout: commandStdout || output,
+          stderr: commandStderr,
+          combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
+        }, { exitCode: lastExitCode, exitSignal: lastExitSignal });
+        const verificationResult = step.verification ? this.runVerification(step.verification, output, step.name) : void 0;
         state.row.status = "completed";
         state.row.output = output;
+        state.row.completionReason = verificationResult?.completionReason;
         state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.db.updateStep(state.row.id, {
           status: "completed",
           output,
+          completionReason: verificationResult?.completionReason,
           completedAt: state.row.completedAt,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         await this.persistStepOutput(runId, step.name, output);
         this.emit({ type: "step:completed", runId, stepName: step.name, output });
+        this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, verificationResult?.completionReason);
         return;
       } catch (err) {
         lastError = err instanceof Error ? err.message : String(err);
+        lastCompletionReason = err instanceof WorkflowCompletionError ? err.completionReason : void 0;
       }
     }
     const errorMsg = lastError ?? "Unknown error";
     this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
-    await this.markStepFailed(state, errorMsg, runId);
+    await this.markStepFailed(state, errorMsg, runId, { exitCode: lastExitCode, exitSignal: lastExitSignal }, lastCompletionReason);
     throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
   }
   /**
@@ -35755,11 +36400,17 @@ ${trimmedOutput.slice(0, 200)}`);
     const state = stepStates.get(step.name);
     if (!state)
       throw new Error(`Step state not found: ${step.name}`);
+    let lastExitCode;
+    let lastExitSignal;
     this.checkAborted();
     state.row.status = "running";
+    state.row.error = void 0;
+    state.row.completionReason = void 0;
     state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.db.updateStep(state.row.id, {
       status: "running",
+      error: void 0,
+      completionReason: void 0,
       startedAt: state.row.startedAt,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -35771,6 +36422,7 @@ ${trimmedOutput.slice(0, 200)}`);
     const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path8.default.join(".worktrees", step.name);
     const createBranch = step.createBranch !== false;
     const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
+    this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
     if (!branch) {
       const errorMsg = 'Worktree step missing required "branch" field';
       await this.markStepFailed(state, errorMsg, runId);
@@ -35802,6 +36454,10 @@ ${trimmedOutput.slice(0, 200)}`);
         await this.markStepFailed(state, errorMsg, runId);
         throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
       }
+      let commandStdout = "";
+      let commandStderr = "";
+      let commandExitCode;
+      let commandExitSignal;
       const output = await new Promise((resolve3, reject) => {
         const child = (0, import_node_child_process3.spawn)("sh", ["-c", worktreeCmd], {
           stdio: "pipe",
@@ -35834,7 +36490,7 @@ ${trimmedOutput.slice(0, 200)}`);
         child.stderr?.on("data", (chunk) => {
           stderrChunks.push(chunk.toString());
         });
-        child.on("close", (code) => {
+        child.on("close", (code, signal) => {
           if (timer)
             clearTimeout(timer);
           if (abortHandler && abortSignal) {
@@ -35848,7 +36504,13 @@ ${trimmedOutput.slice(0, 200)}`);
             reject(new Error(`Step "${step.name}" timed out (no step timeout set, check global swarm.timeoutMs)`));
             return;
           }
+          commandStdout = stdoutChunks.join("");
           const stderr = stderrChunks.join("");
+          commandStderr = stderr;
+          commandExitCode = code ?? void 0;
+          commandExitSignal = signal ?? void 0;
+          lastExitCode = commandExitCode;
+          lastExitSignal = commandExitSignal;
           if (code !== 0 && code !== null) {
             reject(new Error(`git worktree add failed with exit code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
             return;
@@ -35864,6 +36526,11 @@ ${trimmedOutput.slice(0, 200)}`);
           reject(new Error(`Failed to execute git worktree command: ${err.message}`));
         });
       });
+      this.captureStepTerminalEvidence(step.name, {
+        stdout: commandStdout || output,
+        stderr: commandStderr,
+        combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
+      }, { exitCode: commandExitCode, exitSignal: commandExitSignal });
       state.row.status = "completed";
       state.row.output = output;
       state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -35877,10 +36544,19 @@ ${trimmedOutput.slice(0, 200)}`);
       this.emit({ type: "step:completed", runId, stepName: step.name, output });
       this.postToChannel(`**[${step.name}]** Worktree created at: ${output}
   Branch: ${branch}${!branchExists && createBranch ? " (created)" : ""}`);
+      this.recordStepToolSideEffect(step.name, {
+        type: "worktree_created",
+        detail: `Worktree created at ${output}`,
+        raw: { branch, createdBranch: !branchExists && createBranch }
+      });
+      this.finalizeStepEvidence(step.name, "completed", state.row.completedAt);
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
-      await this.markStepFailed(state, errorMsg, runId);
+      await this.markStepFailed(state, errorMsg, runId, {
+        exitCode: lastExitCode,
+        exitSignal: lastExitSignal
+      });
       throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
     }
   }
@@ -35901,8 +36577,9 @@ ${trimmedOutput.slice(0, 200)}`);
     }
     const specialistDef = _WorkflowRunner.resolveAgentDef(rawAgentDef);
     const usesOwnerFlow = specialistDef.interactive !== false;
-    const ownerDef = usesOwnerFlow ? this.resolveAutoStepOwner(specialistDef, agentMap) : specialistDef;
-    const reviewDef = usesOwnerFlow ? this.resolveAutoReviewAgent(ownerDef, agentMap) : void 0;
+    const usesAutoHardening = usesOwnerFlow && !this.isExplicitInteractiveWorker(specialistDef);
+    const ownerDef = usesAutoHardening ? this.resolveAutoStepOwner(specialistDef, agentMap) : specialistDef;
+    const reviewDef = usesAutoHardening ? this.resolveAutoReviewAgent(ownerDef, agentMap) : void 0;
     const supervised = {
       specialist: specialistDef,
       owner: ownerDef,
@@ -35915,6 +36592,7 @@ ${trimmedOutput.slice(0, 200)}`);
     let lastError;
     let lastExitCode;
     let lastExitSignal;
+    let lastCompletionReason;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       this.checkAborted();
       lastExitCode = void 0;
@@ -35922,6 +36600,11 @@ ${trimmedOutput.slice(0, 200)}`);
       if (attempt > 0) {
         this.emit({ type: "step:retrying", runId, stepName: step.name, attempt });
         this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${maxRetries + 1})`);
+        this.recordStepToolSideEffect(step.name, {
+          type: "retry",
+          detail: `Retrying attempt ${attempt + 1}/${maxRetries + 1}`,
+          raw: { attempt, maxRetries }
+        });
         state.row.retryCount = attempt;
         await this.db.updateStep(state.row.id, {
           retryCount: attempt,
@@ -35932,14 +36615,19 @@ ${trimmedOutput.slice(0, 200)}`);
       }
       try {
         state.row.status = "running";
+        state.row.error = void 0;
+        state.row.completionReason = void 0;
         state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.db.updateStep(state.row.id, {
           status: "running",
+          error: void 0,
+          completionReason: void 0,
           startedAt: state.row.startedAt,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         this.emit({ type: "step:started", runId, stepName: step.name });
-        this.postToChannel(`**[${step.name}]** Started (owner: ${ownerDef.name}, specialist: ${specialistDef.name})`);
+        this.log(`[${step.name}] Started (owner: ${ownerDef.name}, specialist: ${specialistDef.name})`);
+        this.initializeStepSignalParticipants(step.name, ownerDef.name, specialistDef.name);
         await this.trajectory?.stepStarted(step, ownerDef.name, {
           role: usesDedicatedOwner ? "owner" : "specialist",
           owner: ownerDef.name,
@@ -35984,33 +36672,83 @@ ${resolvedTask}`;
         };
         const effectiveSpecialist = applyStepWorkdir(specialistDef);
         const effectiveOwner = applyStepWorkdir(ownerDef);
+        const effectiveReviewer = reviewDef ? applyStepWorkdir(reviewDef) : void 0;
+        this.beginStepEvidence(step.name, [
+          this.resolveAgentCwd(effectiveSpecialist),
+          this.resolveAgentCwd(effectiveOwner),
+          effectiveReviewer ? this.resolveAgentCwd(effectiveReviewer) : void 0
+        ], state.row.startedAt);
         let specialistOutput;
         let ownerOutput;
         let ownerElapsed;
+        let completionReason;
         if (usesDedicatedOwner) {
           const result = await this.executeSupervisedAgentStep(step, { specialist: effectiveSpecialist, owner: effectiveOwner, reviewer: reviewDef }, resolvedTask, timeoutMs);
           specialistOutput = result.specialistOutput;
           ownerOutput = result.ownerOutput;
           ownerElapsed = result.ownerElapsed;
+          completionReason = result.completionReason;
         } else {
           const ownerTask = this.injectStepOwnerContract(step, resolvedTask, effectiveOwner, effectiveSpecialist);
+          const explicitInteractiveWorker = this.isExplicitInteractiveWorker(effectiveOwner);
+          let explicitWorkerHandle;
+          let explicitWorkerCompleted = false;
+          let explicitWorkerOutput = "";
           this.log(`[${step.name}] Spawning owner "${effectiveOwner.name}" (cli: ${effectiveOwner.cli})${step.workdir ? ` [workdir: ${step.workdir}]` : ""}`);
           const resolvedStep = { ...step, task: ownerTask };
           const ownerStartTime = Date.now();
-          const spawnResult = this.executor ? await this.executor.executeAgentStep(resolvedStep, effectiveOwner, ownerTask, timeoutMs) : await this.spawnAndWait(effectiveOwner, resolvedStep, timeoutMs);
+          const spawnResult = this.executor ? await this.executor.executeAgentStep(resolvedStep, effectiveOwner, ownerTask, timeoutMs) : await this.spawnAndWait(effectiveOwner, resolvedStep, timeoutMs, {
+            evidenceStepName: step.name,
+            evidenceRole: usesOwnerFlow ? "owner" : "specialist",
+            logicalName: effectiveOwner.name,
+            onSpawned: explicitInteractiveWorker ? ({ agent }) => {
+              explicitWorkerHandle = agent;
+            } : void 0,
+            onChunk: explicitInteractiveWorker ? ({ chunk }) => {
+              explicitWorkerOutput += _WorkflowRunner.stripAnsi(chunk);
+              if (!explicitWorkerCompleted && this.hasExplicitInteractiveWorkerCompletionEvidence(step, explicitWorkerOutput, ownerTask, resolvedTask)) {
+                explicitWorkerCompleted = true;
+                void explicitWorkerHandle?.release().catch(() => void 0);
+              }
+            } : void 0
+          });
           const output = typeof spawnResult === "string" ? spawnResult : spawnResult.output;
           lastExitCode = typeof spawnResult === "string" ? void 0 : spawnResult.exitCode;
           lastExitSignal = typeof spawnResult === "string" ? void 0 : spawnResult.exitSignal;
           ownerElapsed = Date.now() - ownerStartTime;
           this.log(`[${step.name}] Owner "${effectiveOwner.name}" exited`);
           if (usesOwnerFlow) {
-            this.assertOwnerCompletionMarker(step, output, ownerTask);
+            try {
+              const completionDecision = this.resolveOwnerCompletionDecision(step, output, output, ownerTask, resolvedTask);
+              completionReason = completionDecision.completionReason;
+            } catch (error48) {
+              const canUseVerificationFallback = !usesDedicatedOwner && step.verification && error48 instanceof WorkflowCompletionError && error48.completionReason === "failed_no_evidence";
+              if (!canUseVerificationFallback) {
+                throw error48;
+              }
+            }
           }
           specialistOutput = output;
           ownerOutput = output;
         }
-        if (step.verification) {
-          this.runVerification(step.verification, specialistOutput, step.name, effectiveOwner.interactive === false ? void 0 : resolvedTask);
+        if (!usesOwnerFlow) {
+          const explicitOwnerDecision = this.parseOwnerDecision(step, ownerOutput, false);
+          if (explicitOwnerDecision?.decision === "INCOMPLETE_RETRY") {
+            throw new WorkflowCompletionError(`Step "${step.name}" owner requested retry${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "retry_requested_by_owner");
+          }
+          if (explicitOwnerDecision?.decision === "INCOMPLETE_FAIL") {
+            throw new WorkflowCompletionError(`Step "${step.name}" owner marked the step incomplete${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "failed_owner_decision");
+          }
+          if (explicitOwnerDecision?.decision === "NEEDS_CLARIFICATION") {
+            throw new WorkflowCompletionError(`Step "${step.name}" owner requested clarification before completion${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "retry_requested_by_owner");
+          }
+        }
+        if (step.verification && (!usesOwnerFlow || !usesDedicatedOwner) && !completionReason) {
+          const verificationResult = this.runVerification(step.verification, specialistOutput, step.name, effectiveOwner.interactive === false ? void 0 : resolvedTask);
+          completionReason = verificationResult.completionReason;
+        }
+        if (completionReason === "retry_requested_by_owner") {
+          throw new WorkflowCompletionError(`Step "${step.name}" owner requested another attempt`, "retry_requested_by_owner");
         }
         let combinedOutput = specialistOutput;
         if (usesOwnerFlow && reviewDef) {
@@ -36020,19 +36758,26 @@ ${resolvedTask}`;
         }
         state.row.status = "completed";
         state.row.output = combinedOutput;
+        state.row.completionReason = completionReason;
         state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.db.updateStep(state.row.id, {
           status: "completed",
           output: combinedOutput,
+          completionReason,
           completedAt: state.row.completedAt,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         await this.persistStepOutput(runId, step.name, combinedOutput);
         this.emit({ type: "step:completed", runId, stepName: step.name, output: combinedOutput, exitCode: lastExitCode, exitSignal: lastExitSignal });
+        this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, completionReason);
         await this.trajectory?.stepCompleted(step, combinedOutput, attempt + 1);
         return;
       } catch (err) {
         lastError = err instanceof Error ? err.message : String(err);
+        lastCompletionReason = err instanceof WorkflowCompletionError ? err.completionReason : void 0;
+        if (lastCompletionReason === "retry_requested_by_owner" && attempt >= maxRetries) {
+          lastError = this.buildOwnerRetryBudgetExceededMessage(step.name, maxRetries, lastError);
+        }
         if (err instanceof SpawnExitError) {
           lastExitCode = err.exitCode;
           lastExitSignal = err.exitSignal;
@@ -36054,9 +36799,19 @@ ${resolvedTask}`;
     await this.markStepFailed(state, lastError ?? "Unknown error", runId, {
       exitCode: lastExitCode,
       exitSignal: lastExitSignal
-    });
+    }, lastCompletionReason);
     throw new Error(`Step "${step.name}" failed after ${maxRetries} retries: ${lastError ?? "Unknown error"}`);
   }
+  buildOwnerRetryBudgetExceededMessage(stepName, maxRetries, ownerDecisionError) {
+    const attempts = maxRetries + 1;
+    const prefix = `Step "${stepName}" `;
+    const normalizedDecision = ownerDecisionError?.startsWith(prefix) ? ownerDecisionError.slice(prefix.length).trim() : ownerDecisionError?.trim();
+    const decisionSuffix = normalizedDecision ? ` Latest owner decision: ${normalizedDecision}` : "";
+    if (maxRetries === 0) {
+      return `Step "${stepName}" owner requested another attempt, but no retries are configured (maxRetries=0). Configure retries > 0 to allow OWNER_DECISION: INCOMPLETE_RETRY.` + decisionSuffix;
+    }
+    return `Step "${stepName}" owner requested another attempt after ${attempts} total attempts, but the retry budget is exhausted (maxRetries=${maxRetries}).` + decisionSuffix;
+  }
   injectStepOwnerContract(step, resolvedTask, ownerDef, specialistDef) {
     if (ownerDef.interactive === false)
       return resolvedTask;
@@ -36068,12 +36823,18 @@ STEP OWNER CONTRACT:
 - You are the accountable owner for step "${step.name}".
 ` + (specialistNote ? `- ${specialistNote}
 ` : "") + `- If you delegate, you must still verify completion yourself.
-- Before exiting, provide an explicit completion line: STEP_COMPLETE:${step.name}
+- Preferred final decision format:
+  OWNER_DECISION: <one of COMPLETE, INCOMPLETE_RETRY, INCOMPLETE_FAIL, NEEDS_CLARIFICATION>
+  REASON: <one sentence>
+- Legacy completion marker still supported: STEP_COMPLETE:${step.name}
 - Then self-terminate immediately with /exit.`;
   }
   buildOwnerSupervisorTask(step, originalTask, supervised, workerRuntimeName) {
     const verificationGuide = this.buildSupervisorVerificationGuide(step.verification);
     const channelLine = this.channel ? `#${this.channel}` : "(workflow channel unavailable)";
+    const channelContract = this.channel ? `- Prefer Relaycast/group-chat handoff signals over terminal sentinels: wait for the worker to post \`WORKER_DONE: <brief summary>\` in ${channelLine}
+- When you have validated the handoff, post \`LEAD_DONE: <brief summary>\` to ${channelLine} before you exit
+` : "";
     return `You are the step owner/supervisor for step "${step.name}".
 
 Worker: ${supervised.specialist.name} (runtime: ${workerRuntimeName}) on ${channelLine}
@@ -36085,9 +36846,23 @@ How to verify completion:
 - Watch ${channelLine} for the worker's progress messages and mirrored PTY output
 - Check file changes: run \`git diff --stat\` or inspect expected files directly
 - Ask the worker directly on ${channelLine} if you need a status update
-` + verificationGuide + `
-When you're satisfied the work is done correctly:
-Output exactly: STEP_COMPLETE:${step.name}`;
+` + channelContract + verificationGuide + `
+When you have enough evidence, return:
+OWNER_DECISION: <one of COMPLETE, INCOMPLETE_RETRY, INCOMPLETE_FAIL, NEEDS_CLARIFICATION>
+REASON: <one sentence>
+Legacy completion marker still supported: STEP_COMPLETE:${step.name}`;
+  }
+  buildWorkerHandoffTask(step, originalTask, supervised) {
+    if (!this.channel)
+      return originalTask;
+    return `${originalTask}
+
+---
+WORKER COMPLETION CONTRACT:
+- You are handing work off to owner "${supervised.owner.name}" for step "${step.name}".
+- When your work is ready for review, post to #${this.channel}: \`WORKER_DONE: <brief summary>\`
+- Do not rely on terminal output alone for handoff; use the workflow group chat signal above.
+- After posting your handoff signal, self-terminate with /exit unless the owner asks for follow-up.`;
   }
   buildSupervisorVerificationGuide(verification) {
     if (!verification)
@@ -36111,8 +36886,9 @@ Output exactly: STEP_COMPLETE:${step.name}`;
   }
   async executeSupervisedAgentStep(step, supervised, resolvedTask, timeoutMs) {
     if (this.executor) {
+      const specialistTask2 = this.buildWorkerHandoffTask(step, resolvedTask, supervised);
       const supervisorTask2 = this.buildOwnerSupervisorTask(step, resolvedTask, supervised, supervised.specialist.name);
-      const specialistStep2 = { ...step, task: resolvedTask };
+      const specialistStep2 = { ...step, task: specialistTask2 };
       const ownerStep2 = {
         ...step,
         name: `${step.name}-owner`,
@@ -36120,15 +36896,20 @@ Output exactly: STEP_COMPLETE:${step.name}`;
         task: supervisorTask2
       };
       this.log(`[${step.name}] Spawning specialist "${supervised.specialist.name}" and owner "${supervised.owner.name}"`);
-      const specialistPromise = this.executor.executeAgentStep(specialistStep2, supervised.specialist, resolvedTask, timeoutMs);
+      const specialistPromise = this.executor.executeAgentStep(specialistStep2, supervised.specialist, specialistTask2, timeoutMs);
       const specialistSettled = specialistPromise.catch(() => void 0);
       try {
         const ownerStartTime2 = Date.now();
         const ownerOutput = await this.executor.executeAgentStep(ownerStep2, supervised.owner, supervisorTask2, timeoutMs);
         const ownerElapsed = Date.now() - ownerStartTime2;
-        this.assertOwnerCompletionMarker(step, ownerOutput, supervisorTask2);
         const specialistOutput = await specialistPromise;
-        return { specialistOutput, ownerOutput, ownerElapsed };
+        const completionDecision = this.resolveOwnerCompletionDecision(step, ownerOutput, specialistOutput, supervisorTask2, resolvedTask);
+        return {
+          specialistOutput,
+          ownerOutput,
+          ownerElapsed,
+          completionReason: completionDecision.completionReason
+        };
       } catch (error48) {
         await specialistSettled;
         throw error48;
@@ -36144,10 +36925,14 @@ Output exactly: STEP_COMPLETE:${step.name}`;
       resolveWorkerSpawn = resolve3;
       rejectWorkerSpawn = reject;
     });
-    const specialistStep = { ...step, task: resolvedTask };
+    const specialistTask = this.buildWorkerHandoffTask(step, resolvedTask, supervised);
+    const specialistStep = { ...step, task: specialistTask };
     this.log(`[${step.name}] Spawning specialist "${supervised.specialist.name}" (cli: ${supervised.specialist.cli})`);
     const workerPromise = this.spawnAndWait(supervised.specialist, specialistStep, timeoutMs, {
       agentNameSuffix: "worker",
+      evidenceStepName: step.name,
+      evidenceRole: "worker",
+      logicalName: supervised.specialist.name,
       onSpawned: ({ actualName, agent }) => {
         workerHandle = agent;
         workerRuntimeName = actualName;
@@ -36162,7 +36947,7 @@ Output exactly: STEP_COMPLETE:${step.name}`;
         }
       },
       onChunk: ({ agentName, chunk }) => {
-        this.forwardAgentChunkToChannel(step.name, "Worker", agentName, chunk);
+        this.forwardAgentChunkToChannel(step.name, "Worker", agentName, chunk, supervised.specialist.name);
       }
     }).catch((error48) => {
       if (!workerSpawned) {
@@ -36174,13 +36959,23 @@ Output exactly: STEP_COMPLETE:${step.name}`;
     const workerSettled = workerPromise.catch(() => void 0);
     workerPromise.then((result) => {
       workerReleased = true;
-      this.postToChannel(`**[${step.name}]** Worker \`${workerRuntimeName}\` exited`);
+      this.log(`[${step.name}] Worker ${workerRuntimeName} exited`);
+      this.recordStepToolSideEffect(step.name, {
+        type: "worker_exit",
+        detail: `Worker ${workerRuntimeName} exited`,
+        raw: { worker: workerRuntimeName, exitCode: result.exitCode, exitSignal: result.exitSignal }
+      });
       if (step.verification?.type === "output_contains" && result.output.includes(step.verification.value)) {
-        this.postToChannel(`**[${step.name}]** Verification gate observed: output contains ${JSON.stringify(step.verification.value)}`);
+        this.log(`[${step.name}] Verification gate observed: output contains ${JSON.stringify(step.verification.value)}`);
       }
     }).catch((error48) => {
       const message = error48 instanceof Error ? error48.message : String(error48);
       this.postToChannel(`**[${step.name}]** Worker \`${workerRuntimeName}\` exited with error: ${message}`);
+      this.recordStepToolSideEffect(step.name, {
+        type: "worker_error",
+        detail: `Worker ${workerRuntimeName} exited with error: ${message}`,
+        raw: { worker: workerRuntimeName, error: message }
+      });
     });
     await workerReady;
     const supervisorTask = this.buildOwnerSupervisorTask(step, resolvedTask, supervised, workerRuntimeName);
@@ -36195,6 +36990,9 @@ Output exactly: STEP_COMPLETE:${step.name}`;
     try {
       const ownerResultObj = await this.spawnAndWait(supervised.owner, ownerStep, timeoutMs, {
         agentNameSuffix: "owner",
+        evidenceStepName: step.name,
+        evidenceRole: "owner",
+        logicalName: supervised.owner.name,
         onSpawned: ({ actualName }) => {
           this.supervisedRuntimeAgents.set(actualName, {
             stepName: step.name,
@@ -36209,9 +37007,14 @@ Output exactly: STEP_COMPLETE:${step.name}`;
       const ownerElapsed = Date.now() - ownerStartTime;
       const ownerOutput = ownerResultObj.output;
       this.log(`[${step.name}] Owner "${supervised.owner.name}" exited`);
-      this.assertOwnerCompletionMarker(step, ownerOutput, supervisorTask);
       const specialistOutput = (await workerPromise).output;
-      return { specialistOutput, ownerOutput, ownerElapsed };
+      const completionDecision = this.resolveOwnerCompletionDecision(step, ownerOutput, specialistOutput, supervisorTask, resolvedTask);
+      return {
+        specialistOutput,
+        ownerOutput,
+        ownerElapsed,
+        completionReason: completionDecision.completionReason
+      };
     } catch (error48) {
       const message = error48 instanceof Error ? error48.message : String(error48);
       if (!workerReleased && workerHandle) {
@@ -36224,10 +37027,16 @@ Output exactly: STEP_COMPLETE:${step.name}`;
       throw error48;
     }
   }
-  forwardAgentChunkToChannel(stepName, roleLabel, agentName, chunk) {
-    const lines = _WorkflowRunner.stripAnsi(chunk).split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 3);
+  forwardAgentChunkToChannel(stepName, roleLabel, agentName, chunk, sender) {
+    const lines = _WorkflowRunner.scrubForChannel(chunk).split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 3);
     for (const line of lines) {
-      this.postToChannel(`**[${stepName}]** ${roleLabel} \`${agentName}\`: ${line.slice(0, 280)}`);
+      this.postToChannel(`**[${stepName}]** ${roleLabel} \`${agentName}\`: ${line.slice(0, 280)}`, {
+        stepName,
+        sender,
+        actor: agentName,
+        role: roleLabel,
+        origin: "forwarded_chunk"
+      });
     }
   }
   async recordOwnerMonitoringChunk(step, ownerDef, chunk) {
@@ -36242,6 +37051,11 @@ Output exactly: STEP_COMPLETE:${step.name}`;
     if (/STEP_COMPLETE:/i.test(stripped))
       details.push("Declared the step complete");
     for (const detail of details) {
+      this.recordStepToolSideEffect(step.name, {
+        type: "owner_monitoring",
+        detail,
+        raw: { output: stripped.slice(0, 240), owner: ownerDef.name }
+      });
       await this.trajectory?.ownerMonitoringEvent(step.name, ownerDef.name, detail, {
         output: stripped.slice(0, 240)
       });
@@ -36280,6 +37094,7 @@ Output exactly: STEP_COMPLETE:${step.name}`;
   }
   resolveAutoReviewAgent(ownerDef, agentMap) {
     const allDefs = [...agentMap.values()].map((d) => _WorkflowRunner.resolveAgentDef(d));
+    const eligible = (def) => def.name !== ownerDef.name && !this.isExplicitInteractiveWorker(def);
     const isReviewer = (def) => {
       const roleLC = def.role?.toLowerCase() ?? "";
       const nameLC = def.name.toLowerCase();
@@ -36298,28 +37113,187 @@ Output exactly: STEP_COMPLETE:${step.name}`;
         return 2;
       return isReviewer(def) ? 1 : 0;
     };
-    const dedicated = allDefs.filter((d) => d.name !== ownerDef.name && isReviewer(d)).sort((a, b) => reviewerPriority(b) - reviewerPriority(a) || a.name.localeCompare(b.name))[0];
+    const dedicated = allDefs.filter((d) => eligible(d) && isReviewer(d)).sort((a, b) => reviewerPriority(b) - reviewerPriority(a) || a.name.localeCompare(b.name))[0];
     if (dedicated)
       return dedicated;
-    const alternate = allDefs.find((d) => d.name !== ownerDef.name && d.interactive !== false);
+    const alternate = allDefs.find((d) => eligible(d) && d.interactive !== false);
     if (alternate)
       return alternate;
     return ownerDef;
   }
-  assertOwnerCompletionMarker(step, output, injectedTaskText) {
+  isExplicitInteractiveWorker(agentDef) {
+    return agentDef.preset === "worker" && agentDef.interactive !== false;
+  }
+  resolveOwnerCompletionDecision(step, ownerOutput, specialistOutput, injectedTaskText, verificationTaskText) {
+    const hasMarker = this.hasOwnerCompletionMarker(step, ownerOutput, injectedTaskText);
+    const explicitOwnerDecision = this.parseOwnerDecision(step, ownerOutput, false);
+    if (explicitOwnerDecision?.decision === "INCOMPLETE_RETRY") {
+      throw new WorkflowCompletionError(`Step "${step.name}" owner requested retry${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "retry_requested_by_owner");
+    }
+    if (explicitOwnerDecision?.decision === "INCOMPLETE_FAIL") {
+      throw new WorkflowCompletionError(`Step "${step.name}" owner marked the step incomplete${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "failed_owner_decision");
+    }
+    if (explicitOwnerDecision?.decision === "NEEDS_CLARIFICATION") {
+      throw new WorkflowCompletionError(`Step "${step.name}" owner requested clarification before completion${explicitOwnerDecision.reason ? `: ${explicitOwnerDecision.reason}` : ""}`, "retry_requested_by_owner");
+    }
+    const verificationResult = step.verification ? this.runVerification(step.verification, specialistOutput, step.name, verificationTaskText, {
+      allowFailure: true,
+      completionMarkerFound: hasMarker
+    }) : { passed: false };
+    if (verificationResult.error) {
+      throw new WorkflowCompletionError(`Step "${step.name}" verification failed and no owner decision or evidence established completion: ${verificationResult.error}`, "failed_verification");
+    }
+    if (explicitOwnerDecision?.decision === "COMPLETE") {
+      if (!hasMarker) {
+        this.log(`[${step.name}] Structured OWNER_DECISION completed the step without legacy STEP_COMPLETE marker`);
+      }
+      return {
+        completionReason: "completed_by_owner_decision",
+        ownerDecision: explicitOwnerDecision.decision,
+        reason: explicitOwnerDecision.reason
+      };
+    }
+    if (verificationResult.passed) {
+      return { completionReason: "completed_verified" };
+    }
+    const ownerDecision = this.parseOwnerDecision(step, ownerOutput, hasMarker);
+    if (ownerDecision?.decision === "COMPLETE") {
+      return {
+        completionReason: "completed_by_owner_decision",
+        ownerDecision: ownerDecision.decision,
+        reason: ownerDecision.reason
+      };
+    }
+    if (!explicitOwnerDecision) {
+      const evidenceReason = this.judgeOwnerCompletionByEvidence(step.name, ownerOutput);
+      if (evidenceReason) {
+        if (!hasMarker) {
+          this.log(`[${step.name}] Evidence-based completion resolved without legacy STEP_COMPLETE marker`);
+        }
+        return {
+          completionReason: "completed_by_evidence",
+          reason: evidenceReason
+        };
+      }
+    }
+    const processExitFallback = this.tryProcessExitFallback(step, specialistOutput, verificationTaskText, ownerOutput);
+    if (processExitFallback) {
+      this.log(`[${step.name}] Completion inferred from clean process exit (code 0)` + (step.verification ? " + verification passed" : "") + " \u2014 no coordination signal was required");
+      return processExitFallback;
+    }
+    throw new WorkflowCompletionError(`Step "${step.name}" owner completion decision missing: no OWNER_DECISION, legacy STEP_COMPLETE marker, or evidence-backed completion signal`, "failed_no_evidence");
+  }
+  hasExplicitInteractiveWorkerCompletionEvidence(step, output, injectedTaskText, verificationTaskText) {
+    try {
+      this.resolveOwnerCompletionDecision(step, output, output, injectedTaskText, verificationTaskText);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasOwnerCompletionMarker(step, output, injectedTaskText) {
     const marker = `STEP_COMPLETE:${step.name}`;
     const taskHasMarker = injectedTaskText.includes(marker);
     const first = output.indexOf(marker);
     if (first === -1) {
-      throw new Error(`Step "${step.name}" owner completion marker missing: "${marker}"`);
+      return false;
     }
-    const outputLikelyContainsInjectedPrompt = output.includes("STEP OWNER CONTRACT") || output.includes("Output exactly: STEP_COMPLETE:");
+    const outputLikelyContainsInjectedPrompt = output.includes("STEP OWNER CONTRACT") || output.includes("Preferred final decision format") || output.includes("Legacy completion marker still supported") || output.includes("Output exactly: STEP_COMPLETE:");
     if (taskHasMarker && outputLikelyContainsInjectedPrompt) {
-      const hasSecond = output.includes(marker, first + marker.length);
-      if (!hasSecond) {
-        throw new Error(`Step "${step.name}" owner completion marker missing in agent response: "${marker}"`);
-      }
+      return output.includes(marker, first + marker.length);
+    }
+    return true;
+  }
+  parseOwnerDecision(step, ownerOutput, hasMarker) {
+    const decisionPattern = /OWNER_DECISION:\s*(COMPLETE|INCOMPLETE_RETRY|INCOMPLETE_FAIL|NEEDS_CLARIFICATION)\b/gi;
+    const decisionMatches = [...ownerOutput.matchAll(decisionPattern)];
+    const outputLikelyContainsEchoedPrompt = ownerOutput.includes("STEP OWNER CONTRACT") || ownerOutput.includes("Preferred final decision format") || ownerOutput.includes("one of COMPLETE, INCOMPLETE_RETRY") || ownerOutput.includes("COMPLETE|INCOMPLETE_RETRY");
+    if (decisionMatches.length === 0) {
+      if (!hasMarker)
+        return null;
+      return {
+        decision: "COMPLETE",
+        reason: `Legacy completion marker observed: STEP_COMPLETE:${step.name}`
+      };
+    }
+    const realMatches = outputLikelyContainsEchoedPrompt ? decisionMatches.filter((m) => {
+      const lineStart = ownerOutput.lastIndexOf("\n", m.index) + 1;
+      const lineEnd = ownerOutput.indexOf("\n", m.index);
+      const line = ownerOutput.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
+      return !line.includes("COMPLETE|INCOMPLETE_RETRY");
+    }) : decisionMatches;
+    const decisionMatch = realMatches.length > 0 ? realMatches[realMatches.length - 1] : decisionMatches[decisionMatches.length - 1];
+    const decision = decisionMatch?.[1]?.toUpperCase();
+    if (decision !== "COMPLETE" && decision !== "INCOMPLETE_RETRY" && decision !== "INCOMPLETE_FAIL" && decision !== "NEEDS_CLARIFICATION") {
+      return null;
+    }
+    const reasonPattern = /(?:^|\n)REASON:\s*(.+)/gi;
+    const reasonMatches = [...ownerOutput.matchAll(reasonPattern)];
+    const reasonMatch = outputLikelyContainsEchoedPrompt && reasonMatches.length > 1 ? reasonMatches[reasonMatches.length - 1] : reasonMatches[0];
+    const reason = reasonMatch?.[1]?.trim();
+    return {
+      decision,
+      reason: reason && reason !== "<one sentence>" ? reason : void 0
+    };
+  }
+  stripEchoedPromptLines(output, patterns) {
+    return output.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => patterns.every((pattern) => !pattern.test(line))).join("\n");
+  }
+  firstMeaningfulLine(output) {
+    return output.split("\n").map((line) => line.trim()).find(Boolean);
+  }
+  judgeOwnerCompletionByEvidence(stepName, ownerOutput) {
+    if (/OWNER_DECISION:\s*(?:INCOMPLETE_RETRY|INCOMPLETE_FAIL|NEEDS_CLARIFICATION)\b/i.test(ownerOutput)) {
+      return null;
     }
+    const sanitized = this.stripEchoedPromptLines(ownerOutput, [
+      /^STEP OWNER CONTRACT:?$/i,
+      /^Preferred final decision format:?$/i,
+      /^OWNER_DECISION:\s*(?:COMPLETE\|INCOMPLETE_RETRY|<one of COMPLETE, INCOMPLETE_RETRY)/i,
+      /^REASON:\s*<one sentence>$/i,
+      /^Legacy completion marker still supported:/i,
+      /^STEP_COMPLETE:/i
+    ]);
+    if (!sanitized)
+      return null;
+    const hasExplicitSelfRelease = /Calling\s+(?:[\w.-]+\.)?remove_agent\(\{[^<\n]*"reason":"task completed"/i.test(sanitized);
+    const hasPositiveConclusion = /\b(complete(?:d)?|done|verified|looks correct|safe handoff|artifact verified)\b/i.test(sanitized) || /\bartifacts?\b.*\b(correct|verified|complete)\b/i.test(sanitized) || hasExplicitSelfRelease;
+    const evidence = this.getStepCompletionEvidence(stepName);
+    const hasValidatedCoordinationSignal = evidence?.coordinationSignals.some((signal) => signal.kind === "worker_done" || signal.kind === "lead_done" || signal.kind === "verification_passed" || signal.kind === "process_exit" && signal.value === "0") ?? false;
+    const hasValidatedInspectionSignal = evidence?.toolSideEffects.some((effect) => effect.type === "owner_monitoring" && (/Checked git diff stats/i.test(effect.detail) || /Listed files for verification/i.test(effect.detail))) ?? false;
+    const hasEvidenceSignal = hasValidatedCoordinationSignal || hasValidatedInspectionSignal;
+    if (!hasPositiveConclusion || !hasEvidenceSignal) {
+      return null;
+    }
+    return this.firstMeaningfulLine(sanitized) ?? "Evidence-backed completion";
+  }
+  /**
+   * Process-exit fallback: when agent exits with code 0 but posts no coordination
+   * signal, check if verification passes (or no verification is configured) and
+   * infer completion. This is the key mechanism for reducing agent compliance
+   * dependence — the runner trusts a clean exit + passing verification over
+   * requiring exact signal text.
+   */
+  tryProcessExitFallback(step, specialistOutput, verificationTaskText, ownerOutput) {
+    const gracePeriodMs = this.currentConfig?.swarm.completionGracePeriodMs ?? 5e3;
+    if (gracePeriodMs === 0)
+      return null;
+    if (ownerOutput && /OWNER_DECISION:\s*(?:INCOMPLETE_RETRY|INCOMPLETE_FAIL|NEEDS_CLARIFICATION)\b/i.test(ownerOutput)) {
+      return null;
+    }
+    const evidence = this.getStepCompletionEvidence(step.name);
+    const hasCleanExit = evidence?.coordinationSignals.some((signal) => signal.kind === "process_exit" && signal.value === "0") ?? false;
+    if (!hasCleanExit)
+      return null;
+    if (step.verification) {
+      const verificationResult = this.runVerification(step.verification, specialistOutput, step.name, verificationTaskText, { allowFailure: true });
+      if (!verificationResult.passed)
+        return null;
+    }
+    return {
+      completionReason: "completed_by_process_exit",
+      reason: `Process exited with code 0${step.verification ? " and verification passed" : ""} \u2014 coordination signal not required`
+    };
   }
   async runStepReviewGate(step, resolvedTask, specialistOutput, ownerOutput, ownerDef, reviewerDef, timeoutMs) {
     const reviewSnippetMax = 12e3;
@@ -36365,7 +37339,17 @@ Then output /exit.`;
     };
     await this.trajectory?.registerAgent(reviewerDef.name, "reviewer");
     this.postToChannel(`**[${step.name}]** Review started (reviewer: ${reviewerDef.name})`);
+    this.recordStepToolSideEffect(step.name, {
+      type: "review_started",
+      detail: `Review started with ${reviewerDef.name}`,
+      raw: { reviewer: reviewerDef.name }
+    });
     const emitReviewCompleted = async (decision, reason) => {
+      this.recordStepToolSideEffect(step.name, {
+        type: "review_completed",
+        detail: `Review ${decision} by ${reviewerDef.name}${reason ? `: ${reason}` : ""}`,
+        raw: { reviewer: reviewerDef.name, decision, reason }
+      });
       await this.trajectory?.reviewCompleted(step.name, reviewerDef.name, decision, reason);
       this.emit({
         type: "step:review-completed",
@@ -36409,6 +37393,9 @@ Then output /exit.`;
     };
     try {
       await this.spawnAndWait(reviewerDef, reviewStep, safetyTimeoutMs, {
+        evidenceStepName: step.name,
+        evidenceRole: "reviewer",
+        logicalName: reviewerDef.name,
         onSpawned: ({ agent }) => {
           reviewerHandle = agent;
         },
@@ -36445,13 +37432,30 @@ Then output /exit.`;
     return reviewOutput;
   }
   parseReviewDecision(reviewOutput) {
+    const strict = this.parseStrictReviewDecision(reviewOutput);
+    if (strict) {
+      return strict;
+    }
+    const tolerant = this.parseTolerantReviewDecision(reviewOutput);
+    if (tolerant) {
+      return tolerant;
+    }
+    return this.judgeReviewDecisionFromEvidence(reviewOutput);
+  }
+  parseStrictReviewDecision(reviewOutput) {
     const decisionPattern = /REVIEW_DECISION:\s*(APPROVE|REJECT)/gi;
     const decisionMatches = [...reviewOutput.matchAll(decisionPattern)];
     if (decisionMatches.length === 0) {
       return null;
     }
     const outputLikelyContainsEchoedPrompt = reviewOutput.includes("Return exactly") || reviewOutput.includes("REVIEW_DECISION: APPROVE or REJECT");
-    const decisionMatch = outputLikelyContainsEchoedPrompt && decisionMatches.length > 1 ? decisionMatches[decisionMatches.length - 1] : decisionMatches[0];
+    const realReviewMatches = outputLikelyContainsEchoedPrompt ? decisionMatches.filter((m) => {
+      const lineStart = reviewOutput.lastIndexOf("\n", m.index) + 1;
+      const lineEnd = reviewOutput.indexOf("\n", m.index);
+      const line = reviewOutput.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
+      return !line.includes("APPROVE or REJECT");
+    }) : decisionMatches;
+    const decisionMatch = realReviewMatches.length > 0 ? realReviewMatches[realReviewMatches.length - 1] : decisionMatches[decisionMatches.length - 1];
     const decision = decisionMatch?.[1]?.toUpperCase();
     if (decision !== "APPROVE" && decision !== "REJECT") {
       return null;
@@ -36465,6 +37469,80 @@ Then output /exit.`;
       reason: reason && reason !== "<one sentence>" ? reason : void 0
     };
   }
+  parseTolerantReviewDecision(reviewOutput) {
+    const sanitized = this.stripEchoedPromptLines(reviewOutput, [
+      /^Return exactly:?$/i,
+      /^REVIEW_DECISION:\s*APPROVE\s+or\s+REJECT$/i,
+      /^REVIEW_REASON:\s*<one sentence>$/i
+    ]);
+    if (!sanitized) {
+      return null;
+    }
+    const lines = sanitized.split("\n").map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      const candidate = line.replace(/^REVIEW_DECISION:\s*/i, "").trim();
+      const decision2 = this.normalizeReviewDecisionCandidate(candidate);
+      if (decision2) {
+        return {
+          decision: decision2,
+          reason: this.parseReviewReason(sanitized) ?? this.firstMeaningfulLine(sanitized)
+        };
+      }
+    }
+    const decision = this.normalizeReviewDecisionCandidate(lines.join(" "));
+    if (!decision) {
+      return null;
+    }
+    return {
+      decision,
+      reason: this.parseReviewReason(sanitized) ?? this.firstMeaningfulLine(sanitized)
+    };
+  }
+  normalizeReviewDecisionCandidate(candidate) {
+    const value = candidate.trim().toLowerCase();
+    if (!value)
+      return null;
+    if (/^(approve|approved|complete|completed|pass|passed|accept|accepted|lgtm|ship it|looks good|looks fine)\b/i.test(value)) {
+      return "approved";
+    }
+    if (/^(reject|rejected|retry|retry requested|fail|failed|incomplete|needs clarification|not complete|not ready|insufficient evidence)\b/i.test(value)) {
+      return "rejected";
+    }
+    return null;
+  }
+  parseReviewReason(reviewOutput) {
+    const reasonPattern = /REVIEW_REASON:\s*(.+)/gi;
+    const reasonMatches = [...reviewOutput.matchAll(reasonPattern)];
+    const outputLikelyContainsEchoedPrompt = reviewOutput.includes("Return exactly") || reviewOutput.includes("REVIEW_DECISION: APPROVE or REJECT");
+    const reasonMatch = outputLikelyContainsEchoedPrompt && reasonMatches.length > 1 ? reasonMatches[reasonMatches.length - 1] : reasonMatches[0];
+    const reason = reasonMatch?.[1]?.trim();
+    return reason && reason !== "<one sentence>" ? reason : void 0;
+  }
+  judgeReviewDecisionFromEvidence(reviewOutput) {
+    const sanitized = this.stripEchoedPromptLines(reviewOutput, [
+      /^Return exactly:?$/i,
+      /^REVIEW_DECISION:\s*APPROVE\s+or\s+REJECT$/i,
+      /^REVIEW_REASON:\s*<one sentence>$/i
+    ]);
+    if (!sanitized) {
+      return null;
+    }
+    const hasPositiveEvidence = /\b(approved?|complete(?:d)?|verified|looks good|looks fine|safe handoff|pass(?:ed)?)\b/i.test(sanitized);
+    const hasNegativeEvidence = /\b(reject(?:ed)?|retry|fail(?:ed)?|incomplete|missing checks|insufficient evidence|not safe)\b/i.test(sanitized);
+    if (hasNegativeEvidence) {
+      return {
+        decision: "rejected",
+        reason: this.parseReviewReason(sanitized) ?? this.firstMeaningfulLine(sanitized)
+      };
+    }
+    if (!hasPositiveEvidence) {
+      return null;
+    }
+    return {
+      decision: "approved",
+      reason: this.parseReviewReason(sanitized) ?? this.firstMeaningfulLine(sanitized)
+    };
+  }
   combineStepAndReviewOutput(stepOutput, reviewOutput) {
     const primary = stepOutput.trimEnd();
     const review = reviewOutput.trim();
@@ -36671,10 +37749,18 @@ DO NOT:
           reject(new Error(`Failed to spawn ${cmd}: ${err.message}`));
         });
       });
+      this.captureStepTerminalEvidence(step.name, {}, { exitCode, exitSignal });
       return { output, exitCode, exitSignal };
     } finally {
-      const combinedOutput = stdoutChunks.join("") + stderrChunks.join("");
+      const stdout = stdoutChunks.join("");
+      const stderr = stderrChunks.join("");
+      const combinedOutput = stdout + stderr;
       this.lastFailedStepOutput.set(step.name, combinedOutput);
+      this.captureStepTerminalEvidence(step.name, {
+        stdout,
+        stderr,
+        combined: combinedOutput
+      });
       stopHeartbeat?.();
       logStream.end();
       this.unregisterWorker(agentName);
@@ -36687,6 +37773,7 @@ DO NOT:
     if (!this.relay) {
       throw new Error("AgentRelay not initialized");
     }
+    const evidenceStepName = options.evidenceStepName ?? step.name;
     const requestedName = `${step.name}${options.agentNameSuffix ? `-${options.agentNameSuffix}` : ""}-${(this.currentRunId ?? this.generateShortId()).slice(0, 8)}`;
     let agentName = requestedName;
     const role = agentDef.role?.toLowerCase() ?? "";
@@ -36714,11 +37801,17 @@ DO NOT:
     let ptyChunks = [];
     try {
       const agentCwd = this.resolveAgentCwd(agentDef);
+      const interactiveSpawnPolicy = resolveSpawnPolicy({
+        AGENT_NAME: agentName,
+        AGENT_CLI: agentDef.cli,
+        RELAY_API_KEY: this.relayApiKey ?? "workflow-runner",
+        AGENT_CHANNELS: (agentChannels ?? []).join(",")
+      });
       agent = await this.relay.spawnPty({
         name: agentName,
         cli: agentDef.cli,
         model: agentDef.constraints?.model,
-        args: [],
+        args: interactiveSpawnPolicy.args,
         channels: agentChannels,
         task: taskWithExit,
         idleThresholdSecs: agentDef.constraints?.idleThresholdSecs,
@@ -36744,16 +37837,27 @@ DO NOT:
         const oldListener = this.ptyListeners.get(oldName);
         if (oldListener) {
           this.ptyListeners.delete(oldName);
-          this.ptyListeners.set(agent.name, (chunk) => {
+          const resolvedAgentName = agent.name;
+          this.ptyListeners.set(resolvedAgentName, (chunk) => {
             const stripped = _WorkflowRunner.stripAnsi(chunk);
-            this.ptyOutputBuffers.get(agent.name)?.push(stripped);
+            this.ptyOutputBuffers.get(resolvedAgentName)?.push(stripped);
             newLogStream.write(chunk);
-            options.onChunk?.({ agentName: agent.name, chunk });
+            options.onChunk?.({ agentName: resolvedAgentName, chunk });
           });
         }
         agentName = agent.name;
       }
-      await options.onSpawned?.({ requestedName, actualName: agent.name, agent });
+      const liveAgent = agent;
+      await options.onSpawned?.({ requestedName, actualName: liveAgent.name, agent: liveAgent });
+      this.runtimeStepAgents.set(liveAgent.name, {
+        stepName: evidenceStepName,
+        role: options.evidenceRole ?? agentDef.role ?? "agent",
+        logicalName: options.logicalName ?? agentDef.name
+      });
+      const signalParticipant = this.resolveSignalParticipantKind(options.evidenceRole ?? agentDef.role ?? "agent");
+      if (signalParticipant) {
+        this.rememberStepSignalSender(evidenceStepName, signalParticipant, liveAgent.name, options.logicalName ?? agentDef.name);
+      }
       let workerPid;
       try {
         const rawAgents = await this.relay.listAgentsRaw();
@@ -36762,8 +37866,8 @@ DO NOT:
       }
       this.registerWorker(agentName, agentDef.cli, step.task ?? "", workerPid);
       if (this.relayApiKey) {
-        const agentClient = await this.registerRelaycastExternalAgent(agent.name, `Workflow agent for step "${step.name}" (${agentDef.cli})`).catch((err) => {
-          console.warn(`[WorkflowRunner] Failed to register ${agent.name} in Relaycast:`, err?.message ?? err);
+        const agentClient = await this.registerRelaycastExternalAgent(liveAgent.name, `Workflow agent for step "${step.name}" (${agentDef.cli})`).catch((err) => {
+          console.warn(`[WorkflowRunner] Failed to register ${liveAgent.name} in Relaycast:`, err?.message ?? err);
           return null;
         });
         if (agentClient) {
@@ -36775,21 +37879,23 @@ DO NOT:
         await channelAgent?.channels.invite(this.channel, agent.name).catch(() => {
         });
       }
-      this.postToChannel(`**[${step.name}]** Assigned to \`${agent.name}\``);
+      this.log(`[${step.name}] Assigned to ${agent.name}`);
       this.activeAgentHandles.set(agentName, agent);
-      exitResult = await this.waitForExitWithIdleNudging(agent, agentDef, step, timeoutMs);
+      exitResult = await this.waitForExitWithIdleNudging(agent, agentDef, step, timeoutMs, options.preserveOnIdle ?? this.shouldPreserveIdleSupervisor(agentDef, step, options.evidenceRole));
       stopHeartbeat?.();
       if (exitResult === "timeout") {
-        if (step.verification?.type === "file_exists") {
-          const verifyPath = import_node_path8.default.resolve(this.cwd, step.verification.value);
-          if ((0, import_node_fs4.existsSync)(verifyPath)) {
-            this.postToChannel(`**[${step.name}]** Agent idle after completing work \u2014 releasing`);
-            await agent.release();
-          } else {
+        let timeoutRecovered = false;
+        if (step.verification) {
+          const ptyOutput = (this.ptyOutputBuffers.get(agentName) ?? []).join("");
+          const verificationResult = this.runVerification(step.verification, ptyOutput, step.name, void 0, { allowFailure: true });
+          if (verificationResult.passed) {
+            this.log(`[${step.name}] Agent timed out but verification passed \u2014 treating as complete`);
+            this.postToChannel(`**[${step.name}]** Agent idle after completing work \u2014 verification passed, releasing`);
             await agent.release();
-            throw new Error(`Step "${step.name}" timed out after ${timeoutMs ?? "unknown"}ms`);
+            timeoutRecovered = true;
           }
-        } else {
+        }
+        if (!timeoutRecovered) {
           await agent.release();
           throw new Error(`Step "${step.name}" timed out after ${timeoutMs ?? "unknown"}ms`);
         }
@@ -36800,6 +37906,19 @@ DO NOT:
     } finally {
       ptyChunks = this.ptyOutputBuffers.get(agentName) ?? [];
       this.lastFailedStepOutput.set(step.name, ptyChunks.join(""));
+      if (ptyChunks.length > 0 || agent?.exitCode !== void 0 || agent?.exitSignal !== void 0) {
+        this.captureStepTerminalEvidence(evidenceStepName, {
+          stdout: ptyChunks.length > 0 ? ptyChunks.join("") : void 0,
+          combined: ptyChunks.length > 0 ? ptyChunks.join("") : void 0
+        }, {
+          exitCode: agent?.exitCode,
+          exitSignal: agent?.exitSignal
+        }, {
+          sender: options.logicalName ?? agentDef.name,
+          actor: agent?.name ?? agentName,
+          role: options.evidenceRole ?? agentDef.role ?? "agent"
+        });
+      }
       stopHeartbeat?.();
       this.activeAgentHandles.delete(agentName);
       this.ptyOutputBuffers.delete(agentName);
@@ -36811,6 +37930,7 @@ DO NOT:
       }
       this.unregisterWorker(agentName);
       this.supervisedRuntimeAgents.delete(agentName);
+      this.runtimeStepAgents.delete(agentName);
     }
     let output;
     if (ptyChunks.length > 0) {
@@ -36819,6 +37939,13 @@ DO NOT:
       const summaryPath = import_node_path8.default.join(this.summaryDir, `${step.name}.md`);
       output = (0, import_node_fs4.existsSync)(summaryPath) ? await (0, import_promises3.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
     }
+    if (ptyChunks.length === 0) {
+      this.captureStepTerminalEvidence(evidenceStepName, { stdout: output, combined: output }, { exitCode: agent?.exitCode, exitSignal: agent?.exitSignal }, {
+        sender: options.logicalName ?? agentDef.name,
+        actor: agent?.name ?? agentName,
+        role: options.evidenceRole ?? agentDef.role ?? "agent"
+      });
+    }
     return {
       output,
       exitCode: agent?.exitCode,
@@ -36846,13 +37973,34 @@ DO NOT:
     "orchestrator",
     "auctioneer"
   ]);
+  isLeadLikeAgent(agentDef, roleOverride) {
+    if (agentDef.preset === "lead")
+      return true;
+    const role = (roleOverride ?? agentDef.role ?? "").toLowerCase();
+    const nameLC = agentDef.name.toLowerCase();
+    return [..._WorkflowRunner.HUB_ROLES].some((hubRole) => new RegExp(`\\b${hubRole}\\b`, "i").test(nameLC) || new RegExp(`\\b${hubRole}\\b`, "i").test(role));
+  }
+  shouldPreserveIdleSupervisor(agentDef, step, evidenceRole) {
+    if (evidenceRole && /\bowner\b/i.test(evidenceRole)) {
+      return true;
+    }
+    if (!this.isLeadLikeAgent(agentDef, evidenceRole)) {
+      return false;
+    }
+    const task = step.task ?? "";
+    return /\b(wait|waiting|monitor|supervis|check inbox|check.*channel|poll|DONE|_DONE|signal|handoff)\b/i.test(task);
+  }
   /**
    * Wait for agent exit with idle detection and nudging.
    * If no idle nudge config is set, falls through to simple waitForExit.
    */
-  async waitForExitWithIdleNudging(agent, agentDef, step, timeoutMs) {
+  async waitForExitWithIdleNudging(agent, agentDef, step, timeoutMs, preserveIdleSupervisor = false) {
     const nudgeConfig = this.currentConfig?.swarm.idleNudge;
     if (!nudgeConfig) {
+      if (preserveIdleSupervisor) {
+        this.log(`[${step.name}] Supervising agent "${agent.name}" may idle while waiting \u2014 using exit-only completion`);
+        return agent.waitForExit(timeoutMs);
+      }
       const result = await Promise.race([
         agent.waitForExit(timeoutMs).then((r) => ({ kind: "exit", result: r })),
         agent.waitForIdle(timeoutMs).then((r) => ({ kind: "idle", result: r }))
@@ -36869,6 +38017,7 @@ DO NOT:
     const escalateAfterMs = nudgeConfig.escalateAfterMs ?? 12e4;
     const maxNudges = nudgeConfig.maxNudges ?? 1;
     let nudgeCount = 0;
+    let preservedSupervisorNoticeSent = false;
     const startTime = Date.now();
     while (true) {
       const elapsed = Date.now() - startTime;
@@ -36892,6 +38041,14 @@ DO NOT:
         this.emit({ type: "step:nudged", runId: this.currentRunId ?? "", stepName: step.name, nudgeCount });
         continue;
       }
+      if (preserveIdleSupervisor) {
+        if (!preservedSupervisorNoticeSent) {
+          this.log(`[${step.name}] Supervising agent "${agent.name}" stayed idle after ${nudgeCount} nudge(s) \u2014 preserving until exit or timeout`);
+          this.postToChannel(`**[${step.name}]** Supervising agent \`${agent.name}\` is waiting on handoff \u2014 keeping it alive until it exits or the step times out`);
+          preservedSupervisorNoticeSent = true;
+        }
+        continue;
+      }
       this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` still idle after ${nudgeCount} nudge(s) \u2014 force-releasing`);
       this.emit({ type: "step:force-released", runId: this.currentRunId ?? "", stepName: step.name });
       await agent.release();
@@ -36949,7 +38106,31 @@ DO NOT:
     return void 0;
   }
   // ── Verification ────────────────────────────────────────────────────────
-  runVerification(check2, output, stepName, injectedTaskText) {
+  runVerification(check2, output, stepName, injectedTaskText, options) {
+    const fail = (message) => {
+      const observedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+      this.recordStepToolSideEffect(stepName, {
+        type: "verification_observed",
+        detail: message,
+        observedAt: observedAt2,
+        raw: { passed: false, type: check2.type, value: check2.value }
+      });
+      this.getOrCreateStepEvidenceRecord(stepName).evidence.coordinationSignals.push({
+        kind: "verification_failed",
+        source: "verification",
+        text: message,
+        observedAt: observedAt2,
+        value: check2.value
+      });
+      if (options?.allowFailure) {
+        return {
+          passed: false,
+          completionReason: "failed_verification",
+          error: message
+        };
+      }
+      throw new WorkflowCompletionError(message, "failed_verification");
+    };
     switch (check2.type) {
       case "output_contains": {
         const token = check2.value;
@@ -36958,10 +38139,10 @@ DO NOT:
           const first = output.indexOf(token);
           const hasSecond = first !== -1 && output.includes(token, first + token.length);
           if (!hasSecond) {
-            throw new Error(`Verification failed for "${stepName}": output does not contain "${token}" (token found only in task injection \u2014 agent must output it explicitly)`);
+            return fail(`Verification failed for "${stepName}": output does not contain "${token}" (token found only in task injection \u2014 agent must output it explicitly)`);
           }
         } else if (!output.includes(token)) {
-          throw new Error(`Verification failed for "${stepName}": output does not contain "${token}"`);
+          return fail(`Verification failed for "${stepName}": output does not contain "${token}"`);
         }
         break;
       }
@@ -36969,12 +38150,34 @@ DO NOT:
         break;
       case "file_exists":
         if (!(0, import_node_fs4.existsSync)(import_node_path8.default.resolve(this.cwd, check2.value))) {
-          throw new Error(`Verification failed for "${stepName}": file "${check2.value}" does not exist`);
+          return fail(`Verification failed for "${stepName}": file "${check2.value}" does not exist`);
         }
         break;
       case "custom":
-        break;
-    }
+        return { passed: false };
+    }
+    if (options?.completionMarkerFound === false) {
+      this.log(`[${stepName}] Verification passed without legacy STEP_COMPLETE marker; allowing completion`);
+    }
+    const successMessage = options?.completionMarkerFound === false ? `Verification passed without legacy STEP_COMPLETE marker` : `Verification passed`;
+    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.recordStepToolSideEffect(stepName, {
+      type: "verification_observed",
+      detail: successMessage,
+      observedAt,
+      raw: { passed: true, type: check2.type, value: check2.value }
+    });
+    this.getOrCreateStepEvidenceRecord(stepName).evidence.coordinationSignals.push({
+      kind: "verification_passed",
+      source: "verification",
+      text: successMessage,
+      observedAt,
+      value: check2.value
+    });
+    return {
+      passed: true,
+      completionReason: "completed_verified"
+    };
   }
   // ── State helpers ─────────────────────────────────────────────────────
   async updateRunStatus(runId, status, error48) {
@@ -36990,13 +38193,16 @@ DO NOT:
     }
     await this.db.updateRun(runId, patch);
   }
-  async markStepFailed(state, error48, runId, exitInfo) {
+  async markStepFailed(state, error48, runId, exitInfo, completionReason) {
+    this.captureStepTerminalEvidence(state.row.stepName, {}, exitInfo);
     state.row.status = "failed";
     state.row.error = error48;
+    state.row.completionReason = completionReason;
     state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.db.updateStep(state.row.id, {
       status: "failed",
       error: error48,
+      completionReason,
       completedAt: state.row.completedAt,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -37008,6 +38214,7 @@ DO NOT:
       exitCode: exitInfo?.exitCode,
       exitSignal: exitInfo?.exitSignal
     });
+    this.finalizeStepEvidence(state.row.stepName, "failed", state.row.completedAt, completionReason);
   }
   async markDownstreamSkipped(failedStepName, allSteps, stepStates, runId) {
     const queue = [failedStepName];
@@ -37114,9 +38321,23 @@ RELAY SETUP \u2014 do this FIRST before any other relay tool:
   "RELAY SETUP: First call register(name='<exact-agent-name>') before any other relay tool."`;
   }
   /** Post a message to the workflow channel. Fire-and-forget — never throws or blocks. */
-  postToChannel(text) {
+  postToChannel(text, options = {}) {
     if (!this.relayApiKey || !this.channel)
       return;
+    this.recordChannelEvidence(text, options);
+    const stepName = options.stepName ?? this.inferStepNameFromChannelText(text);
+    if (stepName) {
+      this.recordStepToolSideEffect(stepName, {
+        type: "post_channel_message",
+        detail: text.slice(0, 240),
+        raw: {
+          actor: options.actor,
+          role: options.role,
+          target: options.target ?? this.channel,
+          origin: options.origin ?? "runner_post"
+        }
+      });
+    }
     this.ensureRelaycastRunnerAgent().then((agent) => agent.send(this.channel, text)).catch(() => {
     });
   }
@@ -37259,7 +38480,8 @@ ${excerpt}` : "";
         attempts: state.row.retryCount + 1,
         output: state.row.output,
         error: state.row.error,
-        verificationPassed: state.row.status === "completed" && stepsWithVerification.has(name)
+        verificationPassed: state.row.status === "completed" && stepsWithVerification.has(name),
+        completionMode: state.row.completionReason ? this.buildStepCompletionDecision(name, state.row.completionReason)?.mode : void 0
       });
     }
     return outcomes;
@@ -37367,16 +38589,22 @@ ${excerpt}` : "";
   }
   /** Persist step output to disk and post full output as a channel message. */
   async persistStepOutput(runId, stepName, output) {
+    const outputPath = import_node_path8.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
       (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
-      await (0, import_promises3.writeFile)(import_node_path8.default.join(dir, `${stepName}.md`), cleaned);
+      await (0, import_promises3.writeFile)(outputPath, cleaned);
     } catch {
     }
+    this.recordStepToolSideEffect(stepName, {
+      type: "persist_step_output",
+      detail: `Persisted step output to ${this.normalizeEvidencePath(outputPath)}`,
+      raw: { path: outputPath }
+    });
     const scrubbed = _WorkflowRunner.scrubForChannel(output);
     if (scrubbed.length === 0) {
-      this.postToChannel(`**[${stepName}]** Step completed \u2014 output written to disk`);
+      this.postToChannel(`**[${stepName}]** Step completed \u2014 output written to disk`, { stepName });
       return;
     }
     const maxMsg = 2e3;
@@ -37384,7 +38612,7 @@ ${excerpt}` : "";
     this.postToChannel(`**[${stepName}] Output:**
 \`\`\`
 ${preview}
-\`\`\``);
+\`\`\``, { stepName });
   }
   /** Load persisted step output from disk. */
   loadStepOutput(runId, stepName) {
@@ -39013,131 +40241,6 @@ var TemplateRegistry = class {
   }
 };
 
-// packages/sdk/dist/spawn-from-env.js
-var BYPASS_FLAGS = {
-  claude: { flag: "--dangerously-skip-permissions" },
-  codex: {
-    flag: "--dangerously-bypass-approvals-and-sandbox",
-    aliases: ["--full-auto"]
-  },
-  gemini: {
-    flag: "--yolo",
-    aliases: ["-y"]
-  }
-};
-function getBypassFlagConfig(cli) {
-  const baseCli = cli.includes(":") ? cli.split(":")[0] : cli;
-  return BYPASS_FLAGS[baseCli];
-}
-function parseSpawnEnv(env = process.env) {
-  const AGENT_NAME = env.AGENT_NAME;
-  const AGENT_CLI = env.AGENT_CLI;
-  const RELAY_API_KEY = env.RELAY_API_KEY;
-  const missing = [];
-  if (!AGENT_NAME)
-    missing.push("AGENT_NAME");
-  if (!AGENT_CLI)
-    missing.push("AGENT_CLI");
-  if (!RELAY_API_KEY)
-    missing.push("RELAY_API_KEY");
-  if (missing.length > 0) {
-    throw new Error(`[spawn-from-env] Missing required environment variables: ${missing.join(", ")}`);
-  }
-  return {
-    AGENT_NAME,
-    AGENT_CLI,
-    RELAY_API_KEY,
-    AGENT_TASK: env.AGENT_TASK || void 0,
-    AGENT_ARGS: env.AGENT_ARGS || void 0,
-    AGENT_CWD: env.AGENT_CWD || void 0,
-    AGENT_CHANNELS: env.AGENT_CHANNELS || void 0,
-    RELAY_BASE_URL: env.RELAY_BASE_URL || void 0,
-    BROKER_BINARY_PATH: env.BROKER_BINARY_PATH || void 0,
-    AGENT_MODEL: env.AGENT_MODEL || void 0,
-    AGENT_DISABLE_DEFAULT_BYPASS: env.AGENT_DISABLE_DEFAULT_BYPASS || void 0
-  };
-}
-function parseArgs(raw) {
-  if (!raw)
-    return [];
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("[")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed))
-        return parsed.map(String);
-    } catch {
-    }
-  }
-  return trimmed.split(/\s+/).filter(Boolean);
-}
-function resolveSpawnPolicy(input) {
-  const extraArgs = parseArgs(input.AGENT_ARGS);
-  const channels = input.AGENT_CHANNELS ? input.AGENT_CHANNELS.split(",").map((c) => c.trim()).filter(Boolean) : ["general"];
-  const disableBypass = input.AGENT_DISABLE_DEFAULT_BYPASS === "1";
-  const bypassConfig = getBypassFlagConfig(input.AGENT_CLI);
-  let bypassApplied = false;
-  const args = [...extraArgs];
-  const bypassValues = bypassConfig ? [bypassConfig.flag, ...bypassConfig.aliases ?? []] : [];
-  const hasBypassAlready = bypassValues.some((value) => args.includes(value));
-  if (bypassConfig && !disableBypass && !hasBypassAlready) {
-    args.push(bypassConfig.flag);
-    bypassApplied = true;
-  }
-  return {
-    name: input.AGENT_NAME,
-    cli: input.AGENT_CLI,
-    args,
-    channels,
-    task: input.AGENT_TASK,
-    cwd: input.AGENT_CWD,
-    model: input.AGENT_MODEL,
-    bypassApplied
-  };
-}
-async function spawnFromEnv(options = {}) {
-  const env = options.env ?? process.env;
-  const parsed = parseSpawnEnv(env);
-  const policy = resolveSpawnPolicy(parsed);
-  console.log(`[spawn-from-env] Spawning agent: name=${policy.name} cli=${policy.cli} channels=${policy.channels.join(",")} bypass=${policy.bypassApplied}`);
-  if (policy.task) {
-    console.log(`[spawn-from-env] Task: ${policy.task.slice(0, 200)}${policy.task.length > 200 ? "..." : ""}`);
-  }
-  const relay = new AgentRelay({
-    binaryPath: options.binaryPath ?? parsed.BROKER_BINARY_PATH,
-    brokerName: options.brokerName ?? `broker-${policy.name}`,
-    channels: policy.channels,
-    cwd: policy.cwd ?? process.cwd(),
-    env
-  });
-  relay.onAgentSpawned = (agent) => {
-    console.log(`[spawn-from-env] Agent spawned: ${agent.name}`);
-  };
-  relay.onAgentReady = (agent) => {
-    console.log(`[spawn-from-env] Agent ready: ${agent.name}`);
-  };
-  relay.onAgentExited = (agent) => {
-    console.log(`[spawn-from-env] Agent exited: ${agent.name} code=${agent.exitCode ?? "none"} signal=${agent.exitSignal ?? "none"}`);
-  };
-  try {
-    const agent = await relay.spawnPty({
-      name: policy.name,
-      cli: policy.cli,
-      args: policy.args,
-      channels: policy.channels,
-      task: policy.task
-    });
-    const exitReason = await agent.waitForExit();
-    console.log(`[spawn-from-env] Exit reason: ${exitReason}`);
-    return { exitReason, exitCode: agent.exitCode };
-  } catch (err) {
-    console.error(`[spawn-from-env] Error:`, err);
-    throw err;
-  } finally {
-    await relay.shutdown();
-  }
-}
-
 // packages/utils/dist/name-generator.js
 var ADJECTIVES = [
   "Blue",