@gobing-ai/spur 0.4.1 → 0.4.3

package/plugins/sp/lib/plan-projection.generated.mjs

@@ -1,3 +1,573 @@
+// packages/app/src/services/planning-admission.ts
+var NON_ABORTING_PREFLIGHT_CODES = new Set([
+  "L4.scenario-unverified",
+  "L4.verifying-incomplete-tasks"
+]);
+function classifyFeaturePreflightFindings(findings) {
+  const aborting = [];
+  const nonAborting = [];
+  for (const f of findings) {
+    if (f.severity === "error") {
+      if (NON_ABORTING_PREFLIGHT_CODES.has(f.code)) {
+        nonAborting.push(f);
+      } else {
+        aborting.push(f);
+      }
+    } else {
+      nonAborting.push(f);
+    }
+  }
+  return {
+    aborting,
+    nonAborting,
+    shouldAbort: aborting.length > 0
+  };
+}
+function quickReadiness(input) {
+  const status = (input.status ?? "").toLowerCase();
+  const operation = input.operation;
+  if (operation !== "run" && operation !== "refine" && operation !== "verify") {
+    return {
+      action: "invalid",
+      code: "IV",
+      reason: `quick-readiness: unknown operation '${operation}' (${input.wbs})`
+    };
+  }
+  if (input.filteredCount !== undefined) {
+    if (input.filteredCount < 0) {
+      return {
+        action: "invalid",
+        code: "IV",
+        reason: `quick-readiness: invalid negative filtered count '${input.filteredCount}' (${input.wbs})`
+      };
+    }
+    if (input.filteredCount === 0) {
+      return {
+        action: "skipped",
+        code: "EMPTY",
+        reason: `quick-readiness: empty status-filtered set — nothing to ${operation} (${input.wbs})`
+      };
+    }
+  }
+  if (status === "cancelled" || status === "done") {
+    if (operation === "verify" && input.force === true) {
+      return {
+        action: "runnable",
+        code: "FORCE",
+        reason: `quick-readiness: verify --force re-verification of ${status} task ${input.wbs}`
+      };
+    }
+    return {
+      action: "skipped",
+      code: status === "done" ? "DONE" : "CANCELLED",
+      reason: `quick-readiness: already ${status} — no ${operation} hop (${input.wbs})`
+    };
+  }
+  if (status === "blocked") {
+    return {
+      action: "blocked",
+      code: "BLK",
+      reason: `quick-readiness: blocked — human/handover first (${input.wbs})`
+    };
+  }
+  if (operation === "run" && input.dependencies && input.dependencies.length > 0) {
+    const unmet = input.dependencies.filter((d) => (input.depStatuses?.[d] ?? "missing").toLowerCase() !== "done");
+    if (unmet.length > 0) {
+      return {
+        action: "blocked",
+        code: "DEP",
+        reason: `quick-readiness: unmet deps — ${unmet.join(", ")} (${input.wbs})`,
+        unmetDeps: unmet
+      };
+    }
+  }
+  const required = input.requiredSections ?? [];
+  const present = input.presentSections ?? [];
+  const gaps = required.filter((s) => {
+    const finding = input.sectionFindings?.[s];
+    return !present.includes(s) || finding !== undefined && finding !== "";
+  });
+  if (operation === "refine") {
+    if (status !== "backlog" && status !== "todo") {
+      return {
+        action: "skipped",
+        code: "NONPLAN",
+        reason: `quick-readiness: refine targets backlog/todo only, not '${status}' (${input.wbs})`
+      };
+    }
+    return {
+      action: "runnable",
+      code: "OK",
+      reason: `quick-readiness: refine ready for ${input.wbs} (${gaps.length} planning gap(s) to fill)`
+    };
+  }
+  if (operation === "verify") {
+    if (status !== "testing" && status !== "wip") {
+      return {
+        action: "invalid",
+        code: "NOVERIFY",
+        reason: `quick-readiness: verify needs testing/wip, not '${status}' (${input.wbs})`
+      };
+    }
+    return {
+      action: "runnable",
+      code: "OK",
+      reason: `quick-readiness: verify ready for ${input.wbs}`
+    };
+  }
+  if (status !== "todo" && status !== "wip" && status !== "testing") {
+    return {
+      action: "invalid",
+      code: "NORUN",
+      reason: `quick-readiness: run needs todo/wip/testing, not '${status}' (${input.wbs})`
+    };
+  }
+  if (gaps.length > 0) {
+    return {
+      action: "needs-refinement",
+      code: "REFINE",
+      reason: `quick-readiness: implementation sections incomplete (${input.wbs})`,
+      gaps
+    };
+  }
+  return {
+    action: "runnable",
+    code: "OK",
+    reason: `quick-readiness: run ready for ${input.wbs}`
+  };
+}
+function preflightTask(input) {
+  const status = (input.status ?? "").toLowerCase();
+  const deps = input.dependencies ?? [];
+  const depStatuses = input.depStatuses ?? {};
+  if (status === "cancelled") {
+    return {
+      action: "skip",
+      code: "A9",
+      reason: `dev-next: cancelled — nothing to advance (${input.wbs})`
+    };
+  }
+  if (status === "done") {
+    return {
+      action: "skip",
+      code: "A8",
+      reason: `dev-next: already done — batch does not auto-wrap (${input.wbs})`
+    };
+  }
+  if (status === "blocked") {
+    return {
+      action: "skip",
+      code: "A7",
+      reason: `dev-next: blocked — do not launch pipeline; human/handover first (${input.wbs})`
+    };
+  }
+  if (status === "todo" || status === "backlog") {
+    const unmet = deps.filter((d) => {
+      const st = (depStatuses[d] ?? "missing").toLowerCase();
+      return st !== "done";
+    });
+    if (unmet.length > 0) {
+      return {
+        action: "skip",
+        code: "A2",
+        reason: `dev-next: blocked by deps — unmet: ${unmet.join(", ")} (${input.wbs})`,
+        unmetDeps: unmet
+      };
+    }
+  }
+  return { action: "run", code: "OK", reason: `preflight clear — launch task-pipeline for ${input.wbs}` };
+}
+// packages/app/src/workflow/run-summary.ts
+var zeroTokens = () => ({ input: 0, cacheCreate: 0, cacheRead: 0, output: 0 });
+function formatDuration(ms) {
+  const s = Math.round(ms / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const ss = String(s % 60).padStart(2, "0");
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${ss}` : `${m}:${ss}`;
+}
+function formatTokens(n) {
+  if (n >= 999500)
+    return `${(n / 1e6).toFixed(1)}M`;
+  return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+function formatTokenSplit(t) {
+  if (!t)
+    return "n/a";
+  const nonCached = t.input + t.cacheCreate + t.output;
+  return `${formatTokens(nonCached + t.cacheRead)} / ${formatTokens(nonCached)}`;
+}
+var OPERATOR_TOOLS = new Set(["AskUserQuestion", "ask_user_question"]);
+function isCompaction(row) {
+  return row.type === "compaction" || row.type === "system" && row.subtype === "compact_boundary";
+}
+function firstTextContent(row) {
+  const content = row.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return;
+  return content.find((b) => b.type === "text")?.text;
+}
+function skillInvocationPrompt(text) {
+  const name = /^\s*<skill name="([^"]+)"/.exec(text)?.[1];
+  if (name === undefined)
+    return;
+  const close = text.lastIndexOf("</skill>");
+  const args = close < 0 ? "" : text.slice(close + "</skill>".length).trim();
+  return args === "" ? `/${name}` : `/${name} ${args}`;
+}
+function promptText(row) {
+  if (row.type === "custom_message") {
+    if (row.display === false)
+      return;
+    const text = typeof row.content === "string" ? row.content.trim() : "";
+    return text === "" ? undefined : text;
+  }
+  if (row.type === "message") {
+    if (row.message?.role !== "user")
+      return;
+    const text = firstTextContent(row);
+    if (text === undefined)
+      return;
+    return skillInvocationPrompt(text) ?? text;
+  }
+  if (row.type !== "user" || row.isMeta || row.isCompactSummary)
+    return;
+  const content = row.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content) || content.some((b) => b.type === "tool_result"))
+    return;
+  return content.find((b) => b.type === "text")?.text;
+}
+function sumTokens(all) {
+  const total = zeroTokens();
+  for (const t of all)
+    for (const k of Object.keys(total))
+      total[k] += t[k];
+  return total;
+}
+function sumSpans(spans) {
+  return {
+    workMs: spans.reduce((n, s) => n + s.workMs, 0),
+    waitMs: spans.reduce((n, s) => n + s.waitMs, 0),
+    toolCalls: spans.reduce((n, s) => n + s.toolCalls, 0),
+    tokens: sumTokens(spans.map((s) => s.tokens))
+  };
+}
+var newAcc = (ts) => ({
+  last: ts,
+  askMs: 0,
+  asks: new Map,
+  toolIds: new Set,
+  messages: new Map,
+  compactions: 0
+});
+function accumulate(acc, row, ts) {
+  acc.last = Math.max(acc.last, ts);
+  if (row.type === "message") {
+    const m = row.message;
+    if (m?.role === "assistant") {
+      const blocks2 = Array.isArray(m.content) ? m.content : [];
+      for (const b of blocks2) {
+        if (b.type === "toolCall" && b.id) {
+          acc.toolIds.add(b.id);
+          if (b.name && OPERATOR_TOOLS.has(b.name))
+            acc.asks.set(b.id, ts);
+        }
+      }
+      const u2 = m.usage;
+      if (u2 && row.id)
+        acc.messages.set(row.id, {
+          input: u2.input ?? 0,
+          cacheCreate: u2.cacheWrite ?? 0,
+          cacheRead: u2.cacheRead ?? 0,
+          output: u2.output ?? 0
+        });
+    } else if (m?.role === "toolResult" && m.toolCallId && acc.asks.has(m.toolCallId)) {
+      acc.askMs += ts - (acc.asks.get(m.toolCallId) ?? ts);
+    }
+    return;
+  }
+  if (row.type === "compaction")
+    acc.compactions++;
+  const blocks = Array.isArray(row.message?.content) ? row.message.content : [];
+  for (const b of blocks) {
+    if (b.type === "tool_use" && b.id) {
+      acc.toolIds.add(b.id);
+      if (b.name && OPERATOR_TOOLS.has(b.name))
+        acc.asks.set(b.id, ts);
+    } else if (b.type === "tool_result" && b.tool_use_id && acc.asks.has(b.tool_use_id)) {
+      acc.askMs += ts - (acc.asks.get(b.tool_use_id) ?? ts);
+    }
+  }
+  const u = row.message?.usage;
+  if (row.type === "assistant" && u && row.message?.id) {
+    acc.messages.set(row.message.id, {
+      input: u.input_tokens ?? 0,
+      cacheCreate: u.cache_creation_input_tokens ?? 0,
+      cacheRead: u.cache_read_input_tokens ?? 0,
+      output: u.output_tokens ?? 0
+    });
+  }
+}
+var IDLE_GAP_MS = 300000;
+var SHELL_TOOLS = new Set(["bash", "shell", "exec", "exec_command", "run_command", "command"]);
+var SUBAGENT_TOOLS = new Set(["agent", "task", "invoke_subagent", "subagent", "dispatch_agent"]);
+var LOWERCASE_OPERATOR_TOOLS = new Set(["askuserquestion", "ask_user_question"]);
+var ACTOR_PRECEDENCE = ["operator", "subagent", "shell", "other"];
+function actorOf(tool) {
+  const t = tool.toLowerCase().replace(/[^a-z_]/g, "");
+  if (LOWERCASE_OPERATOR_TOOLS.has(t))
+    return "operator";
+  if (SUBAGENT_TOOLS.has(t))
+    return "subagent";
+  if (SHELL_TOOLS.has(t))
+    return "shell";
+  return "other";
+}
+function unionMs(spans, start, end) {
+  const clipped = spans.map(([a, b]) => [Math.max(a, start), Math.min(b, end)]).filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
+  let total = 0;
+  let cursor = Number.NaN;
+  let openUntil = Number.NaN;
+  for (const [a, b] of clipped) {
+    if (!Number.isFinite(cursor)) {
+      cursor = a;
+      openUntil = b;
+      continue;
+    }
+    if (a > openUntil) {
+      total += openUntil - cursor;
+      cursor = a;
+      openUntil = b;
+    } else {
+      openUntil = Math.max(openUntil, b);
+    }
+  }
+  if (Number.isFinite(cursor))
+    total += openUntil - cursor;
+  return total;
+}
+function subtract(spans, claimed) {
+  let free = spans;
+  for (const [ca, cb] of claimed) {
+    const next = [];
+    for (const [a, b] of free) {
+      if (cb <= a || ca >= b) {
+        next.push([a, b]);
+        continue;
+      }
+      if (ca > a)
+        next.push([a, ca]);
+      if (cb < b)
+        next.push([cb, b]);
+    }
+    free = next;
+  }
+  return free;
+}
+function actorSplit(rows, start, end) {
+  const empty = {
+    operatorMs: 0,
+    longestOperatorWaitMs: 0,
+    modelMs: 0,
+    shellMs: 0,
+    subagentMs: 0,
+    otherToolMs: 0,
+    idleMs: 0,
+    compactions: 0,
+    subagentErrors: 0
+  };
+  const window = end - start;
+  if (window <= 0)
+    return empty;
+  const calls = new Map;
+  const results = new Map;
+  const eventTs = [];
+  let compactions = 0;
+  for (const [row, ts] of rows) {
+    if (ts < start || ts > end)
+      continue;
+    eventTs.push(ts);
+    if (isCompaction(row))
+      compactions++;
+    const blocks = Array.isArray(row.message?.content) ? row.message?.content : [];
+    if (row.message?.role === "toolResult" && row.message.toolCallId !== undefined) {
+      results.set(row.message.toolCallId, { ts, isError: row.message.isError === true });
+    }
+    for (const b of blocks) {
+      if ((b.type === "tool_use" || b.type === "toolCall") && b.id !== undefined && b.name !== undefined) {
+        calls.set(b.id, { id: b.id, actor: actorOf(b.name), ts });
+      } else if (b.type === "tool_result" && b.tool_use_id !== undefined) {
+        results.set(b.tool_use_id, { ts, isError: b.is_error === true });
+      }
+    }
+  }
+  let subagentErrors = 0;
+  const resolved = [];
+  for (const call of calls.values()) {
+    const result = results.get(call.id);
+    if (result?.isError === true && call.actor === "subagent")
+      subagentErrors++;
+    resolved.push({ ...call, end: Math.min(result?.ts ?? end, end) });
+  }
+  const claimed = [];
+  const byActor = new Map;
+  for (const actor of ACTOR_PRECEDENCE) {
+    const mine = resolved.filter((r) => r.actor === actor).map((r) => [r.ts, r.end]);
+    const free = subtract(mine, claimed);
+    for (const span of free)
+      claimed.push(span);
+    const ms = unionMs(free, start, end);
+    byActor.set(actor, ms);
+    if (actor === "operator") {
+      empty.longestOperatorWaitMs = Math.max(0, ...mine.map(([a, b]) => b - a));
+    }
+  }
+  const boundaries = [...new Set([start, end, ...eventTs, ...claimed.flat()])].sort((a, b) => a - b);
+  const claimedSorted = [...claimed].sort((a, b) => a[0] - b[0]);
+  let idleMs = 0;
+  for (let i = 0;i < boundaries.length - 1; i++) {
+    const a = boundaries[i];
+    const b = boundaries[i + 1];
+    if (b - a < IDLE_GAP_MS)
+      continue;
+    if (claimedSorted.some(([ca, cb]) => ca < b && cb > a))
+      continue;
+    idleMs += b - a;
+  }
+  const accounted = (byActor.get("operator") ?? 0) + (byActor.get("subagent") ?? 0) + (byActor.get("shell") ?? 0) + (byActor.get("other") ?? 0) + idleMs;
+  return {
+    ...empty,
+    operatorMs: byActor.get("operator") ?? 0,
+    subagentMs: byActor.get("subagent") ?? 0,
+    shellMs: byActor.get("shell") ?? 0,
+    otherToolMs: byActor.get("other") ?? 0,
+    idleMs,
+    modelMs: Math.max(0, window - accounted),
+    compactions,
+    subagentErrors
+  };
+}
+function attemptWindow(attempts) {
+  const starts = attempts.map((a) => Date.parse(a.startedAt ?? "")).filter((n) => !Number.isNaN(n));
+  const ends = attempts.map((a) => Date.parse(a.completedAt ?? "")).filter((n) => !Number.isNaN(n));
+  return starts.length && ends.length ? [Math.min(...starts), Math.max(...ends)] : undefined;
+}
+function summaryRow(stage, status, span, measured) {
+  return {
+    stage,
+    status,
+    workMs: span.workMs,
+    waitMs: span.waitMs,
+    toolCalls: measured ? span.toolCalls : null,
+    tokens: measured ? span.tokens : null,
+    time: formatDuration(span.workMs),
+    wait: formatDuration(span.waitMs),
+    token: formatTokenSplit(measured ? span.tokens : null)
+  };
+}
+function buildRunSummary(rows, inputs, opts = {}) {
+  const { since, until } = opts;
+  const windows = [];
+  for (const { label, progress } of inputs) {
+    const states = (progress.states ?? []).flatMap((s) => {
+      const w = attemptWindow((s.actions ?? []).flatMap((a) => a.attempts ?? []));
+      return w ? [{ s, w }] : [];
+    });
+    if (!states.length)
+      throw new Error(`progress for run ${progress.runId} has no timed attempts`);
+    if (inputs.length === 1) {
+      for (const { s, w } of states) {
+        const stage = (s.visit ?? 1) > 1 ? `${s.state} (visit ${s.visit})` : s.state;
+        windows.push({ stage, status: s.status ?? "", start: w[0], end: w[1] });
+      }
+    } else {
+      const stage = label ?? `${progress.workflow ?? "run"} ${progress.runId.slice(0, 8)}`;
+      const start = Math.min(...states.map(({ w }) => w[0]));
+      windows.push({
+        stage,
+        status: progress.status ?? "",
+        start,
+        end: Math.max(...states.map(({ w }) => w[1]))
+      });
+    }
+  }
+  windows.sort((a, b) => a.start - b.start);
+  const measure = (start, end) => {
+    const acc = newAcc(start);
+    for (const [row, ts] of rows)
+      if (ts >= start && ts <= end && promptText(row) === undefined)
+        accumulate(acc, row, ts);
+    const span = {
+      workMs: end - start - acc.askMs,
+      waitMs: acc.askMs,
+      toolCalls: acc.toolIds.size,
+      tokens: sumTokens([...acc.messages.values()])
+    };
+    return { span, measured: acc.toolIds.size > 0 || acc.messages.size > 0 };
+  };
+  const sinceMs = since ? Date.parse(since) : Number.NaN;
+  const totalStart = Number.isNaN(sinceMs) ? Math.min(...windows.map((w) => w.start)) : sinceMs;
+  let totalEnd = Math.max(...windows.map((w) => w.end));
+  if (!Number.isNaN(sinceMs)) {
+    for (const [, ts] of rows)
+      if (ts >= sinceMs)
+        totalEnd = Math.max(totalEnd, ts);
+  }
+  const untilMs = until ? Date.parse(until) : Number.NaN;
+  if (!Number.isNaN(untilMs) && untilMs > totalStart)
+    totalEnd = untilMs;
+  const stageRows = windows.map((w) => {
+    const { span, measured } = measure(w.start, w.end);
+    return summaryRow(w.stage, w.status, span, measured);
+  });
+  const totalMeasure = measure(totalStart, totalEnd);
+  const statuses = [...new Set(inputs.map((i) => i.progress.status ?? ""))].join("/");
+  const total = summaryRow("Total", statuses, totalMeasure.span, totalMeasure.measured);
+  const overlaps = windows.some((w, i) => i > 0 && w.start < (windows[i - 1]?.end ?? 0));
+  const sum = sumSpans(stageRows.map((r) => ({ ...r, toolCalls: r.toolCalls ?? 0, tokens: r.tokens ?? zeroTokens() })));
+  const overhead = {
+    workMs: total.workMs - sum.workMs,
+    waitMs: total.waitMs - sum.waitMs,
+    toolCalls: (total.toolCalls ?? 0) - sum.toolCalls,
+    tokens: Object.fromEntries(Object.keys(sum.tokens).map((k) => [k, (total.tokens?.[k] ?? 0) - sum.tokens[k]]))
+  };
+  if (!overlaps && overhead.workMs > 0)
+    stageRows.push(summaryRow("driver overhead", "", overhead, totalMeasure.measured));
+  return {
+    available: true,
+    rows: stageRows,
+    total,
+    actors: actorSplit(rows, totalStart, totalEnd),
+    gate: { ms: null, reason: "no matching check receipt" },
+    skippedLines: opts.skippedLines ?? 0
+  };
+}
+// packages/app/src/workflow/task-triage.ts
+var SENSITIVE_PREFIXES = ["drizzle/", "packages/config/", ".github/", "plugins/sp/hooks/"];
+var SENSITIVE_GLOBS = ["apps/server/src/**/auth*", "**/*secret*", "**/*.sql"];
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*");
+  return new RegExp(`^${escaped}$`, "s");
+}
+var SENSITIVE_MATCHERS = [
+  ...SENSITIVE_PREFIXES.map((prefix) => ({
+    label: prefix,
+    test: (path) => path.startsWith(prefix)
+  })),
+  ...SENSITIVE_GLOBS.map((glob) => {
+    const regex = globToRegex(glob);
+    return { label: glob, test: (path) => regex.test(path) };
+  })
+];
+function sensitiveReasonForPath(path) {
+  const match = SENSITIVE_MATCHERS.find((entry) => entry.test(path));
+  return match ? `matches sensitive pattern ${match.label}` : null;
+}
+
 // packages/app/src/workflow/plan-projection.ts
 function planLetter(index) {
   if (!Number.isInteger(index) || index < 0 || index > 25) {
@@ -216,6 +786,118 @@ function buildBatchPlan(tasks) {
   }
   return waves;
 }
+var byWbs = (a, b) => a.localeCompare(b, "en", { numeric: true });
+function kahnOrder(nodes, preds) {
+  const indegree = new Map(nodes.map((n) => [n, preds.get(n)?.size ?? 0]));
+  const succ = new Map(nodes.map((n) => [n, []]));
+  for (const [n, ps] of preds)
+    for (const p of ps)
+      succ.get(p)?.push(n);
+  const ready = nodes.filter((n) => indegree.get(n) === 0).sort(byWbs);
+  const order = [];
+  for (let n = ready.shift();n !== undefined; n = ready.shift()) {
+    order.push(n);
+    for (const s of succ.get(n) ?? []) {
+      const d = (indegree.get(s) ?? 0) - 1;
+      indegree.set(s, d);
+      if (d === 0) {
+        ready.push(s);
+        ready.sort(byWbs);
+      }
+    }
+  }
+  return order;
+}
+function findCycle(remaining, preds) {
+  const state = new Map;
+  const stack = [];
+  const visit = (n) => {
+    state.set(n, "visiting");
+    stack.push(n);
+    for (const p of [...preds.get(n) ?? []].sort(byWbs)) {
+      if (!remaining.has(p))
+        continue;
+      if (state.get(p) === "visiting")
+        return [...stack.slice(stack.indexOf(p)), p];
+      if (!state.has(p)) {
+        const cycle = visit(p);
+        if (cycle)
+          return cycle;
+      }
+    }
+    stack.pop();
+    state.set(n, "done");
+    return null;
+  };
+  for (const n of [...remaining].sort(byWbs)) {
+    if (state.has(n))
+      continue;
+    const cycle = visit(n);
+    if (cycle)
+      return cycle;
+  }
+  return [];
+}
+function scheduleBatch(tasks, opts = {}) {
+  const byId = new Map;
+  for (const t of tasks)
+    if (!byId.has(t.wbs))
+      byId.set(t.wbs, t);
+  const nodes = [...byId.keys()].sort(byWbs);
+  const preds = new Map(nodes.map((n) => [n, new Set((byId.get(n)?.dependencies ?? []).filter((d) => byId.has(d)))]));
+  const depOrder = kahnOrder(nodes, preds);
+  if (depOrder.length < nodes.length) {
+    const cycle = findCycle(new Set(nodes.filter((n) => !depOrder.includes(n))), preds);
+    return {
+      order: [],
+      waves: [],
+      cycle,
+      overlaps: [],
+      mode: "sequential",
+      reason: `dependency cycle ${cycle.join(" → ")}`
+    };
+  }
+  const files = new Map(nodes.map((n) => [n, new Set((byId.get(n)?.files ?? []).map(normalizeTaskPath))]));
+  const overlaps = [];
+  for (let i = 0;i < depOrder.length; i++) {
+    const before = depOrder[i];
+    const beforeFiles = files.get(before) ?? new Set;
+    for (const after of depOrder.slice(i + 1)) {
+      const shared = [...beforeFiles].filter((f) => files.get(after)?.has(f)).sort();
+      if (shared.length === 0)
+        continue;
+      overlaps.push({ before, after, files: shared });
+      preds.get(after)?.add(before);
+    }
+  }
+  const order = kahnOrder(nodes, preds);
+  const level = new Map;
+  for (const n of order) {
+    let l = 0;
+    for (const p of preds.get(n) ?? [])
+      l = Math.max(l, (level.get(p) ?? 0) + 1);
+    level.set(n, l);
+  }
+  const waves = [];
+  for (const n of order) {
+    const l = level.get(n) ?? 0;
+    waves[l] = [...waves[l] ?? [], n].sort(byWbs);
+  }
+  const widest = Math.max(0, ...waves.map((w) => w.length));
+  const concurrency = opts.concurrency ?? 2;
+  let reason = `widest wave holds ${widest} independent tasks`;
+  if (nodes.length < 2)
+    reason = "fewer than two tasks";
+  else if (concurrency < 2)
+    reason = "concurrency is 1";
+  else if (widest < 2)
+    reason = "every wave holds one task (dependency or file-overlap chain)";
+  const mode = nodes.length >= 2 && concurrency >= 2 && widest >= 2 ? "parallel" : "sequential";
+  return { order, waves, cycle: null, overlaps, mode, reason };
+}
+function normalizeTaskPath(path) {
+  return path.trim().replace(/^\.\//, "");
+}
 function taskPhaseChildren(taskLetter, plan) {
   if (!Array.isArray(plan))
     return [];
@@ -243,13 +925,34 @@ function hostText(item) {
   return hostDecided ? `${item.text} [${item.outcome}]` : item.text;
 }
 export {
+  zeroTokens,
   validatePhaseTable,
   taskPhaseChildren,
+  sumTokens,
+  sumSpans,
+  skillInvocationPrompt,
+  sensitiveReasonForPath,
+  scheduleBatch,
+  quickReadiness,
+  promptText,
+  preflightTask,
   planLetter,
   planChild,
+  newAcc,
+  isCompaction,
   insertOnEntry,
   hostText,
   hostStatus,
+  formatTokens,
+  formatTokenSplit,
+  formatDuration,
+  classifyFeaturePreflightFindings,
+  buildRunSummary,
   buildPhasedPlan,
-  buildBatchPlan
+  buildBatchPlan,
+  actorSplit,
+  accumulate,
+  SENSITIVE_PREFIXES,
+  SENSITIVE_GLOBS,
+  NON_ABORTING_PREFLIGHT_CODES
 };