karajan-code 4.70.4 → 5.0.1

package/src/agents/model-registry.js

@@ -1,142 +0,0 @@
-const modelRegistry = new Map();
-
-export function registerModel(name, { provider, pricing, deprecated } = {}) {
-	if (!name || typeof name !== "string") {
-		throw new Error("Model name must be a non-empty string");
-	}
-	if (!pricing || typeof pricing.input_per_million !== "number" || typeof pricing.output_per_million !== "number") {
-		throw new Error(`Model "${name}" requires pricing with input_per_million and output_per_million`);
-	}
-	modelRegistry.set(name, {
-		name,
-		provider: provider || name.split("/")[0],
-		pricing: { input_per_million: pricing.input_per_million, output_per_million: pricing.output_per_million },
-		deprecated: deprecated || null,
-	});
-}
-
-export function registerModelAlias(alias, target, { provider } = {}) {
-	const entry = modelRegistry.get(target);
-	if (!entry) {
-		throw new Error(`Target model "${target}" for alias "${alias}" not found`);
-	}
-	modelRegistry.set(alias, {
-		...entry,
-		name: alias,
-		provider: provider || entry.provider
-	});
-}
-
-export function getModelPricing(name) {
-	const entry = modelRegistry.get(name);
-	return entry ? { ...entry.pricing } : null;
-}
-
-export function isModelDeprecated(name) {
-	const entry = modelRegistry.get(name);
-	if (!entry?.deprecated) return false;
-	return new Date(entry.deprecated) <= new Date();
-}
-
-export function getModelInfo(name) {
-	const entry = modelRegistry.get(name);
-	if (!entry) return null;
-	return { name: entry.name, provider: entry.provider, pricing: { ...entry.pricing }, deprecated: entry.deprecated };
-}
-
-export function getRegisteredModels() {
-	return [...modelRegistry.entries()].map(([_name, entry]) => ({
-		name: entry.name,
-		provider: entry.provider,
-		pricing: { ...entry.pricing },
-		deprecated: entry.deprecated,
-	}));
-}
-
-export function buildDefaultPricingTable() {
-	const table = {};
-	for (const [name, entry] of modelRegistry) {
-		table[name] = { ...entry.pricing };
-	}
-	return table;
-}
-
-/**
- * Anthropic Claude Family
- * Pricing & Info: https://platform.claude.com/docs/en/about-claude/pricing
- */
-registerModel("claude-opus-4.6", { provider: "anthropic", pricing: { input_per_million: 5.0, output_per_million: 25.0 } });
-registerModel("claude-sonnet-4.6", { provider: "anthropic", pricing: { input_per_million: 3.0, output_per_million: 15.0 } });
-registerModel("claude-haiku-4.5", { provider: "anthropic", pricing: { input_per_million: 1.0, output_per_million: 5.0 } });
-
-// Default models & General aliases
-registerModel("claude", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
-registerModel("sonnet", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
-registerModel("opus", { provider: "anthropic", pricing: { input_per_million: 15, output_per_million: 75 } });
-registerModel("haiku", { provider: "anthropic", pricing: { input_per_million: 0.25, output_per_million: 1.25 } });
-
-/**
- * OpenAI GPT Family
- * Pricing: https://developers.openai.com/api/docs/pricing
- */
-registerModel("gpt-5.4-standard", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
-registerModel("gpt-5.4-thinking", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
-registerModel("gpt-5.4-pro", { provider: "openai", pricing: { input_per_million: 30.0, output_per_million: 180.0 } });
-registerModel("gpt-5.4-mini", { provider: "openai", pricing: { input_per_million: 0.75, output_per_million: 4.5 } });
-
-// Default models & General aliases
-registerModel("codex", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
-// KJC-TSK-0699: the models the codex CLI lists (0.146.1). List prices after the
-// 2026-07-30 cut; Sol at its base rate, not the temporary promotion.
-registerModel("gpt-5.6-sol", { provider: "openai", pricing: { input_per_million: 5.0, output_per_million: 30.0 } });
-registerModel("gpt-5.6-terra", { provider: "openai", pricing: { input_per_million: 2.0, output_per_million: 12.0 } });
-registerModel("gpt-5.6-luna", { provider: "openai", pricing: { input_per_million: 0.2, output_per_million: 1.2 } });
-registerModel("o4-mini", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
-registerModel("o3", { provider: "openai", pricing: { input_per_million: 10, output_per_million: 40 } });
-
-/**
- * Google Gemini Family
- * Pricing: https://ai.google.dev/gemini-api/docs/pricing
- */
-registerModel("gemini-3.1-pro-preview", { provider: "google", pricing: { input_per_million: 2.0, output_per_million: 12.0 } });
-registerModel("gemini-3.1-flash-lite", { provider: "google", pricing: { input_per_million: 0.25, output_per_million: 1.5 } });
-registerModel("gemini-3-flash-preview", { provider: "google", pricing: { input_per_million: 0.5, output_per_million: 3.0 } });
-registerModel("gemini-2.5-pro", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
-registerModel("gemini-2.0-flash", { provider: "google", pricing: { input_per_million: 0.075, output_per_million: 0.3 } });
-
-// Default models & General aliases
-registerModelAlias("gemini", "gemini-2.5-pro");
-
-/**
- * Other Providers & CLI Aliases
- */
-registerModel("aider", { provider: "aider", pricing: { input_per_million: 3, output_per_million: 15 } });
-registerModel("opencode", { provider: "opencode", pricing: { input_per_million: 0, output_per_million: 0 } });
-
-/**
- * Moonshot Kimi Family (KJC-TSK-0633) — consumed through OpenCode as an
- * OpenAI-compatible provider (docs/providers-via-opencode.md).
- * Pricing: https://platform.moonshot.ai/docs/pricing — verify before
- * trusting for billing decisions; ids/prices move fast.
- */
-registerModel("kimi-k2", { provider: "moonshot", pricing: { input_per_million: 0.6, output_per_million: 2.5 } });
-registerModel("kimi-k2-thinking", { provider: "moonshot", pricing: { input_per_million: 0.6, output_per_million: 2.5 } });
-registerModelAlias("kimi", "kimi-k2");
-// Prefixed ids as the documented opencode.json snippet produces them.
-registerModelAlias("kimi/kimi-k2", "kimi-k2");
-registerModelAlias("kimi/kimi-k2-thinking", "kimi-k2-thinking");
-
-/**
- * DeepSeek Family (KJC-TSK-0633) — same OpenCode route.
- * Pricing: https://api-docs.deepseek.com/quick_start/pricing
- */
-registerModel("deepseek-chat", { provider: "deepseek", pricing: { input_per_million: 0.28, output_per_million: 0.42 } });
-registerModel("deepseek-reasoner", { provider: "deepseek", pricing: { input_per_million: 0.28, output_per_million: 0.42 } });
-registerModelAlias("deepseek", "deepseek-chat");
-registerModelAlias("deepseek/deepseek-chat", "deepseek-chat");
-registerModelAlias("deepseek/deepseek-reasoner", "deepseek-reasoner");
-
-// Common CLI Aliases (with provider overrides)
-registerModelAlias("aider/claude-3-7-sonnet", "claude-sonnet-4.6", { provider: "aider" });
-registerModelAlias("aider/gpt-4o", "gpt-5.4-standard", { provider: "aider" });
-registerModelAlias("opencode/minimax-m2.5", "opencode", { provider: "opencode" });

package/src/audit/plan-adherence.js

@@ -1,224 +0,0 @@
-/**
- * Plan adherence metric — KJC-TSK-0376 (deepeval-inspired).
- * Pure offline 0-100 score: how faithfully did the coder follow the plan?
- * Components (weighted): commit_attribution 40%, acceptance_tests 30%,
- * scope_discipline 20%, dependency_order 10%. Components return null
- * when no data; aggregator redistributes the weight.
- * See docs/plan-adherence.md (PR-C) for the full spec.
- */
-
-import { escapeRegExp } from "../utils/escape-regexp.js";
-
-const WEIGHTS = {
-  commit_attribution: 40,
-  acceptance_tests: 30,
-  scope_discipline: 20,
-  dependency_order: 10,
-};
-
-/**
- * Build a regex that matches the HU id anywhere in a commit message
- * (case-insensitive, word-boundary friendly). The `_` and `-` characters
- * appear inside HU ids so we anchor on whole-token rather than \b.
- */
-function huIdMatcher(huId) {
-  const escaped = escapeRegExp(huId);
-  return new RegExp(`(^|[^a-z0-9])${escaped}([^a-z0-9]|$)`, "i");
-}
-
-/**
- * Slugify an HU title for branch-name / scope matching. Mirrors the
- * `buildHuBranchName` slug rule (lowercase, non-alnum → "-").
- */
-function slugify(text) {
-  return String(text || "")
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9]+/g, "-")
-    .replaceAll(/(^-+)|(-+$)/g, "");
-}
-
-/**
- * Try to attribute a single commit to one of the plan's HUs.
- *
- * Order of evidence, strongest first:
- *   1. The HU id appears in the commit message.
- *   2. The HU id appears in the branch name where the commit lives
- *      (commit.branch is supplied by listCommitsBetween's caller when
- *      it knows the per-HU branches).
- *   3. The HU title slug matches the commit message.
- *
- * Returns the matched huId, or null when none of the above fires.
- */
-export function attributeCommitToHu(commit, hus) {
-  if (!commit || !Array.isArray(hus) || hus.length === 0) return null;
-  const msg = String(commit.message || "");
-  const branch = String(commit.branch || "");
-  for (const hu of hus) {
-    if (!hu?.id) continue;
-    const matcher = huIdMatcher(hu.id);
-    if (matcher.test(msg)) return hu.id;
-    if (branch && matcher.test(branch)) return hu.id;
-  }
-  // Fallback: title slug
-  for (const hu of hus) {
-    const slug = slugify(hu.title);
-    if (!slug || slug.length < 6) continue;
-    if (slugify(msg).includes(slug)) return hu.id;
-  }
-  return null;
-}
-
-/**
- * Component 1: commit attribution. Returns null when the run produced
- * no commits at all (avoids penalising analysis-only or doc-only runs).
- */
-export function computeCommitAttribution(commits, plan) {
-  if (!Array.isArray(commits) || commits.length === 0) return null;
-  if (!plan?.hus || plan.hus.length === 0) return null;
-  let attributed = 0;
-  for (const commit of commits) {
-    if (attributeCommitToHu(commit, plan.hus)) attributed += 1;
-  }
-  return Math.round((attributed / commits.length) * 100);
-}
-
-/**
- * Component 2: acceptance test coverage. Heuristic: each HU declares
- * `acceptance_tests`. We check whether at least one commit from that
- * HU's pool has a `test:`-prefixed message. Per-HU score (1 or 0),
- * averaged across HUs that DO declare tests. Returns null when no HU
- * declares acceptance tests.
- */
-export function computeAcceptanceTestCoverage(commits, plan) {
-  if (!plan?.hus || plan.hus.length === 0) return null;
-  if (!Array.isArray(commits) || commits.length === 0) return null;
-  const husWithTests = plan.hus.filter(
-    (hu) => Array.isArray(hu?.acceptance_tests) && hu.acceptance_tests.length > 0,
-  );
-  if (husWithTests.length === 0) return null;
-
-  let covered = 0;
-  for (const hu of husWithTests) {
-    const huCommits = (commits || []).filter(
-      (c) => attributeCommitToHu(c, [hu]) === hu.id,
-    );
-    const hasTestCommit = huCommits.some((c) =>
-      /^test[:(]/i.test(String(c.message || "").trim()),
-    );
-    if (hasTestCommit) covered += 1;
-  }
-  return Math.round((covered / husWithTests.length) * 100);
-}
-
-/**
- * Component 3: scope discipline. For each file changed by the run, we
- * try to match it against at least one HU's id slug, title slug, or
- * `scope` text. A file that matches no HU is flagged as out-of-scope.
- * Returns null when the run changed no files.
- */
-export function computeScopeDiscipline(filesChanged, plan) {
-  if (!Array.isArray(filesChanged) || filesChanged.length === 0) return null;
-  if (!plan?.hus || plan.hus.length === 0) return null;
-  const huKeywords = plan.hus.map((hu) => ({
-    id: hu.id,
-    matchers: [
-      slugify(hu.id),
-      slugify(hu.title),
-      // Pull alpha-rich words from `scope` text (length >= 4).
-      ...String(hu.scope || "")
-        .toLowerCase()
-        .split(/[^a-z]+/)
-        .filter((w) => w.length >= 4),
-    ].filter(Boolean),
-  }));
-  let inScope = 0;
-  for (const file of filesChanged) {
-    const slug = slugify(file);
-    const matched = huKeywords.some((hk) =>
-      hk.matchers.some((m) => slug.includes(m) || file.includes(m)),
-    );
-    if (matched) inScope += 1;
-  }
-  return Math.round((inScope / filesChanged.length) * 100);
-}
-
-/**
- * Component 4: dependency order. For every `(parent, child)` edge
- * declared via `child.blocked_by`, check that the EARLIEST commit
- * attributed to `parent` is older than the EARLIEST commit attributed
- * to `child`. Returns null when no dependency edges exist.
- *
- * `commits` are expected oldest-first (the shape `listCommitsBetween`
- * returns). When that's not the case the score still makes sense — we
- * just compare relative positions in the array.
- */
-export function computeDependencyOrder(commits, plan) {
-  if (!plan?.hus || plan.hus.length === 0) return null;
-  const edges = [];
-  for (const hu of plan.hus) {
-    for (const parentId of hu.blocked_by || []) {
-      edges.push([parentId, hu.id]);
-    }
-  }
-  if (edges.length === 0) return null;
-  if (!Array.isArray(commits) || commits.length === 0) return null;
-
-  // Build huId → first commit index (oldest first attribution).
-  const firstIndex = new Map();
-  commits.forEach((commit, idx) => {
-    const huId = attributeCommitToHu(commit, plan.hus);
-    if (huId && !firstIndex.has(huId)) firstIndex.set(huId, idx);
-  });
-
-  let respected = 0;
-  let evaluable = 0;
-  for (const [parentId, childId] of edges) {
-    const p = firstIndex.get(parentId);
-    const c = firstIndex.get(childId);
-    if (p === undefined || c === undefined) continue; // can't evaluate
-    evaluable += 1;
-    if (p < c) respected += 1;
-  }
-  if (evaluable === 0) return null;
-  return Math.round((respected / evaluable) * 100);
-}
-
-/**
- * Aggregator: compute every component and weight them. Components
- * that return `null` are excluded and their weight redistributed
- * proportionally across the rest, so a run that legitimately has no
- * acceptance tests or no dependencies isn't penalised.
- *
- * Returns the full structured result (see file header for shape).
- */
-export function computePlanAdherenceScore({ commits, plan, filesChanged }) {
-  const breakdown = {
-    commit_attribution: computeCommitAttribution(commits, plan),
-    acceptance_tests: computeAcceptanceTestCoverage(commits, plan),
-    scope_discipline: computeScopeDiscipline(filesChanged, plan),
-    dependency_order: computeDependencyOrder(commits, plan),
-  };
-
-  // Weighted average over non-null components only.
-  let totalWeight = 0;
-  let weightedSum = 0;
-  for (const [key, weight] of Object.entries(WEIGHTS)) {
-    const value = breakdown[key];
-    if (value === null || value === undefined) continue;
-    totalWeight += weight;
-    weightedSum += value * weight;
-  }
-  const score = totalWeight === 0 ? null : Math.round(weightedSum / totalWeight);
-
-  // Per-HU detail: was the HU "touched" (attributed at least one commit)?
-  const hu_scores = (plan?.hus || []).map((hu) => {
-    const huCommits = (commits || []).filter(
-      (c) => attributeCommitToHu(c, [hu]) === hu.id,
-    );
-    const issues = [];
-    if (huCommits.length === 0) issues.push("no commit attributed");
-    return { huId: hu.id, attributed: huCommits.length > 0, issues };
-  });
-
-  return { score, breakdown, hu_scores };
-}

package/src/autonomy/arbiter-role.js

@@ -1,71 +0,0 @@
-/**
- * ArbiterRole — the autonomous decision authority that resolves agent conflicts
- * by picking the least-bad verdict (KJC-TSK-0573, épica KJC-PCS-0062).
- *
- * Extends AgentRole (so it inherits Brain recovery / standby) following the
- * TriageRole pattern: a cheap decisor model emits a closed-set verdict, and any
- * parse failure degrades to BLOCK_AND_CONTINUE — the pipeline never crashes and
- * never blocks on the Arbiter.
- */
-
-import { AgentRole } from "../roles/agent-role.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-import { buildArbiterPrompt, VERDICTS } from "../prompts/arbiter.js";
-
-const CONSERVATIVE = "BLOCK_AND_CONTINUE";
-const VERDICT_SET = new Set(VERDICTS);
-
-function clampConfidence(value) {
-  const n = Number(value);
-  return Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
-}
-
-export class ArbiterRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "arbiter" });
-  }
-
-  async buildPrompt(input) {
-    return { prompt: buildArbiterPrompt(input) };
-  }
-
-  parseOutput(raw) {
-    return extractFirstJson(raw);
-  }
-
-  buildSuccessResult(parsed, provider) {
-    const verdict = VERDICT_SET.has(parsed?.verdict) ? parsed.verdict : CONSERVATIVE;
-    return {
-      verdict,
-      confidence: clampConfidence(parsed?.confidence),
-      rationale: String(parsed?.rationale || "").trim() || "no rationale",
-      defect: parsed?.defect ? String(parsed.defect).trim() : null,
-      directive: parsed?.directive ? String(parsed.directive).trim() : null,
-      provider,
-    };
-  }
-
-  buildSummary(parsed) {
-    return `Arbiter: ${VERDICT_SET.has(parsed?.verdict) ? parsed.verdict : CONSERVATIVE}`;
-  }
-
-  // Never crash on garbage: degrade to the conservative verdict so the pipeline
-  // moves on instead of aborting (ok:true keeps the run alive).
-  handleParseNull(agentResult, provider) {
-    return this.degraded(agentResult, provider, "unstructured output");
-  }
-
-  handleParseError(err, agentResult, provider) {
-    return this.degraded(agentResult, provider, err?.message || "parse error");
-  }
-
-  degraded(agentResult, provider, why) {
-    this.logger?.warn?.(`[arbiter] ${why} → ${CONSERVATIVE} (conservative)`);
-    return {
-      ok: true,
-      result: { verdict: CONSERVATIVE, confidence: 0, rationale: `degraded: ${why}`, defect: null, directive: null, provider },
-      summary: `Arbiter: ${CONSERVATIVE} (degraded)`,
-      usage: agentResult.usage,
-    };
-  }
-}

package/src/autonomy/arbiter.js

@@ -1,22 +0,0 @@
-/**
- * createArbiter — adapt ArbiterRole to the function the decision-resolver
- * injects (KJC-TSK-0573). The resolver calls `arbiter(req)` and expects
- * `{ choice, rationale, ... }`; here `choice` is the Arbiter's verdict, which
- * the resolver then validates against the caller's options (AUTO-A).
- */
-
-import { ArbiterRole } from "./arbiter-role.js";
-
-export function createArbiter({ config = {}, logger = console, createAgentFn = null } = {}) {
-  return async function arbiter(req) {
-    const role = new ArbiterRole({ config, logger, createAgentFn });
-    const { result } = await role.execute(req);
-    return {
-      choice: result.verdict,
-      rationale: result.rationale,
-      confidence: result.confidence,
-      defect: result.defect,
-      directive: result.directive,
-    };
-  };
-}

package/src/autonomy/decider.js

@@ -1,18 +0,0 @@
-/**
- * buildDecider — wire the active autonomy level to a ready decision resolver
- * (KJC-TSK-0572, design in docs/specs/autonomous-delivery.md §5).
- *
- * interactive → the human `ask`; assisted/autonomous → the Arbiter (AUTO-B).
- * Consumers (spec-review, reviewer, checkpoint…) call `resolve(...)` instead of
- * prompting directly, so the autonomy level decides who answers in one place.
- */
-
-import { createDecisionResolver } from "./decision-resolver.js";
-import { resolveAutonomy } from "./policy.js";
-import { createArbiter } from "./arbiter.js";
-
-export function buildDecider({ config = {}, flags = {}, ask = null, env = process.env, logger = console, createAgentFn = null } = {}) {
-  const autonomy = resolveAutonomy({ config, flags, env });
-  const arbiter = autonomy === "interactive" ? null : createArbiter({ config, logger, createAgentFn });
-  return { autonomy, resolve: createDecisionResolver({ autonomy, ask, arbiter, logger }) };
-}

package/src/autonomy/decision-resolver.js

@@ -1,58 +0,0 @@
-/**
- * autonomy/decision-resolver — the single choke point for every pipeline
- * question (KJC-TSK-0572, design in docs/specs/autonomous-delivery.md §5).
- *
- * Today the "ask a human" logic is scattered (spec-review, checkpoint,
- * reviewer, board-bridge). This unifies it: callers ask `resolveDecision`
- * instead of prompting directly, and the autonomy level decides who answers —
- * the human (`ask`) or the Arbiter (`arbiter`, injected by AUTO-B).
- *
- * INVARIANT: in `autonomous` mode the resolver NEVER returns a null choice and
- * NEVER blocks — if the Arbiter can't decide it degrades to the option flagged
- * `conservative` (or the first option). Decisions are always traced.
- */
-
-import { RISK, usesArbiter } from "./policy.js";
-
-/** Pick the safe fallback: the option flagged conservative, else the first. */
-function conservativeOf(options) {
-  return options.find((o) => o.conservative) ?? options[0] ?? null;
-}
-
-function decision(choice, rationale, source) {
-  return { choice: choice ?? null, rationale, source };
-}
-
-/**
- * Build a resolver bound to an autonomy level and its two answer sources.
- *
- * @param {object} opts
- * @param {string} opts.autonomy - interactive | assisted | autonomous
- * @param {(question: string, context?: object) => Promise<string|null>} [opts.ask] - human prompt
- * @param {(input: object) => Promise<{choice: string, rationale?: string}>} [opts.arbiter] - AUTO-B
- * @returns {(req: object) => Promise<{choice, rationale, source}>}
- */
-export function createDecisionResolver({ autonomy = "interactive", ask = null, arbiter = null, logger = console } = {}) {
-  return async function resolveDecision({ question, options = [], context = null, risk = RISK.LOW } = {}) {
-    const fallback = conservativeOf(options);
-
-    // Human path: interactive, or assisted with a high-risk decision.
-    if (!usesArbiter(autonomy, risk)) {
-      const answer = ask ? await ask(question, context) : null;
-      return decision(answer, "human", "human");
-    }
-
-    // Arbiter path: must always yield a valid choice, never block.
-    if (!arbiter) return decision(fallback?.value, "no arbiter available → conservative", "fallback");
-    let verdict;
-    try {
-      verdict = await arbiter({ question, options, context, risk });
-    } catch (err) {
-      logger.warn?.(`decision-resolver: arbiter failed (${err.message}) → conservative`);
-      return decision(fallback?.value, "arbiter error → conservative", "fallback");
-    }
-    const valid = verdict && options.some((o) => o.value === verdict.choice);
-    if (!valid) return decision(fallback?.value, "arbiter gave no valid choice → conservative", "fallback");
-    return decision(verdict.choice, verdict.rationale ?? "arbiter", "arbiter");
-  };
-}

package/src/autonomy/outcome-report.js

@@ -1,55 +0,0 @@
-/**
- * outcome-report — the auditable "meets the ask, with known defects" report
- * for an autonomous run (KJC-TSK-0577, design in docs/specs/autonomous-delivery.md §10).
- *
- * Pure: builds a serializable outcome from the run results + Arbiter decisions,
- * and renders it as lines (or the structure is emitted as --json). The point is
- * that an imperfect-but-delivered result is explicit and auditable: which HUs
- * met the ask, what the Arbiter decided, and what debt remains.
- */
-
-/**
- * @param {object} opts
- * @param {string} [opts.planRef]
- * @param {boolean} opts.delivered - the run met the minimum ask
- * @param {Array<{id, title?, met: boolean, note?}>} [opts.hus]
- * @param {Array<{verdict, rationale, hu?, defect?}>} [opts.decisions] - Arbiter log
- */
-export function buildOutcome({ planRef = null, delivered = false, hus = [], decisions = [] } = {}) {
-  const met = hus.filter((h) => h.met).length;
-  const residualDefects = [
-    ...hus.filter((h) => !h.met).map((h) => ({ hu: h.id, detail: h.note || "acceptance criteria not fully met" })),
-    ...decisions.filter((d) => d.defect).map((d) => ({ hu: d.hu ?? null, detail: d.defect })),
-  ];
-  return {
-    verdict: delivered ? "DELIVERED" : "INCOMPLETE",
-    planRef,
-    hus: { total: hus.length, met, unmet: hus.length - met },
-    decisions,
-    residualDefects,
-  };
-}
-
-/** Render an outcome (from buildOutcome) as human-readable lines. */
-export function formatOutcomeReport(outcome) {
-  const lines = [
-    `kj autorun — outcome: ${outcome.verdict}`,
-    `  plan: ${outcome.planRef ?? "?"}`,
-    `  HUs:  ${outcome.hus.met}/${outcome.hus.total} met the ask`,
-  ];
-  if (outcome.decisions?.length) {
-    lines.push("  Decisions (Arbiter — least-bad calls):");
-    for (const d of outcome.decisions) {
-      lines.push(`    • ${d.verdict}${d.hu ? ` [${d.hu}]` : ""} — ${d.rationale}`);
-    }
-  }
-  if (outcome.residualDefects?.length) {
-    lines.push("  Known defects (delivered with debt):");
-    for (const def of outcome.residualDefects) {
-      lines.push(`    • ${def.hu ? `[${def.hu}] ` : ""}${def.detail}`);
-    }
-  } else {
-    lines.push("  No residual defects recorded.");
-  }
-  return lines;
-}

package/src/autonomy/stage-ask.js

@@ -1,30 +0,0 @@
-/**
- * createAutonomyAskQuestion — make the stages' question function non-blocking in
- * autonomous mode (KJC-TSK-0576, AUTO-E, design in docs/specs/autonomous-delivery.md §9).
- *
- * In `autonomous` no stage asks a human or routes to the HU Board: the wrapper
- * answers in-process with the least-bad "keep going" choice, so the run never
- * pauses or aborts mid-loop. interactive and assisted keep the human prompts
- * (baseAsk) unchanged.
- *
- * The answer is chosen per stage so the EXISTING branches proceed (verified
- * against the stage code — no stage logic is touched):
- *   - architect clarification: null → the stage continues best-effort (a truthy
- *     answer would force a wasteful architect re-run).
- *   - everything else (Solomon escalation, checkpoint, …): "continue" → parsed
- *     as free-text guidance → the stage continues instead of pausing/aborting.
- */
-export function createAutonomyAskQuestion({ baseAsk = null, autonomy = "interactive", logger = console } = {}) {
-  if (autonomy !== "autonomous") return baseAsk;
-  const auto = async (_question, context = {}) => {
-    const stage = context?.stage ?? null;
-    logger?.info?.(`[autonomy] ${stage ? `${stage}: ` : ""}auto-continue (no human in the loop)`);
-    return stage === "architect" ? null : "continue";
-  };
-  auto.interactive = false;
-  // Marker so the orchestrator can tell an autonomous (unattended) run from an
-  // interactive one even though both carry a truthy askQuestion — the wall-clock
-  // backstop relies on it (KJC-TSK-0575, AUTO-D).
-  auto.unattended = true;
-  return auto;
-}