@mmerterden/multi-agent-pipeline 20.23.2 → 20.25.0

package/pipeline/scripts/_transcript-hosts.mjs

@@ -0,0 +1,406 @@
+/**
+ * @file _transcript-hosts.mjs  -  Copilot CLI and Codex session logs, read as
+ * the Claude Code records transcript-index.mjs already understands.
+ *
+ * Each host writes a different JSONL:
+ *
+ *   claude   ~/.claude/projects/<cwd slug>/<session>.jsonl: `type` user /
+ *            assistant / system, the message under `message`
+ *   copilot  ~/.copilot/session-state/<session>/events.jsonl: dotted event
+ *            types (`session.start`, `assistant.message`,
+ *            `tool.execution_complete`, ...), the body under `data`
+ *   codex    ~/.codex/sessions/YYYY/MM/DD/rollout-<time>-<session>.jsonl:
+ *            `type` session_meta / response_item / event_msg / compacted /
+ *            turn_context, the body under `payload`
+ *
+ * detectFormat() names the format from one record. createAdapter() returns a
+ * function that turns each record of a file into zero or more records in the
+ * Claude Code shape, so the indexer has one reading loop and every finding
+ * still cites the line of the file it came from. Two record kinds exist only
+ * here and are handled by the indexer directly:
+ *
+ *   x-usage   token use the host reports outside a message (Codex
+ *             token_count, Copilot CLI's shutdown totals)
+ *   a user record with `subagentStats`, carrying a background subagent's
+ *             tokens and duration with its completion notice
+ *
+ * A tool result may carry `denied: true` when the host marks a refusal with a
+ * code rather than a message.
+ *
+ * @module pipeline/scripts/_transcript-hosts
+ */
+
+const CODEX_TYPES = new Set([
+  "session_meta",
+  "response_item",
+  "event_msg",
+  "compacted",
+  "turn_context",
+]);
+
+/** "claude", "copilot" or "codex" for one parsed record. */
+export function detectFormat(rec) {
+  if (!rec || typeof rec !== "object") return "claude";
+  if (
+    typeof rec.type === "string" &&
+    rec.type.includes(".") &&
+    rec.data &&
+    typeof rec.data === "object"
+  )
+    return "copilot";
+  if (CODEX_TYPES.has(rec.type) && rec.payload && typeof rec.payload === "object") return "codex";
+  return "claude";
+}
+
+const asObject = (raw) => {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw !== "string") return {};
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" && !Array.isArray(v) ? v : { arguments: raw };
+  } catch {
+    return { arguments: raw };
+  }
+};
+
+const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+
+/** A prompt as the indexer reads it: a leading slash command becomes a command record. */
+function promptRecord(timestamp, text) {
+  const t = String(text ?? "");
+  const slash = t.trim().match(/^(\/[^\s<]+)/);
+  const content = slash ? `<command-name>${slash[1]}</command-name>` : t;
+  return { type: "user", timestamp, message: { role: "user", content } };
+}
+
+const interrupt = (timestamp, reason) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: `[Request interrupted by user]${reason ? ` (${reason})` : ""}`,
+  },
+});
+
+const toolResult = (timestamp, id, body, isError, extra = {}) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: id,
+        content: body,
+        is_error: isError,
+        ...(extra.denied ? { denied: true } : {}),
+      },
+    ],
+  },
+  ...(extra.toolUseResult !== undefined ? { toolUseResult: extra.toolUseResult } : {}),
+});
+
+const notice = (timestamp, id, status, stats) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: `<task-notification><task-id>${id}</task-id><status>${status}</status></task-notification>`,
+  },
+  subagentStats: stats,
+});
+
+// --- Copilot CLI -----------------------------------------------------------------
+
+const COPILOT_SUBAGENT_TOOL = "task";
+const COPILOT_DENIAL_CODES = new Set(["denied", "rejected"]);
+
+function copilotAdapter() {
+  const toolNames = new Map();
+  const finished = new Map();
+  const counted = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let shutdown = false;
+
+  const adapt = (rec) => {
+    const d = rec.data || {};
+    const ts = rec.timestamp;
+    switch (rec.type) {
+      case "user.message":
+        return [promptRecord(ts, d.content)];
+      case "assistant.message": {
+        const content = [];
+        if (typeof d.content === "string" && d.content.trim())
+          content.push({ type: "text", text: d.content });
+        for (const r of Array.isArray(d.toolRequests) ? d.toolRequests : []) {
+          if (!r || typeof r.name !== "string") continue;
+          if (r.toolCallId) toolNames.set(r.toolCallId, r.name);
+          content.push({
+            type: "tool_use",
+            id: r.toolCallId,
+            name: r.name,
+            input: asObject(r.arguments),
+          });
+        }
+        const out = num(d.outputTokens);
+        counted.output += out;
+        return [
+          {
+            type: "assistant",
+            timestamp: ts,
+            isSidechain: Boolean(d.parentToolCallId),
+            message: {
+              id: d.messageId,
+              role: "assistant",
+              content,
+              ...(d.outputTokens !== undefined ? { usage: { output_tokens: out } } : {}),
+            },
+          },
+        ];
+      }
+      case "tool.execution_complete": {
+        const ok = d.success !== false;
+        const body = ok
+          ? String(d.result?.content ?? "")
+          : String(d.error?.message ?? d.result?.content ?? "failed");
+        const denied = !ok && COPILOT_DENIAL_CODES.has(d.error?.code);
+        let toolUseResult;
+        if (toolNames.get(d.toolCallId) === COPILOT_SUBAGENT_TOOL) {
+          const stats = finished.get(d.toolCallId);
+          toolUseResult = stats
+            ? {
+                status: stats.status,
+                agentId: d.toolCallId,
+                totalTokens: stats.tokens,
+                totalDurationMs: stats.durationMs,
+                totalToolUseCount: stats.toolUses,
+              }
+            : { status: ok ? "async_launched" : "error", agentId: d.toolCallId };
+        }
+        return [toolResult(ts, d.toolCallId, body, !ok, { denied, toolUseResult })];
+      }
+      case "subagent.completed":
+      case "subagent.failed": {
+        const stats = {
+          status: rec.type === "subagent.failed" ? "failed" : "completed",
+          tokens: Number.isFinite(d.totalTokens) ? d.totalTokens : undefined,
+          durationMs: Number.isFinite(d.durationMs) ? d.durationMs : undefined,
+          toolUses: Number.isFinite(d.totalToolCalls) ? d.totalToolCalls : undefined,
+        };
+        finished.set(d.toolCallId, stats);
+        return [notice(ts, d.toolCallId, stats.status, stats)];
+      }
+      case "session.compaction_complete":
+        if (d.success === false)
+          return [{ type: "system", timestamp: ts, level: "error", content: "compaction failed" }];
+        return [
+          {
+            type: "system",
+            subtype: "compact_boundary",
+            timestamp: ts,
+            compactMetadata: { preTokens: d.preCompactionTokens },
+          },
+        ];
+      case "hook.end":
+        if (d.success !== false) return [];
+        return [
+          {
+            type: "system",
+            timestamp: ts,
+            hookErrors: [`${d.hookType || "hook"}: ${d.error?.message || "failed"}`],
+          },
+        ];
+      case "session.error":
+        return [
+          {
+            type: "system",
+            timestamp: ts,
+            level: "error",
+            content: `${d.errorType ? `${d.errorType}: ` : ""}${d.message || ""}`,
+          },
+        ];
+      case "abort":
+        return [interrupt(ts, d.reason)];
+      case "session.shutdown": {
+        shutdown = true;
+        const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        for (const m of Object.values(d.modelMetrics || {})) {
+          const u = m?.usage || {};
+          total.input += num(u.inputTokens);
+          total.output += num(u.outputTokens);
+          total.cacheRead += num(u.cacheReadTokens);
+          total.cacheWrite += num(u.cacheWriteTokens);
+        }
+        const add = {};
+        for (const k of Object.keys(total)) {
+          add[k] = Math.max(0, total[k] - counted[k]);
+          counted[k] += add[k];
+        }
+        return [
+          { type: "x-usage", timestamp: ts, usage: add, countsMessage: false, inTurn: false },
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+  // Input and cache tokens arrive only in session.shutdown; without it the
+  // session's usage is its output tokens alone.
+  adapt.usagePartial = () => !shutdown;
+  return adapt;
+}
+
+// --- Codex -------------------------------------------------------------------------
+
+const EXIT_CODE = /(?:^|\n)(?:Process exited with code|Exit code:?)\s*(-?\d+)/;
+const WALL_TIME = /(?:^|\n)Wall time:\s*([\d.]+)\s*seconds?/;
+
+function codexOutput(raw) {
+  if (typeof raw === "string") {
+    try {
+      const v = JSON.parse(raw);
+      if (v && typeof v === "object" && !Array.isArray(v) && ("output" in v || "metadata" in v)) {
+        const meta = v.metadata || {};
+        return {
+          text: String(v.output ?? ""),
+          exitCode: Number.isFinite(meta.exit_code) ? meta.exit_code : null,
+          durationMs: Number.isFinite(meta.duration_seconds)
+            ? Math.round(meta.duration_seconds * 1000)
+            : null,
+        };
+      }
+    } catch {
+      // Plain text output.
+    }
+    const code = raw.match(EXIT_CODE);
+    const wall = raw.match(WALL_TIME);
+    return {
+      text: raw,
+      exitCode: code ? Number(code[1]) : null,
+      durationMs: wall ? Math.round(Number(wall[1]) * 1000) : null,
+    };
+  }
+  if (Array.isArray(raw)) {
+    const text = raw
+      .map((b) => (typeof b === "string" ? b : typeof b?.text === "string" ? b.text : ""))
+      .filter(Boolean)
+      .join("\n");
+    return codexOutput(text);
+  }
+  if (raw && typeof raw === "object") return codexOutput(raw.content ?? JSON.stringify(raw));
+  return { text: "", exitCode: null, durationMs: null };
+}
+
+function codexInput(name, raw) {
+  const input = asObject(raw);
+  for (const k of ["command", "cmd"]) {
+    if (Array.isArray(input[k])) return { ...input, [k]: input[k].join(" ") };
+  }
+  return input;
+}
+
+function codexAdapter() {
+  let lastTotal = null;
+
+  const toolUse = (ts, id, name, input) => ({
+    type: "assistant",
+    timestamp: ts,
+    message: { role: "assistant", content: [{ type: "tool_use", id, name, input }] },
+  });
+
+  return (rec) => {
+    const p = rec.payload || {};
+    const ts = rec.timestamp;
+    if (rec.type === "compacted")
+      return [{ type: "system", subtype: "compact_boundary", timestamp: ts, compactMetadata: {} }];
+    if (rec.type === "event_msg") {
+      switch (p.type) {
+        case "user_message":
+          return [promptRecord(ts, p.message)];
+        case "token_count": {
+          const info = p.info;
+          const total = info?.total_token_usage?.total_tokens;
+          if (!info || total === lastTotal) return [];
+          lastTotal = total;
+          const u = info.last_token_usage || {};
+          const cached = num(u.cached_input_tokens);
+          return [
+            {
+              type: "x-usage",
+              timestamp: ts,
+              usage: {
+                input: Math.max(0, num(u.input_tokens) - cached),
+                output: num(u.output_tokens),
+                cacheRead: cached,
+                cacheWrite: num(u.cache_write_input_tokens),
+              },
+              countsMessage: true,
+              inTurn: true,
+            },
+          ];
+        }
+        case "error":
+          return [{ type: "system", timestamp: ts, level: "error", content: p.message || "" }];
+        case "turn_aborted":
+          return [interrupt(ts, p.reason)];
+        default:
+          return [];
+      }
+    }
+    if (rec.type !== "response_item") return [];
+    switch (p.type) {
+      case "message":
+        if (p.role !== "assistant") return [];
+        return [
+          {
+            type: "assistant",
+            timestamp: ts,
+            message: {
+              role: "assistant",
+              content: (Array.isArray(p.content) ? p.content : [])
+                .filter((b) => typeof b?.text === "string")
+                .map((b) => ({ type: "text", text: b.text })),
+            },
+          },
+        ];
+      case "function_call":
+        return [toolUse(ts, p.call_id, p.name, codexInput(p.name, p.arguments))];
+      case "custom_tool_call":
+        return [toolUse(ts, p.call_id, p.name, { input: String(p.input ?? "") })];
+      case "local_shell_call":
+        return [toolUse(ts, p.call_id, "local_shell", codexInput("local_shell", p.action || {}))];
+      case "web_search_call":
+        return [toolUse(ts, undefined, "web_search", { query: p.action?.query ?? "" })];
+      case "function_call_output":
+      case "custom_tool_call_output": {
+        const out = codexOutput(p.output);
+        const failed = (out.exitCode !== null && out.exitCode !== 0) || p.output?.success === false;
+        return [
+          toolResult(ts, p.call_id, out.text, failed, {
+            toolUseResult: out.durationMs !== null ? { durationMs: out.durationMs } : undefined,
+          }),
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+}
+
+/**
+ * The record converter for `format`: a function from one parsed record to the
+ * Claude Code records it stands for (often none). A Copilot CLI converter also
+ * has `usagePartial()`, true while the session has written no shutdown record.
+ */
+export function createAdapter(format) {
+  if (format === "copilot") return copilotAdapter();
+  if (format === "codex") return codexAdapter();
+  return (rec) => [rec];
+}
+
+/** The working directory a Copilot CLI or Codex session started in, from its opening record. */
+export function sessionCwd(rec) {
+  const format = detectFormat(rec);
+  if (format === "copilot" && rec.type === "session.start") return rec.data?.context?.cwd ?? null;
+  if (format === "codex" && rec.type === "session_meta") return rec.payload?.cwd ?? null;
+  return null;
+}

package/pipeline/scripts/analysis-story-tree.mjs

@@ -62,6 +62,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { hostCommand } from "../lib/user-facing.mjs";
 import { lockTimeoutFrom, updateJsonFileSync } from "../lib/json-file-lock.mjs";
+import { analyzeGraph, cyclicComponentOf } from "../lib/task-graph.mjs";
 import { resolveConstitution } from "./constitution.mjs";
 import { gateContext, recordQuietly } from "./gate-ledger.mjs";
 import {
@@ -170,6 +171,7 @@ export function identityLabel(prefix, docId, sourceIds) {
  *   issueTree.cloneLinkType      the link type between a story and its clones
  *   issueTree.storyPanels        story section panel colours, or false for none
  *   issueTree.subtaskRolesDeclined  the person chose no sub-tasks; do not ask again
+ *   issueTree.dependencyLinkType  the link type written for a story dependency
  */
 const ISSUE_TREE_SETTINGS = [
   "issueTree.enabled",
@@ -187,6 +189,7 @@ const ISSUE_TREE_SETTINGS = [
   "issueTree.cloneLinkType",
   "issueTree.storyPanels",
   "issueTree.subtaskRolesDeclined",
+  "issueTree.dependencyLinkType",
 ];
 
 function readPrefs() {
@@ -216,6 +219,100 @@ export function subtaskTypeFor(setting, role) {
   return null;
 }
 
+const DEPENDS_ON = /\bdepends on:([^|\n]*)/gi;
+
+/**
+ * The `Depends on: <ids>` clauses of a document's requirement rows.
+ *
+ * A clause belongs to the table row it sits in, in any cell, so a trailing
+ * column under any header works and so does a note appended to a cell. The
+ * row's subject is the first requirement id left once the clause is removed.
+ * Clauses outside a table row are not read: without a row there is no subject.
+ *
+ * `stripped` is the text with every read clause removed. Ids are defined by
+ * where they appear, so a reference left in place would define the id it
+ * points at, and a dependency on a requirement nobody wrote would plan a story
+ * for it instead of being reported.
+ *
+ * @returns {{deps: Map<string, Set<string>>, stripped: string}}
+ */
+export function dependencyClauses(text, corporate) {
+  const atom = corporate ? ATOM_CORP : ATOM_GLOBAL;
+  const deps = new Map();
+  const lines = text.split("\n");
+  for (const [i, line] of lines.entries()) {
+    if (!/^\s*\|/.test(line) || !/\bdepends on:/i.test(line)) continue;
+    const refs = [];
+    const rest = line.replace(DEPENDS_ON, (clause, ids) => {
+      const found = ids.match(atom);
+      if (!found) return clause;
+      refs.push(...found.map((x) => x.toUpperCase()));
+      return "";
+    });
+    const subject = (rest.match(atom) || [])[0]?.toUpperCase();
+    if (!subject || !refs.length) continue;
+    lines[i] = rest;
+    for (const r of refs) {
+      if (r === subject) continue;
+      if (!deps.has(subject)) deps.set(subject, new Set());
+      deps.get(subject).add(r);
+    }
+  }
+  return { deps, stripped: lines.join("\n") };
+}
+
+/**
+ * Requirement dependencies, read as story-to-story edges and checked as a
+ * graph. A story depends on another when one of its source ids depends on a
+ * source id of the other; two ids of one story give no edge. A dependency on
+ * an id no story covers, and a cycle between stories, are problems: the plan
+ * reports them and is not `ok`. An edge whose two stories sit in one strongly
+ * connected component carries `onCycle: true`; such an edge has no order to
+ * record, so it is never linked and never counted as a write.
+ */
+function storyDependencies(stories, reqDeps) {
+  const coverers = new Map();
+  for (const s of stories)
+    for (const id of s.sourceIds) {
+      if (!coverers.has(id)) coverers.set(id, []);
+      coverers.get(id).push(s);
+    }
+  const edges = new Map();
+  const missing = [];
+  for (const s of stories) {
+    for (const id of s.sourceIds) {
+      for (const dep of reqDeps.get(id) || []) {
+        const targets = coverers.get(dep);
+        if (!targets) {
+          missing.push({ id, dependsOn: dep });
+          continue;
+        }
+        for (const t of targets) {
+          if (t === s) continue;
+          const key = `${s.label}>${t.label}`;
+          if (!edges.has(key))
+            edges.set(key, { dependent: s.label, prerequisite: t.label, via: [] });
+          const via = `${dep} -> ${id}`;
+          if (!edges.get(key).via.includes(via)) edges.get(key).via.push(via);
+        }
+      }
+    }
+  }
+  for (const s of stories) {
+    const on = [...edges.values()].filter((e) => e.dependent === s.label);
+    if (on.length) s.dependsOn = on.map((e) => e.prerequisite);
+  }
+  const graph = stories.map((s) => ({ id: s.label, deps: s.dependsOn || [], status: "pending" }));
+  const { cycles } = analyzeGraph(graph);
+  const component = cyclicComponentOf(graph);
+  for (const e of edges.values()) {
+    const c = component.get(e.dependent);
+    if (c !== undefined && c === component.get(e.prerequisite)) e.onCycle = true;
+  }
+  const unique = [...new Map(missing.map((m) => [`${m.id}>${m.dependsOn}`, m])).values()];
+  return { edges: [...edges.values()], cycles, missing: unique };
+}
+
 /** Every open placeholder that makes a document unfit to become work. */
 export function openItems(text) {
   const found = [];
@@ -268,10 +365,11 @@ export function coverageOf(defined, nodes, corporate = false) {
   };
 }
 
-export function plan(text, prefs, { pageUrl = null } = {}) {
-  const fm = frontMatter(text);
+export function plan(source, prefs, { pageUrl = null } = {}) {
+  const fm = frontMatter(source);
   const profile = (fm.profile || "global").toLowerCase();
   const corporate = profile === "corporate";
+  const { deps: reqDeps, stripped: text } = dependencyClauses(source, corporate);
   const secs = sections(text);
 
   const atomRe = corporate ? ATOM_CORP : ATOM_GLOBAL;
@@ -423,6 +521,30 @@ export function plan(text, prefs, { pageUrl = null } = {}) {
   }
 
   const coverage = coverageOf(defined, stories, corporate);
+  const dependencies = reqDeps.size ? storyDependencies(stories, reqDeps) : null;
+  if (dependencies) {
+    const titleOf = new Map(stories.map((s) => [s.label, s.group]));
+    const linked = new Set(dependencies.edges.map((e) => `${e.dependent}>${e.prerequisite}`));
+    const isLoop = (c) => c.every((l, i) => linked.has(`${l}>${c[(i + 1) % c.length]}`));
+    const problems = [
+      ...dependencies.cycles.map((c) =>
+        isLoop(c)
+          ? `dependency cycle: ${[c[0], ...[...c].reverse()].map((l) => titleOf.get(l)).join(" -> ")}`
+          : `dependency cycle among: ${c.map((l) => titleOf.get(l)).join(", ")}`,
+      ),
+      ...dependencies.missing.map(
+        (m) => `${m.id} depends on ${m.dependsOn}, which no story covers`,
+      ),
+    ];
+    if (problems.length) {
+      coverage.dependencyProblems = problems;
+      if (coverage.verdict === "ok") coverage.verdict = "incomplete";
+      if (coverage.verdict === "incomplete" && !coverage.reason) {
+        coverage.reason = `${problems.length} dependency problem(s): ${problems.join("; ")}`;
+      }
+    }
+  }
+  const linkType = prefs.dependencyLinkType ?? "Blocks";
 
   return {
     document: {
@@ -447,12 +569,15 @@ export function plan(text, prefs, { pageUrl = null } = {}) {
       cloneLinkType: prefs.cloneLinkType ?? "Relates",
       storyPanels: prefs.storyPanels ?? null,
       subtaskRolesDeclined: prefs.subtaskRolesDeclined === true,
+      ...(dependencies || prefs.dependencyLinkType !== undefined
+        ? { dependencyLinkType: linkType }
+        : {}),
     },
     nodes: stories,
-    writeCount: stories.reduce(
-      (n, s) => n + 1 + s.subtasks.length + 2 * (s.clones?.length || 0),
-      0,
-    ),
+    ...(dependencies ? { dependencies } : {}),
+    writeCount:
+      stories.reduce((n, s) => n + 1 + s.subtasks.length + 2 * (s.clones?.length || 0), 0) +
+      (dependencies?.edges.filter((e) => !e.onCycle).length || 0),
   };
 }
 
@@ -461,7 +586,9 @@ export function plan(text, prefs, { pageUrl = null } = {}) {
  *
  * @returns {object}  a spec-consistency-gate result
  */
-function consistencyOf(text, nodes) {
+function consistencyOf(source, nodes) {
+  const corporate = (frontMatter(source).profile || "").toLowerCase() === "corporate";
+  const text = dependencyClauses(source, corporate).stripped;
   const constitution = resolveConstitution({
     repo: dirname(file),
     feature: frontMatter(text).feature || null,
@@ -606,12 +733,18 @@ async function main() {
   );
   if (c.uncovered.length) process.stdout.write(`  not in any story: ${c.uncovered.join(", ")}\n`);
   if (c.invented.length) process.stdout.write(`  cited but undefined: ${c.invented.join(", ")}\n`);
+  for (const p of c.dependencyProblems || []) process.stdout.write(`  ${p}\n`);
   const k = result.consistency;
   process.stdout.write(
     `consistency: ${k.verdict} (${k.advisory ? "advisory, " : ""}${consistencyDetail(k)})\n`,
   );
   for (const line of describe(k)) process.stdout.write(`${line}\n`);
-  process.stdout.write(`\n${result.writeCount} issue(s) would be created:\n`);
+  const linkCount =
+    result.nodes.reduce((n, s) => n + (s.clones?.length || 0), 0) +
+    (result.dependencies?.edges.filter((e) => !e.onCycle).length || 0);
+  process.stdout.write(
+    `\n${result.writeCount - linkCount} issue(s) and ${linkCount} link(s) would be created:\n`,
+  );
   for (const s of result.nodes) {
     process.stdout.write(`  ${result.prefsUsed.storyIssueType}  ${s.title}\n`);
     process.stdout.write(
@@ -635,6 +768,18 @@ async function main() {
       );
     }
   }
+  const d = result.dependencies;
+  if (d) {
+    const group = new Map(result.nodes.map((n) => [n.label, n.group]));
+    process.stdout.write(
+      `\ndependencies: ${d.edges.length} ${result.prefsUsed.dependencyLinkType} link(s), the prerequisite first:\n`,
+    );
+    for (const e of d.edges) {
+      process.stdout.write(
+        `  ${group.get(e.prerequisite)} -> ${group.get(e.dependent)}  (${e.via.join(", ")})  [${e.prerequisite} -> ${e.dependent}]${e.onCycle ? "  not linked: on a dependency cycle" : ""}\n`,
+      );
+    }
+  }
   // Every field's provenance, so a wrong setting is visible here rather than in
   // Jira after the writes have happened.
   process.stdout.write("\nfrom prefs.global.issueTree:\n");

package/pipeline/scripts/autopilot-publish.mjs

@@ -13,7 +13,9 @@
  *   1. The request, the state and the test log are read as bounded regular
  *      files (lib/regular-file.mjs): a FIFO, a device or an oversized file is
  *      refused, never read. The request is read once and validated in process
- *      (pr-request.mjs validatePrRequest) on those same bytes.
+ *      (pr-request.mjs validatePrRequest) on those same bytes. The state's
+ *      `decisions[]` is appended to the body as one redacted section
+ *      (lib/decisions.mjs), so the PR lists what the run chose unasked.
  *   2. The repository comes from the runner's own config (the queue item's
  *      `nameWithOwner`), never from the request. A request naming another
  *      repository is refused, not redirected. The base is the configured
@@ -104,6 +106,7 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 
+import { appendDecisionsSection } from "../lib/decisions.mjs";
 import { invokedDirectly } from "../lib/invoked-directly.mjs";
 import { scan } from "../lib/outbound-gate.mjs";
 import { prRequestPath, prRequestsDir, prVerdictPath } from "../lib/pr-request-location.mjs";
@@ -123,6 +126,7 @@ const GIT_TIMEOUT_MS = 60 * 1000;
 const NET_TIMEOUT_MS = 5 * 60 * 1000;
 // A valid request is at most a 256-character title and a 65536-character body.
 const REQUEST_MAX_BYTES = 1024 * 1024;
+const BODY_MAX_CHARS = 65536;
 const STATE_MAX_BYTES = 16 * 1024 * 1024;
 const LOG_MAX_BYTES = 64 * 1024 * 1024;
 const VERIFY_TIMEOUT_SEC = 30 * 60;
@@ -1268,6 +1272,13 @@ export async function publish({ sessionId, statePath, item, config, env = proces
     }
 
     req = readRequest(reqPath);
+    // What the run decided in place of a person goes into the PR it opens. The
+    // section is redacted when rendered and passes the outbound gate below with
+    // the rest of the body.
+    req = {
+      ...req,
+      body: appendDecisionsSection(req.body, state.decisions, { maxChars: BODY_MAX_CHARS }),
+    };
 
     const repoCfg = (config?.repos || []).find((r) => r && r.nameWithOwner === repo);
     if (!repo || !repoCfg)

package/pipeline/scripts/build-stack-plugins.mjs

@@ -177,9 +177,9 @@ for (const skill of allSkills) {
 // --- 2b. routing audit ---------------------------------------------------
 // The loop above adds a skill to EVERY plugin whose pattern matches, so a bare
 // substring alternative that also reads as a suffix of another stack's skill
-// name ships that skill into two plugins. `architecture` did that to
-// android-architecture and swift-architecture, which is how ai-backend-toolkit
-// came to carry Compose and SwiftUI guidance.
+// name ships that skill into two plugins. A bare `architecture` matches
+// android-architecture and swift-architecture, and would put Compose and
+// SwiftUI guidance into ai-backend-toolkit.
 //
 // --check-routing runs this audit alone. It reads nothing but the authoring
 // source in this repo, so CI can gate it without a checkout of the plugins repo.