cool-workflow 0.1.85 → 0.1.87

package/scripts/agents/agent-adapter-core.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+
+const RESULT_CONTRACT = `
+=== HOW TO RETURN YOUR ANSWER (overrides any 'write to result.md' instruction above) ===
+You have NO file-write access. Do NOT attempt to write, create, or edit any file -
+result.md is persisted FOR YOU from your final message, so writing it yourself is
+neither needed nor possible. Use ONLY read-only tools (read files, grep, list).
+Respond with ONLY your FINAL answer as Markdown, and it MUST END WITH a fenced
+cw:result block that EXACTLY follows this schema:
+
+\`\`\`cw:result
+{
+  "summary": "one-paragraph direct answer",
+  "findings": [
+    {
+      "id": "unique-kebab-id",
+      "title": "short risk title",
+      "severity": "P0",
+      "classification": "real",
+      "evidence": ["path/to/file.ts:42"]
+    }
+  ],
+  "evidence": ["path/to/file.ts:42", "path/to/other.ts:10"]
+}
+\`\`\`
+
+HARD RULES (the result is REJECTED otherwise):
+- Every object in "findings" MUST have a unique "id" (non-empty string).
+- "classification", if present, MUST be one of: real, conditional, non-issue, unknown.
+- Any finding with "severity" P0, P1, or P2 MUST include a NON-EMPTY "evidence" array.
+- The top-level "evidence" array MUST be NON-EMPTY with REAL file:line locators from this repo.
+- If you have no structured findings, use "findings": [] (empty) - never omit a finding's id.`;
+
+function buildPrompt(inputPath) {
+  return `${fs.readFileSync(inputPath, "utf8")}\n${RESULT_CONTRACT}`;
+}
+
+function streamEnabled(env = process.env) {
+  return env.CW_AGENT_STREAM === "1" && env.CW_NO_STREAM !== "1";
+}
+
+function traceEnabled(env = process.env, stderr = process.stderr) {
+  return streamEnabled(env) && Boolean(stderr.isTTY);
+}
+
+function trace(line, env = process.env, stderr = process.stderr) {
+  if (!traceEnabled(env, stderr)) return;
+  stderr.write(`${line}\n`);
+}
+
+function shortText(value, max = 100) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function maybeObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+
+function firstString(...values) {
+  for (const value of values) if (typeof value === "string" && value.trim()) return value.trim();
+  return undefined;
+}
+
+function firstObject(...values) {
+  for (const value of values) {
+    const obj = maybeObject(value);
+    if (obj) return obj;
+  }
+  return undefined;
+}
+
+function modelFromEvent(ev) {
+  const msg = maybeObject(ev.message);
+  return firstString(ev.model, ev.model_id, ev.modelId, msg && msg.model, ev.provider_model);
+}
+
+function usageFromEvent(ev) {
+  const msg = maybeObject(ev.message);
+  return firstObject(ev.usage, ev.token_usage, ev.tokenUsage, msg && msg.usage);
+}
+
+function toolNameFromEvent(ev) {
+  const item = maybeObject(ev.item);
+  const call = maybeObject(ev.tool_call || ev.toolCall);
+  return firstString(ev.name, ev.tool, ev.tool_name, ev.toolName, item && item.name, call && call.name);
+}
+
+function toolArgFromEvent(ev) {
+  const input = maybeObject(ev.input) || maybeObject(ev.arguments) || maybeObject(ev.args) || maybeObject(ev.item && ev.item.input);
+  if (!input) return "";
+  return firstString(input.file_path, input.path, input.pattern, input.command, input.query, input.url, input.cmd) || "";
+}
+
+function textFromEvent(ev) {
+  const delta = maybeObject(ev.delta);
+  const msg = maybeObject(ev.message);
+  return firstString(ev.text, ev.delta, ev.content, ev.output, delta && delta.text, msg && msg.content);
+}
+
+function renderJsonEvent(provider, ev, state) {
+  if (!ev || typeof ev !== "object") return;
+  const model = modelFromEvent(ev);
+  if (model && !state.model) state.model = model;
+  const usage = usageFromEvent(ev);
+  if (usage) state.usage = usage;
+
+  const type = String(ev.type || ev.event || ev.kind || "");
+  const toolName = toolNameFromEvent(ev);
+  if (toolName || /tool|command/i.test(type)) {
+    const arg = shortText(toolArgFromEvent(ev), 80);
+    trace(`  -> ${toolName || type}${arg ? ` ${arg}` : ""}`);
+    return;
+  }
+
+  const text = textFromEvent(ev);
+  if (text && /assistant|message|delta|text|response|output/i.test(type || "text")) {
+    trace(`  ${shortText(text, 240)}`);
+  } else if (/turn|step|summary|status/i.test(type)) {
+    const status = firstString(ev.status, ev.status_detail, ev.summary, ev.message);
+    if (status) trace(`  . ${provider}: ${shortText(status, 160)}`);
+  }
+}
+
+function parseJsonLines(provider, chunk, state, onLine) {
+  state.buffer = `${state.buffer || ""}${chunk}`;
+  let nl;
+  while ((nl = state.buffer.indexOf("\n")) >= 0) {
+    const line = state.buffer.slice(0, nl).trim();
+    state.buffer = state.buffer.slice(nl + 1);
+    if (!line) continue;
+    if (onLine) onLine(line);
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    renderJsonEvent(provider, ev, state);
+  }
+}
+
+function flushJsonLines(provider, state, onLine) {
+  const line = String(state.buffer || "").trim();
+  state.buffer = "";
+  if (!line) return;
+  if (onLine) onLine(line);
+  try {
+    renderJsonEvent(provider, JSON.parse(line), state);
+  } catch {
+    /* ignore incomplete/non-JSON tail */
+  }
+}
+
+function writeResult(resultPath, resultText) {
+  if (typeof resultText !== "string" || !resultText.trim()) {
+    throw new Error("agent produced no final result");
+  }
+  fs.writeFileSync(resultPath, resultText, "utf8");
+}
+
+function emitReport(model, usage, resultText) {
+  process.stdout.write(JSON.stringify({ model, usage, result: resultText }));
+}
+
+module.exports = {
+  RESULT_CONTRACT,
+  buildPrompt,
+  streamEnabled,
+  traceEnabled,
+  trace,
+  parseJsonLines,
+  flushJsonLines,
+  writeResult,
+  emitReport
+};

package/scripts/agents/builtin-templates.json

@@ -2,6 +2,9 @@
   "schemaVersion": 1,
   "comment": "Builtin agent-delegation templates as DATA, not a hand-edited kernel TS literal (FreeBSD-audit L15). Each entry maps a vendor name to the wrapper script in THIS directory that `builtin:<name>` (or CW_AGENT_COMMAND=builtin:<name>) resolves to. Adding a vendor is a content/distribution step: drop a wrapper script here + add a line below — NO kernel edit. Still pure config: the wrapper is an out-of-process delegation script; CW never imports or calls a model API.",
   "templates": {
-    "claude": "claude-p-agent.js"
+    "claude": "claude-p-agent.js",
+    "codex": "codex-agent.js",
+    "gemini": "gemini-agent.js",
+    "opencode": "opencode-agent.js"
   }
 }

package/scripts/agents/codex-agent.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+
+// codex-agent.js - Codex CLI adapter for CW Agent Delegation Drive.
+//
+// This is a CONFIG wrapper, not a CW runtime dependency. CW spawns this script
+// out-of-process; this script spawns `codex exec` out-of-process. Vendor JSONL
+// parsing stays here in userland policy. CW core only captures stdout and, when
+// opted in, forwards stderr.
+//
+// Contract:
+//   argv[2] = {{input}}   worker input.md
+//   argv[3] = {{result}}  worker result.md to persist
+//
+// stdout: one JSON object { model, usage, result } for CW provenance.
+// stderr: optional live trace when CW_AGENT_STREAM=1 and attached to a TTY.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+const {
+  buildPrompt,
+  emitReport,
+  flushJsonLines,
+  parseJsonLines,
+  trace,
+  writeResult
+} = require("./agent-adapter-core");
+
+const inputPath = process.argv[2];
+const resultPath = process.argv[3];
+if (!inputPath || !resultPath) {
+  process.stderr.write("usage: codex-agent.js <inputPath> <resultPath>  (CW substitutes {{input}} {{result}})\n");
+  process.exit(2);
+}
+
+const finalPath = path.join(path.dirname(resultPath), `.codex-last-message-${process.pid}.md`);
+try {
+  fs.rmSync(finalPath, { force: true });
+} catch {
+  /* best effort */
+}
+
+const prompt = buildPrompt(inputPath);
+const state = { provider: "codex", buffer: "", model: undefined, usage: undefined };
+const capturedStdout = [];
+let childStderr = "";
+function recordJsonLine(line) {
+  capturedStdout.push(line);
+  try {
+    JSON.parse(line);
+  } catch {
+    state.invalidJson = true;
+  }
+}
+
+trace("* codex: reading the repo (read-only)...");
+
+const args = [
+  "exec",
+  "--json",
+  "--output-last-message",
+  finalPath,
+  "--sandbox",
+  "read-only",
+  "--ask-for-approval",
+  "never",
+  "--color",
+  "never",
+  "-"
+];
+
+const child = spawn("codex", args, {
+  stdio: ["pipe", "pipe", "pipe"],
+  shell: false
+});
+
+child.stdin.setDefaultEncoding("utf8");
+child.stdin.end(prompt);
+
+child.stdout.setEncoding("utf8");
+child.stdout.on("data", (chunk) => {
+  parseJsonLines("codex", chunk, state, recordJsonLine);
+});
+
+child.stderr.setEncoding("utf8");
+child.stderr.on("data", (chunk) => {
+  childStderr += chunk;
+  if (process.env.CW_AGENT_STREAM === "1" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
+    process.stderr.write(chunk);
+  }
+});
+
+child.on("error", (error) => {
+  process.stderr.write(`codex spawn failed: ${error.message}\n`);
+  process.exit(1);
+});
+
+child.on("close", (code) => {
+  flushJsonLines("codex", state, recordJsonLine);
+  if (code !== 0) {
+    const detail = childStderr.trim() || `codex exited ${code === null ? "(timeout/killed)" : code}`;
+    process.stderr.write(`${detail}\n`);
+    process.exit(code === null ? 1 : code);
+  }
+  if (state.invalidJson) {
+    process.stderr.write("codex --json produced a non-JSONL stdout line - refusing to trust the result\n");
+    process.exit(1);
+  }
+
+  let resultText = "";
+  try {
+    resultText = fs.readFileSync(finalPath, "utf8");
+  } catch {
+    process.stderr.write("codex produced no final output file - refusing to fabricate a result\n");
+    process.exit(1);
+  } finally {
+    try {
+      fs.rmSync(finalPath, { force: true });
+    } catch {
+      /* best effort */
+    }
+  }
+
+  try {
+    writeResult(resultPath, resultText);
+  } catch (error) {
+    process.stderr.write(`codex produced no final result: ${error.message}\n`);
+    process.exit(1);
+  }
+
+  trace("* done - result captured");
+  emitReport(state.model, state.usage, resultText);
+});

package/scripts/agents/gemini-agent.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+"use strict";
+
+// gemini-agent.js - Gemini CLI adapter for CW Agent Delegation Drive.
+//
+// This is a CONFIG wrapper, not a CW runtime dependency. CW spawns this script
+// out-of-process; this script spawns `gemini -p` out-of-process. Vendor NDJSON
+// parsing stays here in userland policy.
+//
+// Contract:
+//   argv[2] = {{input}}   worker input.md
+//   argv[3] = {{result}}  worker result.md to persist
+//
+// stdout: one JSON object { model, usage, result } for CW provenance.
+// stderr: optional live trace when CW_AGENT_STREAM=1 and attached to a TTY.
+
+const { spawn } = require("node:child_process");
+const {
+  buildPrompt,
+  emitReport,
+  flushJsonLines,
+  parseJsonLines,
+  trace,
+  writeResult
+} = require("./agent-adapter-core");
+
+const inputPath = process.argv[2];
+const resultPath = process.argv[3];
+if (!inputPath || !resultPath) {
+  process.stderr.write("usage: gemini-agent.js <inputPath> <resultPath>  (CW substitutes {{input}} {{result}})\n");
+  process.exit(2);
+}
+
+const prompt = buildPrompt(inputPath);
+const state = { provider: "gemini", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined };
+let childStderr = "";
+function recordJsonLine(line) {
+  let ev;
+  try {
+    ev = JSON.parse(line);
+  } catch {
+    state.invalidJson = true;
+    return;
+  }
+  // Prefer the final result event text; delta events are incremental fallback.
+  if (ev.result && typeof ev.result === "string") {
+    state.finalResult = ev.result;
+  } else {
+    const text = typeof ev.text === "string" ? ev.text : (ev.delta ? (typeof ev.delta === "string" ? ev.delta : ev.delta.text) : undefined);
+    if (typeof text === "string" && text.trim()) state.textFragments.push(text);
+  }
+}
+
+trace("* gemini: reading the repo (read-only)...");
+
+const args = [
+  "-p",
+  prompt,
+  "--output-format",
+  "stream-json",
+  "--approval-mode",
+  "plan"
+];
+
+const child = spawn("gemini", args, {
+  stdio: ["ignore", "pipe", "pipe"],
+  shell: false
+});
+
+child.stdout.setEncoding("utf8");
+child.stdout.on("data", (chunk) => {
+  parseJsonLines("gemini", chunk, state, recordJsonLine);
+});
+
+child.stderr.setEncoding("utf8");
+child.stderr.on("data", (chunk) => {
+  childStderr += chunk;
+  if (process.env.CW_AGENT_STREAM === "1" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
+    process.stderr.write(chunk);
+  }
+});
+
+child.on("error", (error) => {
+  process.stderr.write(`gemini spawn failed: ${error.message}\n`);
+  process.exit(1);
+});
+
+child.on("close", (code) => {
+  flushJsonLines("gemini", state, recordJsonLine);
+  if (code !== 0) {
+    const detail = childStderr.trim() || `gemini exited ${code === null ? "(timeout/killed)" : code}`;
+    process.stderr.write(`${detail}\n`);
+    process.exit(code === null ? 1 : code);
+  }
+  if (state.invalidJson) {
+    process.stderr.write("gemini --output-format stream-json produced a non-JSONL stdout line - refusing to trust the result\n");
+    process.exit(1);
+  }
+
+  const resultText = state.finalResult || state.textFragments.join("\n\n");
+  if (!resultText.trim()) {
+    process.stderr.write("gemini produced no result text - refusing to fabricate a result\n");
+    process.exit(1);
+  }
+
+  try {
+    writeResult(resultPath, resultText);
+  } catch (error) {
+    process.stderr.write(`gemini produced no final result: ${error.message}\n`);
+    process.exit(1);
+  }
+
+  trace("* done - result captured");
+  emitReport(state.model, state.usage, resultText);
+});

package/scripts/agents/opencode-agent.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+"use strict";
+
+// opencode-agent.js - OpenCode CLI adapter for CW Agent Delegation Drive.
+//
+// This is a CONFIG wrapper, not a CW runtime dependency. CW spawns this script
+// out-of-process; this script spawns `opencode run` out-of-process. Vendor JSONL
+// parsing stays here in userland policy.
+//
+// Contract:
+//   argv[2] = {{input}}   worker input.md
+//   argv[3] = {{result}}  worker result.md to persist
+//
+// stdout: one JSON object { model, usage, result } for CW provenance.
+// stderr: optional live trace when CW_AGENT_STREAM=1 and attached to a TTY.
+//
+// NOTE: --dangerously-skip-permissions is used because OpenCode lacks a native
+// --read-only or --allowed-tools flag. CW's sandbox layer enforces write safety
+// via execution-backend boundary controls. If OpenCode adds a cleaner read-only
+// flag, prefer that here.
+
+const { spawn } = require("node:child_process");
+const {
+  buildPrompt,
+  emitReport,
+  flushJsonLines,
+  parseJsonLines,
+  trace,
+  writeResult
+} = require("./agent-adapter-core");
+
+const inputPath = process.argv[2];
+const resultPath = process.argv[3];
+if (!inputPath || !resultPath) {
+  process.stderr.write("usage: opencode-agent.js <inputPath> <resultPath>  (CW substitutes {{input}} {{result}})\n");
+  process.exit(2);
+}
+
+const prompt = buildPrompt(inputPath);
+const state = { provider: "opencode", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined };
+let childStderr = "";
+function recordJsonLine(line) {
+  let ev;
+  try {
+    ev = JSON.parse(line);
+  } catch {
+    state.invalidJson = true;
+    return;
+  }
+  if (ev.result && typeof ev.result === "string") {
+    state.finalResult = ev.result;
+  } else {
+    const text = typeof ev.text === "string" ? ev.text : (ev.delta ? (typeof ev.delta === "string" ? ev.delta : ev.delta.text) : undefined);
+    if (typeof text === "string" && text.trim()) state.textFragments.push(text);
+  }
+}
+
+trace("* opencode: reading the repo...");
+
+const args = [
+  "run",
+  "--format",
+  "json",
+  "--dangerously-skip-permissions",
+  "--prompt",
+  prompt
+];
+
+const child = spawn("opencode", args, {
+  stdio: ["ignore", "pipe", "pipe"],
+  shell: false
+});
+
+child.stdout.setEncoding("utf8");
+child.stdout.on("data", (chunk) => {
+  parseJsonLines("opencode", chunk, state, recordJsonLine);
+});
+
+child.stderr.setEncoding("utf8");
+child.stderr.on("data", (chunk) => {
+  childStderr += chunk;
+  if (process.env.CW_AGENT_STREAM === "1" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
+    process.stderr.write(chunk);
+  }
+});
+
+child.on("error", (error) => {
+  process.stderr.write(`opencode spawn failed: ${error.message}\n`);
+  process.exit(1);
+});
+
+child.on("close", (code) => {
+  flushJsonLines("opencode", state, recordJsonLine);
+  if (code !== 0) {
+    const detail = childStderr.trim() || `opencode exited ${code === null ? "(timeout/killed)" : code}`;
+    process.stderr.write(`${detail}\n`);
+    process.exit(code === null ? 1 : code);
+  }
+  if (state.invalidJson) {
+    process.stderr.write("opencode --format json produced a non-JSONL stdout line - refusing to trust the result\n");
+    process.exit(1);
+  }
+
+  const resultText = state.finalResult || state.textFragments.join("\n\n");
+  if (!resultText.trim()) {
+    process.stderr.write("opencode produced no result text - refusing to fabricate a result\n");
+    process.exit(1);
+  }
+
+  try {
+    writeResult(resultPath, resultText);
+  } catch (error) {
+    process.stderr.write(`opencode produced no final result: ${error.message}\n`);
+    process.exit(1);
+  }
+
+  trace("* done - result captured");
+  emitReport(state.model, state.usage, resultText);
+});

package/scripts/architecture-review-fast.js

@@ -308,11 +308,13 @@ function buildMetrics(started, contextText, sourceContextElapsedMs, fastReview,
   const steps = Array.isArray(fastReview?.steps) ? fastReview.steps : [];
   const handleKinds = countBy(steps.map((step) => step && step.handleKind).filter(Boolean));
   const actions = countBy(steps.map((step) => step && step.action).filter(Boolean));
+  const taskMetrics = buildTaskMetrics(fastReview, steps);
   return {
     totalElapsedMs: elapsedMs(started),
     sourceContext: {
       elapsedMs: sourceContextElapsedMs,
-      bytes: Buffer.byteLength(contextText, "utf8")
+      bytes: Buffer.byteLength(contextText, "utf8"),
+      digest: `sha256:${crypto.createHash("sha256").update(contextText, "utf8").digest("hex")}`
     },
     fastReview: {
       elapsedMs: fastReviewElapsedMs,
@@ -323,12 +325,52 @@ function buildMetrics(started, contextText, sourceContextElapsedMs, fastReview,
       actions,
       handleKinds,
       resultCacheHits: Number(handleKinds["result-cache"] || 0),
-      agentSpawns: steps.filter((step) => step && step.backendId === "agent" && step.handleKind && step.handleKind !== "result-cache").length
+      agentSpawns: steps.filter((step) => step && step.backendId === "agent" && step.handleKind && step.handleKind !== "result-cache").length,
+      taskMetrics
     },
     ...(fullReviewScheduleElapsedMs === undefined ? {} : { fullReviewSchedule: { elapsedMs: fullReviewScheduleElapsedMs } })
   };
 }
 
+function buildTaskMetrics(fastReview, steps) {
+  const statePath = stringArg(fastReview?.statePath);
+  const run = readRunState(statePath);
+  const tasks = Array.isArray(run?.tasks) ? run.tasks : [];
+  const byTask = new Map(tasks.map((task) => [task.id, task]));
+  return steps
+    .filter((step) => step && step.taskId)
+    .map((step) => {
+      const task = byTask.get(step.taskId) || {};
+      return {
+        phase: step.phase || task.phase || "",
+        taskId: step.taskId,
+        action: step.action,
+        status: step.status,
+        elapsedMs: taskElapsedMs(task),
+        handleKind: step.handleKind || "",
+        agentSpawned: Boolean(step.backendId === "agent" && step.handleKind && step.handleKind !== "result-cache"),
+        resultCacheHit: step.handleKind === "result-cache",
+        reportedModel: step.reportedModel || ""
+      };
+    });
+}
+
+function readRunState(statePath) {
+  if (!statePath) return null;
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function taskElapsedMs(task) {
+  const started = Date.parse(task?.startedAt || task?.dispatchedAt || "");
+  const completed = Date.parse(task?.completedAt || "");
+  if (!Number.isFinite(started) || !Number.isFinite(completed)) return null;
+  return Math.max(0, completed - started);
+}
+
 function countBy(values) {
   const counts = {};
   for (const value of values) counts[String(value)] = (counts[String(value)] || 0) + 1;

package/scripts/canonical-apps.js

@@ -83,7 +83,7 @@ const canonicalApps = [
       "--source",
       "plugins/cool-workflow/docs/workflow-app-framework.7.md",
       "--scope",
-      "Cool Workflow v0.1.85",
+      "Cool Workflow v0.1.87",
       "--freshness",
       "as of release preparation"
     ]
@@ -117,14 +117,14 @@ function main() {
     assert.ok(summary, `${app.id} must appear in app list`);
     assert.equal(summary.sourceKind, "app-directory");
     assert.equal(summary.legacy, false);
-    assert.equal(summary.version, "0.1.85");
+    assert.equal(summary.version, "0.1.87");
 
     const validation = runJson(["app", "validate", manifestPath]);
     assert.equal(validation.valid, true, `${app.id} manifest must validate`);
 
     const shown = runJson(["app", "show", app.id]);
     assert.equal(shown.app.id, app.id);
-    assert.equal(shown.app.version, "0.1.85");
+    assert.equal(shown.app.version, "0.1.87");
     assert.ok(shown.app.metadata.canonical, `${app.id} must be marked canonical`);
     assert.ok(shown.app.sandboxProfiles.length > 0, `${app.id} must declare sandbox profiles`);
     assertTaskIdsUnique(shown);
@@ -135,7 +135,7 @@ function main() {
     const plan = runJson(["plan", app.id, ...app.args(workspace)]);
     const state = JSON.parse(fs.readFileSync(plan.statePath, "utf8"));
     assert.equal(state.workflow.app.id, app.id);
-    assert.equal(state.workflow.app.version, "0.1.85");
+    assert.equal(state.workflow.app.version, "0.1.87");
     assert.equal(state.workflow.app.metadata.canonical, true);
     assert.ok(state.tasks.some((task) => task.requiresEvidence), `${app.id} plan must include evidence gates`);
     assert.ok(state.tasks.every((task) => task.sandboxProfileId), `${app.id} plan must include sandbox hints`);