@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-NQQH3YT7.js

@@ -0,0 +1,302 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  describeYaziProfile,
+  inspectCurrentYaziProfile,
+  resetYaziProfile
+} from "./chunk-HZHHCK24.js";
+import {
+  installTool,
+  installedToolVersions,
+  removeTool
+} from "./chunk-BKFM6EJV.js";
+import {
+  describeFloorRejection,
+  describeResolution,
+  installRemedy,
+  toolStatus,
+  toolStatuses
+} from "./chunk-QSNYB6ZV.js";
+import {
+  PINNED_TOOLS,
+  findPinnedTool
+} from "./chunk-QDC3K2U3.js";
+import {
+  formatColumns,
+  printError,
+  printOk
+} from "./chunk-VPKWYKEY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/tools.ts
+init_esm_shims();
+var HELP = `clio-coder tools <command>
+
+Manage the external terminal programs Clio can drive. Every one of them is
+optional: Clio works without them and only uses one when it is present. Each is
+pinned to an exact upstream version and checksum, and a copy already on PATH
+wins over Clio's own as long as it clears the pinned minimum.
+
+Commands:
+  clio-coder tools list [--json]           the pinned table and where each resolves
+  clio-coder tools status <id> [--json] [--reset-profile]  one tool in detail
+  clio-coder tools install <id> [--force] [--json]  download, verify, and vendor a tool
+  clio-coder tools remove <id>|--all [--json]  delete every vendored version of a tool
+
+Downloads happen only here. Nothing on a startup path fetches anything.
+
+An install keeps one version directory per tool: once the pinned version is in
+place, versions it superseded are pruned, along with any staging directory left
+by an install that was killed. Removal touches nothing outside <data>/tools/<id>
+and needs no confirmation, since every byte under it is re-downloadable from the
+checksum-pinned registry. "remove --all" sweeps every tool in the table.
+`;
+async function runToolsCommand(argv = []) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || parsed.command === void 0) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 2;
+  }
+  if (parsed.all && parsed.command !== "remove") {
+    printError("--all is only valid with `tools remove`");
+    return 2;
+  }
+  switch (parsed.command) {
+    case "list":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return listTools(parsed.json);
+    case "status":
+      return statusTool(parsed.positional[0], parsed.json, parsed.resetProfile);
+    case "install":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return installOne(parsed.positional[0], parsed.force, parsed.json);
+    case "remove":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return parsed.all ? removeAll(parsed.positional[0], parsed.json) : removeOne(parsed.positional[0], parsed.json);
+    default:
+      printError(`unknown tools command: ${parsed.command}`);
+      process.stderr.write(HELP);
+      return 2;
+  }
+}
+function parse(argv) {
+  const out = { positional: [], json: false, force: false, all: false, resetProfile: false, help: false };
+  for (const arg of argv) {
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--json":
+        out.json = true;
+        break;
+      case "--force":
+      case "-f":
+        out.force = true;
+        break;
+      case "--all":
+        out.all = true;
+        break;
+      case "--reset-profile":
+        out.resetProfile = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+        out.positional.push(arg);
+    }
+  }
+  return out;
+}
+function listTools(json) {
+  const statuses = toolStatuses();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(statuses.map(jsonShape), null, 2)}
+`);
+    return 0;
+  }
+  const rows = statuses.map((status) => [
+    status.id,
+    status.version,
+    status.license,
+    status.resolution.source,
+    describeResolution(status)
+  ]);
+  process.stdout.write(formatColumns([["TOOL", "PIN", "LICENSE", "SOURCE", "RESOLVED"], ...rows]));
+  return 0;
+}
+function invalidResetProfile() {
+  printError("--reset-profile is only valid with `tools status yazi`");
+  return 2;
+}
+function unknownTool(id) {
+  printError(`unknown tool: ${id} (known: ${PINNED_TOOLS.map((row) => row.id).join(", ")})`);
+  return 2;
+}
+function statusTool(id, json, resetProfile) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools status <id>");
+    return 2;
+  }
+  const entry = findPinnedTool(id);
+  if (entry === null) {
+    return unknownTool(id);
+  }
+  if (resetProfile && id !== "yazi") return invalidResetProfile();
+  if (resetProfile) resetYaziProfile();
+  const status = toolStatus(entry);
+  const profile = id === "yazi" ? inspectCurrentYaziProfile() : null;
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ ...jsonShape(status), ...profile ? { profile, profileReset: resetProfile } : {} }, null, 2)}
+`
+    );
+    return 0;
+  }
+  const rejection = describeFloorRejection(status);
+  const installedVersions = installedToolVersions(entry.id);
+  const lines = [
+    `${entry.id} ${entry.version} (${entry.license})`,
+    `  ${entry.summary}`,
+    `  homepage    ${entry.homepage}`,
+    `  binaries    ${entry.binaries.join(", ")}`,
+    `  PATH floor  ${entry.minimumVersion}`,
+    `  platform    ${status.platform ?? `${process.platform}-${process.arch}`}${status.supported ? "" : " (no pinned asset)"}`,
+    `  vendor dir  ${status.installDir}${status.installed ? "" : " (not installed)"}`,
+    `  vendored    ${installedVersions.length === 0 ? "nothing" : installedVersions.join(", ")}`,
+    `  resolves to ${describeResolution(status)}`,
+    // Spelled out on its own line as well as inside the resolution sentence,
+    // because a rejected PATH copy is the one thing an operator reads this
+    // command to understand and the sentence above may be about something else.
+    ...rejection === null ? [] : [
+      `  floor       rejected: ${rejection}`,
+      ...status.resolution.source === "none" && status.supported ? [`  remedy      ${installRemedy(entry.id)}`] : []
+    ],
+    ...profile ? [
+      `  profile     ${describeYaziProfile(profile)}`,
+      ...resetProfile ? ["  profile reset; next open regenerates it"] : []
+    ] : []
+  ];
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+async function installOne(id, force, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools install <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) {
+    return unknownTool(id);
+  }
+  const result = await installTool(id, {
+    force,
+    ...json ? {} : { onProgress: (message) => process.stderr.write(`  ${message}
+`) }
+  });
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  for (const path of result.documents) process.stdout.write(`  license  ${path}
+`);
+  for (const version of result.pruned) process.stdout.write(`  pruned   ${id} ${version}
+`);
+  return 0;
+}
+function removeOne(id, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools remove <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) return unknownTool(id);
+  const result = removeTool(id);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  if (result.removed.length > 0) {
+    process.stdout.write(`  reinstall with \`${installRemedy(id)}\`
+`);
+  }
+  return 0;
+}
+function removeAll(id, json) {
+  if (id !== void 0) {
+    printError("`tools remove --all` takes no tool id; drop the id or drop --all");
+    return 2;
+  }
+  const results = PINNED_TOOLS.map((entry) => removeTool(entry.id));
+  if (json) {
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+    return results.every((result) => result.ok) ? 0 : 1;
+  }
+  for (const result of results) {
+    if (!result.ok) printError(result.message);
+    else if (result.removed.length > 0 || result.staleStaging.length > 0) printOk(result.message);
+  }
+  const touched = results.filter((result) => result.ok && result.removed.length > 0);
+  const untouched = results.filter((result) => result.ok && result.removed.length === 0);
+  if (touched.length > 0) {
+    process.stdout.write(`  reinstall with \`clio-coder tools install <id>\`
+`);
+  }
+  if (untouched.length > 0) {
+    process.stdout.write(`  ${untouched.length} of ${results.length} had nothing vendored
+`);
+  }
+  return results.every((result) => result.ok) ? 0 : 1;
+}
+function jsonShape(status) {
+  return {
+    id: status.id,
+    version: status.version,
+    license: status.license,
+    platform: status.platform,
+    supported: status.supported,
+    installed: status.installed,
+    installDir: status.installDir,
+    source: status.resolution.source,
+    binaryPath: status.resolution.binaryPath,
+    foundVersion: status.resolution.version,
+    minimumVersion: status.resolution.entry?.minimumVersion ?? null,
+    pathCandidate: status.resolution.pathCandidate,
+    // A script deciding whether to warn about a floor rejection should not have
+    // to parse `detail` for it, so the rejection and the command that answers
+    // it are their own fields. `remedy` is null exactly where installing would
+    // change nothing: already vendored, or no asset for this platform.
+    floorRejection: describeFloorRejection(status),
+    remedy: status.resolution.source === "none" && status.supported ? installRemedy(status.id) : null,
+    installedVersions: installedToolVersions(status.id),
+    detail: describeResolution(status)
+  };
+}
+
+export {
+  runToolsCommand
+};
+//# sourceMappingURL=chunk-NQQH3YT7.js.map

package/dist/chunk-NYS75XW5.js

@@ -0,0 +1,15 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/tui-primitives.ts
+init_esm_shims();
+import { ProcessTerminal, TuiAltScreen, truncateToWidth } from "@earendil-works/pi-tui";
+
+export {
+  ProcessTerminal,
+  TuiAltScreen,
+  truncateToWidth
+};
+//# sourceMappingURL=chunk-NYS75XW5.js.map

package/dist/{chunk-GN57SG4G.js → chunk-O4XIVISU.js}

@@ -1,33 +1,35 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   parseAgentRecipeSchema
-} from "./chunk-FBVTI2TJ.js";
+} from "./chunk-Z4TXYIEG.js";
+import {
+  parseFleetContract
+} from "./chunk-CTJ4RNAA.js";
 import {
-  parseFleetContract,
   parseFrontmatter
-} from "./chunk-E77JEWSD.js";
+} from "./chunk-RKKLTLYB.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-DYJP44XW.js";
 import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-IJ7RPIYJ.js";
+} from "./chunk-VFA6GDY5.js";
 import {
   readClioVersion
 } from "./chunk-IWHMRKLL.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-4DGYLA73.js";
+} from "./chunk-GXNLGKAB.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir,
   resolveClioDirs
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceBackupPath,
   safeResourceWrite
@@ -610,4 +612,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-GN57SG4G.js.map
+//# sourceMappingURL=chunk-O4XIVISU.js.map

package/dist/{chunk-EMYUUSFG.js → chunk-O6TL7WWY.js}

@@ -4,25 +4,25 @@ import {
   READONLY_SCOPE,
   WORKSPACE_SCOPE,
   isSubset
-} from "./chunk-VCBR6CU7.js";
+} from "./chunk-5PSMVOLM.js";
 import {
   createLoopState,
   observe
 } from "./chunk-UOV2BYIW.js";
 import {
   createSafetyPolicyEngine
-} from "./chunk-5H3GB5BO.js";
+} from "./chunk-32KWKNSF.js";
 import {
   classify
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-DYJP44XW.js";
 import {
   BusChannels,
   isRunAbortedPayload
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -608,4 +608,4 @@ var SafetyDomainModule = {
 export {
   SafetyDomainModule
 };
-//# sourceMappingURL=chunk-EMYUUSFG.js.map
+//# sourceMappingURL=chunk-O6TL7WWY.js.map

package/dist/chunk-OQBA45DZ.js

@@ -0,0 +1,97 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compileExecutionPlan
+} from "./chunk-QBJA7R7N.js";
+import {
+  deriveExecutionRole
+} from "./chunk-H7IXIC72.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/scout-transition.ts
+init_esm_shims();
+function scopeFor(authority) {
+  return authority === "read-only" || authority === "verification" ? "readonly" : "workspace";
+}
+function assertReceiptDigest(value) {
+  if (!/^[0-9a-f]{64}$/u.test(value)) throw new Error("scout transition: source receipt digest is invalid");
+}
+function compileScoutTransition(input) {
+  assertReceiptDigest(input.sourceReceiptDigest);
+  if (!input.scout.needsSplit) {
+    return {
+      kind: "settled",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      findings: input.scout.findings.map((finding) => ({ ...finding }))
+    };
+  }
+  const subtasks = input.scout.proposedSubtasks;
+  const byId = new Map(input.bindings.map((binding) => [binding.subtaskId, binding]));
+  if (byId.size !== input.bindings.length || byId.size !== subtasks.length) {
+    throw new Error("scout transition: coordinator bindings must match subtasks exactly");
+  }
+  for (const binding of input.bindings) {
+    if (!subtasks.some((subtask) => subtask.id === binding.subtaskId)) {
+      throw new Error(`scout transition: undeclared binding '${binding.subtaskId}'`);
+    }
+  }
+  const approved = new Set(input.authority.approvedAuthorities);
+  const missing = /* @__PURE__ */ new Set();
+  const steps = subtasks.map((subtask) => {
+    const binding = byId.get(subtask.id);
+    if (binding === void 0) throw new Error(`scout transition: subtask '${subtask.id}' has no agent binding`);
+    if (binding.spec.resultContract.kind !== subtask.expectedResultContract) {
+      throw new Error(`scout transition: subtask '${subtask.id}' result contract does not match its bound agent`);
+    }
+    if (binding.spec.capabilityClass !== subtask.requestedAuthority) {
+      throw new Error(`scout transition: subtask '${subtask.id}' authority does not match its bound agent`);
+    }
+    const granted = approved.has(subtask.requestedAuthority);
+    if (!granted) missing.add(subtask.requestedAuthority);
+    return {
+      id: subtask.id,
+      agentId: binding.spec.id,
+      executionRole: deriveExecutionRole({
+        attempt: 0,
+        capabilityClass: binding.spec.capabilityClass,
+        resultContractKind: binding.spec.resultContract.kind
+      }),
+      scope: scopeFor(subtask.requestedAuthority),
+      expectedResultContract: subtask.expectedResultContract,
+      requestedAuthority: subtask.requestedAuthority,
+      approvedAuthority: granted ? subtask.requestedAuthority : null,
+      dependencies: [...subtask.dependencies],
+      task: subtask.task
+    };
+  });
+  const plan = compileExecutionPlan({
+    topology: "fleet",
+    rootTask: input.rootTask,
+    maxWorkers: Math.max(1, Math.min(4, input.maxWorkers, steps.length)),
+    onFailure: "stop",
+    steps
+  });
+  if (missing.size > 0) {
+    return {
+      kind: "approval-required",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      plan,
+      requiredAuthorities: [...missing]
+    };
+  }
+  return {
+    kind: "ready",
+    sourceReceiptDigest: input.sourceReceiptDigest,
+    plan,
+    authority: {
+      basis: input.authority.basis,
+      approvedAuthorities: [...input.authority.approvedAuthorities]
+    }
+  };
+}
+
+export {
+  compileScoutTransition
+};
+//# sourceMappingURL=chunk-OQBA45DZ.js.map

package/dist/{chunk-LU7P4LHA.js → chunk-P3FOHJT4.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   openAuthStorage
-} from "./chunk-EQ63NRB7.js";
+} from "./chunk-BBVYXMFO.js";
 import {
   getRuntimeRegistry
 } from "./chunk-NUGM5KR6.js";
@@ -30,4 +30,4 @@ function credentialsPresent() {
 export {
   credentialsPresent
 };
-//# sourceMappingURL=chunk-LU7P4LHA.js.map
+//# sourceMappingURL=chunk-P3FOHJT4.js.map

package/dist/chunk-PMZCIOCJ.js

@@ -0,0 +1,25 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/interactive/pane-policy.ts
+init_esm_shims();
+var WATCHABLE_STATUSES = /* @__PURE__ */ new Set(["running", "stale", "cancelling", "enqueued", "retrying"]);
+function paneWatchDecision(request) {
+  if (request.source === "dispatch") {
+    return { open: false, reason: "dispatches run headless; watch a run from the workers view or /panes show" };
+  }
+  if (!WATCHABLE_STATUSES.has(request.runStatus)) {
+    return {
+      open: false,
+      reason: `run is ${request.runStatus}; use \`clio-coder fleet view <runId>\` for the post-mortem`
+    };
+  }
+  return { open: true };
+}
+
+export {
+  paneWatchDecision
+};
+//# sourceMappingURL=chunk-PMZCIOCJ.js.map

package/dist/{chunk-I4HZDVNP.js → chunk-PQEFIJ36.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   resolveClioDirs
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -70,4 +70,4 @@ export {
   workerCompileCacheEnvironment,
   deleteInjectedCompileCacheFrom
 };
-//# sourceMappingURL=chunk-I4HZDVNP.js.map
+//# sourceMappingURL=chunk-PQEFIJ36.js.map

package/dist/{chunk-J3YUBZWY.js → chunk-QBJA7R7N.js}

@@ -3,7 +3,10 @@ import {
   fleetLoopCheckStepId,
   fleetLoopRepairStepId,
   fleetStepWriteBoundary
-} from "./chunk-E77JEWSD.js";
+} from "./chunk-CTJ4RNAA.js";
+import {
+  resultContractShape
+} from "./chunk-DYJP44XW.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -45,11 +48,23 @@ function executionPlanWaves(steps, maxWorkers) {
     const ready = steps.filter((step) => remaining.has(step.id) && step.dependencies.every((id) => completed.has(id)));
     if (ready.length === 0) throw new Error("execution plan: dependency cycle detected");
     const codeReady = ready.filter((step) => step.kind === "code").map((step) => step.id);
-    const agentReady = ready.filter((step) => step.kind !== "code").map((step) => step.id);
+    const agentReady = ready.filter((step) => step.kind !== "code");
     const chunks = [];
-    for (let offset = 0; offset < agentReady.length; offset += maxWorkers) {
-      chunks.push(agentReady.slice(offset, offset + maxWorkers));
+    let chunk = [];
+    let endpointCounts = /* @__PURE__ */ new Map();
+    for (const step of agentReady) {
+      const endpoint = step.endpoint;
+      const endpointLimit = endpoint === void 0 ? Number.POSITIVE_INFINITY : Math.max(1, endpoint.limit - (endpoint.foregroundHeld ?? 0));
+      const endpointFull = endpoint !== void 0 && (endpointCounts.get(endpoint.key) ?? 0) >= endpointLimit;
+      if (chunk.length >= maxWorkers || endpointFull) {
+        chunks.push(chunk);
+        chunk = [];
+        endpointCounts = /* @__PURE__ */ new Map();
+      }
+      chunk.push(step.id);
+      if (endpoint !== void 0) endpointCounts.set(endpoint.key, (endpointCounts.get(endpoint.key) ?? 0) + 1);
     }
+    if (chunk.length > 0) chunks.push(chunk);
     if (chunks.length === 0) chunks.push([]);
     chunks[0] = [...codeReady, ...chunks[0] ?? []];
     for (const wave of chunks) {
@@ -139,6 +154,21 @@ function compileExecutionPlan(input) {
   };
   return { ...canonical, hash: createHash("sha256").update(JSON.stringify(canonical)).digest("hex") };
 }
+function bindExecutionPlanEndpoints(plan, bindings) {
+  return compileExecutionPlan({
+    topology: plan.topology,
+    rootTask: plan.rootTask,
+    maxWorkers: plan.maxWorkers,
+    ...plan.writers === 1 ? { writers: 1 } : {},
+    onFailure: plan.onFailure,
+    steps: plan.steps.map((step) => {
+      if (step.kind === "code") return step;
+      const endpoint = bindings[step.id];
+      return endpoint === void 0 ? step : { ...step, endpoint: { ...endpoint } };
+    }),
+    loops: plan.loops
+  });
+}
 function executionPlanAncestors(plan, stepId) {
   const byId = new Map(plan.steps.map((step) => [step.id, step]));
   const ancestors = /* @__PURE__ */ new Set();
@@ -185,6 +215,31 @@ function spliceExecutionPlan(plan, parentId, tasks) {
 
 // src/domains/dispatch/fleet-plan.ts
 init_esm_shims();
+
+// src/domains/dispatch/fleet-node-prompt.ts
+init_esm_shims();
+function fleetNodeAnswerDirective(kind) {
+  if (kind === "architect-plan") return null;
+  return [
+    `Your result contract for this step is \`${kind}\`.`,
+    "The task above describes the whole chain. Any result shape it states belongs to the step that produces it, and does not apply to you.",
+    `End with exactly this shape and nothing else: ${resultContractShape({ kind })}`,
+    // The wire example carries literal names and evidence, and a small model
+    // handed one on a first attempt copies them: the first run of this
+    // directive came back claiming `npm run typecheck` / `exit 0` in the same
+    // breath as admitting it could not run a command. The fields are the
+    // contract; the values in the example are not.
+    "Its field values are an example. Fill them with what this run actually produced or observed, and never report a name or evidence you did not."
+  ].join("\n");
+}
+function renderFleetNodeTask(task, kind) {
+  const directive = fleetNodeAnswerDirective(kind);
+  return directive === null ? task : `${task}
+
+${directive}`;
+}
+
+// src/domains/dispatch/fleet-plan.ts
 function expandDependencies(dependencies, loopMembers) {
   return dependencies.flatMap((id) => {
     const loop = loopMembers.get(id);
@@ -233,7 +288,7 @@ function compileFleetExecutionPlan(input) {
       agentId: context.agentId,
       scope: context.scope,
       dependencies: [...dependencies],
-      task,
+      task: renderFleetNodeTask(task, resolved.expectedResultContract),
       expectedResultContract: resolved.expectedResultContract,
       requestedAuthority: resolved.requestedAuthority,
       approvedAuthority: resolved.approvedAuthority,
@@ -375,8 +430,9 @@ function compileFleetExecutionPlan(input) {
 export {
   requireAgentSteps,
   compileExecutionPlan,
+  bindExecutionPlanEndpoints,
   executionPlanAncestors,
   spliceExecutionPlan,
   compileFleetExecutionPlan
 };
-//# sourceMappingURL=chunk-J3YUBZWY.js.map
+//# sourceMappingURL=chunk-QBJA7R7N.js.map