karajan-code 2.8.0 → 2.9.0

package/src/commands/audit.js

@@ -1,11 +1,36 @@
 import path from "node:path";
-import { createAgent } from "../agents/index.js";
+import fs from "node:fs/promises";
+import readline from "node:readline";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { assertAgentsAvailable } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
-import { buildAuditPrompt, parseAuditOutput, AUDIT_DIMENSIONS } from "../prompts/audit.js";
+import { AUDIT_DIMENSIONS } from "../prompts/audit.js";
+import { AuditRole } from "../roles/audit-role.js";
 import { withCliRunLog } from "../utils/cli-run-log.js";
 import { createCliProgressReporter } from "../utils/cli-progress.js";
 import { runAgentReadiness, formatAgentReadinessReport } from "../audit/agent-readiness.js";
+import { formatDeterministicSummary } from "../audit/deterministic-summary.js";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Prompt the user (TTY only) to decide whether to continue with the LLM
+ * phase after deterministic findings have been printed. KJC-TSK-0364.
+ *
+ * @returns {Promise<boolean>} true to continue with LLM, false to skip
+ */
+function promptContinueWithLlm({ promptFn = null } = {}) {
+  if (typeof promptFn === "function") return promptFn();
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) { resolve(true); return; } // CI / piped input → continue
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("Continue with LLM analysis? [y/N] ", (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test((answer || "").trim()));
+    });
+  });
+}
 
 function formatFindings(findings) {
   const lines = [];
@@ -45,10 +70,11 @@ const DIMENSION_LABELS = {
   codeQuality: "Code Quality",
   performance: "Performance",
   architecture: "Architecture",
-  testing: "Testing"
+  testing: "Testing",
+  accessibility: "Accessibility (WCAG 2.x)"
 };
 
-function formatAudit(parsed) {
+function formatAudit(parsed, usage = null) {
   const lines = [];
   lines.push("## Codebase Health Report");
   lines.push(`**Overall Health:** ${parsed.summary.overallHealth}`);
@@ -66,10 +92,119 @@ function formatAudit(parsed) {
   }
 
   if (parsed.textSummary) lines.push(`---\n${parsed.textSummary}`);
+
+  const usageBlock = formatUsageSummary(usage);
+  if (usageBlock) {
+    lines.push("");
+    lines.push(usageBlock);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format the LLM token + cost summary that closes every audit report.
+ * KJC-TSK-0363: makes the LLM cost visible (was silently discarded
+ * pre-patch — auditCommand never read roleResult.usage).
+ *
+ * @param {object|null} usage - shape produced by AuditRole's extractUsage
+ * @returns {string|null} markdown block, or null when there's nothing useful to show
+ */
+function formatUsageSummary(usage) {
+  if (!usage) return null;
+  const lines = ["## LLM Usage"];
+  lines.push(`- Provider: ${usage.provider}${usage.model ? ` (${usage.model})` : ""}`);
+  if (typeof usage.durationMs === "number") {
+    lines.push(`- Duration: ${(usage.durationMs / 1000).toFixed(1)}s`);
+  }
+  if (!usage.available) {
+    lines.push(`- Tokens: usage data not available — ${usage.reason || "provider does not report it"}`);
+    return lines.join("\n");
+  }
+  // Force en-US locale so the comma grouping is deterministic across CI
+  // machines (Node's default Intl.NumberFormat depends on the runtime
+  // locale; without this the rendering would look like "1234" on
+  // locale-less Node and "1,234" on a US-locale workstation).
+  const fmt = (n) => n.toLocaleString("en-US");
+  lines.push(`- Tokens: ${fmt(usage.total_tokens)} total (${fmt(usage.tokens_in)} in, ${fmt(usage.tokens_out)} out)`);
+  if (typeof usage.cost_usd === "number") {
+    lines.push(`- Estimated cost: $${usage.cost_usd.toFixed(4)} USD`);
+  }
   return lines.join("\n");
 }
 
-export async function auditCommand({ task, config, logger, dimensions, json, agentReadiness, path: pathArg }) {
+/**
+ * Resolve where to write the audit report on disk, given a flag value, an
+ * env override, and the desired format. Returns null if no write target
+ * was requested. Creates parent directories on demand.
+ *
+ * Resolution rules (KJC-TSK-0362):
+ *   - flag undefined + no env → null (legacy behaviour, stdout only)
+ *   - flag is a directory → write `audit-<ISO>.{md,json}` inside it
+ *   - flag is a non-directory path → use it verbatim (extension drives format
+ *     when --json/--md not explicit)
+ *   - flag is undefined but env $KJ_AUDIT_REPORT_DIR is set → treat env as dir
+ */
+async function resolveReportFilePath(flagValue, isJson) {
+  const envDir = process.env.KJ_AUDIT_REPORT_DIR;
+  const target = flagValue || (envDir ? envDir : null);
+  if (!target) return null;
+
+  const ext = isJson ? "json" : "md";
+  let stats = null;
+  try { stats = await fs.stat(target); } catch { /* not a directory yet */ }
+  const isDir = stats?.isDirectory() || target.endsWith(path.sep) || target === envDir;
+
+  let resolved;
+  if (isDir) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    resolved = path.resolve(target, `audit-${stamp}.${ext}`);
+  } else {
+    resolved = path.resolve(target);
+  }
+
+  await fs.mkdir(path.dirname(resolved), { recursive: true });
+  return resolved;
+}
+
+/**
+ * Build the markdown header that prefixes a persisted report — captures
+ * timestamp + repo state + invocation flags so the file is reproducible.
+ */
+async function buildReportHeader(projectDir, invocation) {
+  const lines = ["# Karajan Audit Report", ""];
+  lines.push(`- **Generated:** ${new Date().toISOString()}`);
+  lines.push(`- **Project:** ${projectDir || process.cwd()}`);
+
+  // Best-effort git info — silent if outside a repo.
+  try {
+    const branch = (await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: projectDir, timeout: 2000 })).stdout.trim();
+    const commit = (await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd: projectDir, timeout: 2000 })).stdout.trim();
+    lines.push(`- **Branch:** ${branch}`);
+    lines.push(`- **Commit:** ${commit}`);
+  } catch { /* not a git repo or git missing */ }
+
+  if (invocation) lines.push(`- **Invocation:** \`${invocation}\``);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+}
+
+function describeInvocation({ task, dimensions, noSonar, noOsv, noSemgrep, json, deterministicOnly, yes }) {
+  const parts = ["kj audit"];
+  if (task && task !== "Analyze the full codebase") parts.push(JSON.stringify(task));
+  if (dimensions && dimensions !== "all") parts.push(`--dimensions=${dimensions}`);
+  if (noSonar) parts.push("--no-sonar");
+  if (noOsv) parts.push("--no-osv");
+  if (noSemgrep) parts.push("--no-semgrep");
+  if (deterministicOnly) parts.push("--deterministic-only");
+  if (yes) parts.push("--yes");
+  if (json) parts.push("--json");
+  return parts.join(" ");
+}
+
+export async function auditCommand({ task, config, logger, dimensions, json, agentReadiness, path: pathArg, noSonar = false, noOsv = false, noSemgrep = false, reportFile = null, deterministicOnly = false, yes = false, promptFn = null }) {
   // --agent-readiness is a STANDALONE, deterministic, LLM-free audit
   // dimension. It scores any third-party repo for AI-agent readability
   // (llms.txt presence, page token budgets, robots allowlist, etc.).
@@ -88,44 +223,120 @@ export async function auditCommand({ task, config, logger, dimensions, json, age
   }
 
   return withCliRunLog("audit", { projectDir: config?.projectDir, logger }, async ({ runLog }) => {
-    const auditRole = resolveRole(config, "audit");
-    await assertAgentsAvailable([auditRole.provider]);
-    logger.info(`Audit (${auditRole.provider}) starting...`);
-    runLog.logText(`[audit] provider=${auditRole.provider} dimensions=${dimensions || "all"}`);
+    const auditRoleConfig = resolveRole(config, "audit");
+    await assertAgentsAvailable([auditRoleConfig.provider]);
+    logger.info(`Audit (${auditRoleConfig.provider}) starting...`);
+    runLog.logText(`[audit] provider=${auditRoleConfig.provider} dimensions=${dimensions || "all"} deterministicOnly=${deterministicOnly}`);
 
-    const agent = createAgent(auditRole.provider, config, logger);
-    const dimList = dimensions && dimensions !== "all"
-      ? dimensions.split(",").map(d => d.trim().toLowerCase()).map(d => d === "quality" ? "codeQuality" : d).filter(d => AUDIT_DIMENSIONS.includes(d))
-      : null;
+    // Two-phase audit (KJC-TSK-0364) — collect deterministic findings
+    // first; show them; ask the user (when TTY + not --yes + not
+    // --deterministic-only) whether to spend tokens on the LLM analysis.
+    // CI / piped input / --yes / --deterministic-only never prompts.
+    const role = new AuditRole({ config, logger });
+    const roleInput = {
+      task: task || "Analyze the full codebase",
+      dimensions: dimensions || null,
+      noSonar,
+      noOsv,
+      noSemgrep,
+    };
+    const deterministicCtx = await role.collectDeterministic(roleInput);
+    const deterministicMd = formatDeterministicSummary(deterministicCtx);
 
-    const prompt = buildAuditPrompt({ task: task || "Analyze the full codebase", dimensions: dimList });
+    // --json suppresses the interactive flow regardless: it would mangle
+    // a script's stdout. JSON consumers always get the full audit unless
+    // they explicitly pass deterministicOnly.
+    const reportPath = await resolveReportFilePath(reportFile, json);
+    let runLlm = !deterministicOnly;
+    if (runLlm && !json && !yes) {
+      console.log(deterministicMd);
+      console.log("");
+      const ok = await promptContinueWithLlm({ promptFn });
+      runLlm = ok;
+      if (!ok) logger.info("LLM analysis skipped (deterministic-only mode).");
+    }
+
+    if (!runLlm) {
+      // Deterministic-only path. Produce the report from what we already
+      // have, persist it (md or json), and exit. Zero tokens spent.
+      const stdoutContent = json
+        ? JSON.stringify({ deterministic: deterministicCtx, mode: "deterministic-only" }, null, 2)
+        : (deterministicOnly ? deterministicMd : ""); // already printed above when interactive
+      if (json || deterministicOnly) console.log(stdoutContent);
+
+      if (reportPath) {
+        let payload;
+        if (reportPath.endsWith(".json")) {
+          payload = JSON.stringify({ deterministic: deterministicCtx, mode: "deterministic-only" }, null, 2);
+        } else {
+          const header = await buildReportHeader(config?.projectDir, describeInvocation({ task, dimensions, noSonar, noOsv, noSemgrep, json, deterministicOnly, yes }));
+          payload = header + deterministicMd + "\n";
+        }
+        await fs.writeFile(reportPath, payload, "utf8");
+        runLog.logText(`[audit] report written (deterministic-only) → ${reportPath}`);
+        logger.info(`Audit report written: ${reportPath}`);
+      }
+      logger.info("Audit completed (deterministic-only).");
+      return { ok: true, mode: "deterministic-only", reportPath: reportPath || undefined };
+    }
+
+    // Continue with the LLM phase using the already-collected context.
     const progress = createCliProgressReporter({ role: "auditor" });
-    let result;
+    let roleResult;
     try {
-      result = await agent.runTask({ prompt, onOutput: progress.onOutput, role: "audit" });
-      progress.finish(result.ok ? "done" : "failed");
+      roleResult = await role.executeWithDeterministic({ ...roleInput, onOutput: progress.onOutput }, deterministicCtx);
+      progress.finish(roleResult.ok ? "done" : "failed");
     } catch (err) { progress.finish("failed"); throw err; }
 
-    if (!result.ok) {
-      throw new Error(result.error || result.output || "Audit failed");
+    if (!roleResult.ok) {
+      const err = roleResult.result?.error || "Audit failed";
+      throw new Error(err);
     }
 
-    const parsed = parseAuditOutput(result.output);
-    if (parsed?.summary) {
+    const parsed = roleResult.result;
+    const usage = roleResult.usage;
+    if (parsed?.summary?.overallHealth) {
       runLog.logText(`[audit] findings=${parsed.summary.totalFindings} (critical=${parsed.summary.critical}, high=${parsed.summary.high})`);
     }
+    if (usage?.available) {
+      runLog.logText(`[audit] usage tokens=${usage.total_tokens} cost=$${(usage.cost_usd ?? 0).toFixed(4)} duration=${(usage.durationMs / 1000).toFixed(1)}s`);
+    }
 
+    let stdoutContent;
     if (json) {
-      console.log(JSON.stringify(parsed || result.output, null, 2));
-      return { ok: true };
+      const jsonPayload = parsed
+        ? { ...parsed, usage: usage || undefined }
+        : { ...roleResult, usage: usage || undefined };
+      stdoutContent = JSON.stringify(jsonPayload, null, 2);
+    } else if (parsed?.summary?.overallHealth) {
+      stdoutContent = formatAudit(parsed, usage);
+    } else if (parsed?.raw) {
+      stdoutContent = parsed.raw + (usage ? `\n\n${formatUsageSummary(usage) || ""}` : "");
+    } else {
+      stdoutContent = roleResult.summary || "Audit complete.";
     }
+    console.log(stdoutContent);
 
-    if (parsed?.summary) {
-      console.log(formatAudit(parsed));
-    } else {
-      console.log(result.output);
+    if (reportPath) {
+      let payload;
+      if (reportPath.endsWith(".json")) {
+        const jsonPayload = parsed
+          ? { ...parsed, usage: usage || undefined }
+          : { ...roleResult, usage: usage || undefined };
+        payload = JSON.stringify(jsonPayload, null, 2);
+      } else {
+        const header = await buildReportHeader(config?.projectDir, describeInvocation({ task, dimensions, noSonar, noOsv, noSemgrep, json, deterministicOnly, yes }));
+        payload = header + stdoutContent + "\n";
+      }
+      await fs.writeFile(reportPath, payload, "utf8");
+      runLog.logText(`[audit] report written → ${reportPath}`);
+      logger.info(`Audit report written: ${reportPath}`);
     }
+
     logger.info("Audit completed.");
-    return { ok: true };
+    return { ok: true, reportPath: reportPath || undefined };
   });
 }
+
+// Exposed for tests — kept module-private otherwise.
+export { formatAudit, formatUsageSummary, AUDIT_DIMENSIONS };

package/src/commands/doctor.js

@@ -77,7 +77,7 @@ function confirmViaTty(describe) {
  * @param {{ config: Object, checkOnly?: boolean, yes?: boolean, onConfirm?: Function, logger?: Object }} args
  * @returns {Promise<import("../checks/types.js").RunReport>}
  */
-export async function runDoctor({ config, checkOnly = false, yes = false, onConfirm, logger }) {
+async function runDoctor({ config, checkOnly = false, yes = false, onConfirm, logger }) {
   const checks = buildChecks(config);
   return runCheckPipeline(checks, { config }, {
     mode: checkOnly ? "check-only" : "fix",

package/src/config/test-harness.js

@@ -76,4 +76,3 @@ export function resolveTestHarness(explicit = {}) {
   return Object.freeze(out);
 }
 
-export { PROD_DEFAULTS, GLOBAL_KEYS };

package/src/orchestrator/ci-integration.js

@@ -86,7 +86,7 @@ export async function handleCiEarlyPrOrPush({ ciEnabled, config, session, emitte
   }
 }
 
-export function formatBlockingIssues(issues) {
+function formatBlockingIssues(issues) {
   return issues?.map((x) => `- ${x.id || "ISSUE"} [${x.severity || ""}] ${x.description}`).join("\n") || "";
 }
 

package/src/orchestrator/direct-actions.js

@@ -190,4 +190,4 @@ export function getAllowedActionTypes() {
   return Object.keys(ACTION_HANDLERS);
 }
 
-export { ALLOWED_COMMANDS, isCommandAllowed };
+export { isCommandAllowed };

package/src/orchestrator/drivers/error-recovery.js

@@ -119,7 +119,7 @@ export async function handleStandbyResult({ stageResult, session, emitter, event
 }
 
 
-export function emitSolomonAlerts(alerts, emitter, eventBase, logger) {
+function emitSolomonAlerts(alerts, emitter, eventBase, logger) {
   for (const alert of alerts) {
     emitProgress(emitter, makeEvent("brain:rules-alert", { ...eventBase, stage: "brain" }, {
       status: alert.severity === "critical" ? "fail" : "warn",
@@ -198,7 +198,7 @@ export async function handleSolomonCheck({ config, session, emitter, eventBase,
   return { action: "continue" };
 }
 
-export async function checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i }) {
+async function checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i }) {
   if (!rulesResult.hasCritical || !askQuestion) return null;
 
   const alertSummary = rulesResult.alerts

package/src/orchestrator/drivers/iteration-loop.js

@@ -44,23 +44,13 @@ import { runQualityGateStages } from "./iteration-phases/quality-gates.js";
 import { runReviewerGateStage } from "./iteration-phases/reviewer-gate.js";
 import { handleApprovedReview } from "./iteration-phases/handle-approved.js";
 
-// Re-export for back-compat with any external caller; the canonical
-// definitions now live in ./iteration-phases/.
-export { runCoderAndRefactorerStages } from "./iteration-phases/coder-and-refactorer.js";
-export { runGuardStages } from "./iteration-phases/guards.js";
-export { runQualityGateStages } from "./iteration-phases/quality-gates.js";
-export { runReviewerGateStage } from "./iteration-phases/reviewer-gate.js";
-export { handleApprovedReview } from "./iteration-phases/handle-approved.js";
-
 // `runCoderAndRefactorerStages`, `runGuardStages`, `runQualityGateStages`,
 // `runReviewerGateStage` and `handleApprovedReview` were extracted to
 // ./iteration-phases/ in the v2.7.x audit follow-up (same pattern as
-// pre-loop-phases/). The imports above pull them back in; re-exports
-// keep the previous public surface for any external caller. Behaviour
-// is unchanged.
-
+// pre-loop-phases/). The back-compat re-exports were removed in
+// KJC-TSK-0354 PR-D — no caller imported them via this module.
 
-export async function runSingleIteration(ctx) {
+async function runSingleIteration(ctx) {
   // Use plannedTask (HU-scoped or planner-enriched) over the raw original task.
   // When running per-HU sub-pipelines, plannedTask is the HU's text, not the full spec.
   const { config, logger, emitter, eventBase, session, iteration: i } = ctx;

package/src/orchestrator/drivers/pre-loop.js

@@ -52,9 +52,6 @@ import { emitConfigDeprecations } from "./pre-loop-phases/config-deprecations.js
 import { ensureAddyosmaniSkills } from "./pre-loop-phases/ensure-addyosmani-skills.js";
 import { maybeGenerateAutoHuBatch } from "./pre-loop-phases/auto-hu-batch.js";
 
-// Re-export for back-compat with any external caller; the canonical
-// definitions now live in ./pre-loop-phases/.
-export { ensureAddyosmaniSkills };
 import {
   applyTriageOverrides, applyAutoSimplify, applyFlagOverrides,
   resolvePipelinePolicies, updateGitignoreForStack,
@@ -380,7 +377,7 @@ export async function runPreLoopStages({ config, logger, emitter, eventBase, ses
 
   return { plannedTask, updatedConfig };
 }
-export async function runPlanningPhases({ config, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion, brainCtx }) {
+async function runPlanningPhases({ config, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion, brainCtx }) {
   let researchContext = null;
   let plannedTask = task;
 

package/src/orchestrator/feedback-queue.js

@@ -149,4 +149,3 @@ export function deserialize(str) {
   }
 }
 
-export { SEVERITY_ORDER, CATEGORY_ORDER };

package/src/orchestrator/integrations.js

@@ -72,13 +72,6 @@ export function unregisterIntegration(name) {
   registry.delete(name);
 }
 
-/**
- * Clear the registry. Test-only; production never calls this.
- */
-export function __clearIntegrations() {
-  registry.clear();
-}
-
 /**
  * List registered integration names. Useful for bootstrap logging.
  * @returns {string[]}

package/src/orchestrator/role-output-compressor.js

@@ -187,4 +187,3 @@ export function measureCompression(original, compressed) {
   };
 }
 
-export { COMPRESSORS };

package/src/orchestrator/session-journal.js

@@ -2,7 +2,6 @@
 // Creates .reviews/session_*/ directories containing markdown files per stage.
 import fs from "node:fs/promises";
 import path from "node:path";
-import { runCommand } from "../utils/process.js";
 
 /**
  * Create the journal directory for a session.
@@ -174,29 +173,6 @@ export function formatDecision({ timestamp, trigger, context, action, reasoning
   return lines.join("\n");
 }
 
-// ── Tree of affected files ───────────────────────────────────────────────────
-
-export async function generateFileTree(baseRef) {
-  try {
-    const result = await runCommand("git", ["diff", "--name-status", `${baseRef}...HEAD`]);
-    if (result.exitCode !== 0 || !result.stdout?.trim()) return null;
-
-    const lines = ["# Affected Files\n"];
-    const statusMap = { M: "modified", A: "added", D: "deleted", R: "renamed" };
-
-    for (const line of result.stdout.trim().split("\n")) {
-      const [status, ...fileParts] = line.split("\t");
-      const file = fileParts.join("\t");
-      const label = statusMap[status?.[0]] || status;
-      lines.push(`- [${label}] ${file}`);
-    }
-
-    return lines.join("\n");
-  } catch {
-    return null;
-  }
-}
-
 // ── Summary ──────────────────────────────────────────────────────────────────
 
 export function generateSummary({ task, result, sessionId, iterations, durationMs, budget, stages, commits, files }) {
@@ -325,20 +301,7 @@ export async function writeDecisionsJournal(journalDir, decisionEntries) {
   await writeJournalFile(journalDir, "decisions.md", content);
 }
 
-/**
- * Write the file tree.
- */
-export async function writeTreeJournal(journalDir, baseRef) {
-  const tree = await generateFileTree(baseRef);
-  if (tree) await writeJournalFile(journalDir, "tree.txt", tree);
-  return Boolean(tree);
-}
-
-/**
- * Write the session summary.
- */
-export async function writeSummaryJournal(journalDir, summaryData) {
-  const files = summaryData.files || [];
-  const content = generateSummary({ ...summaryData, files: [...files, "summary.md"] });
-  await writeJournalFile(journalDir, "summary.md", content);
-}
+// writeTreeJournal / writeSummaryJournal / generateFileTree were
+// superseded in v2.7.x by src/session/journal/{tree-writer,summary-writer}.js
+// (the V2 split). post-loop.js dynamically imports the V2 versions; this
+// orchestrator-side copy is no longer wired anywhere. KJC-TSK-0354 PR-D.

package/src/orchestrator/stages/stage-classes.js

@@ -82,5 +82,3 @@ export const stageRegistry = new StageRegistry();
 stageRegistry.register(new TriageStage());
 stageRegistry.register(new CoderStage());
 stageRegistry.register(new ReviewerStage());
-
-export { StageExecutor, StageRegistry };

package/src/plan/plan-store.js

@@ -114,20 +114,6 @@ export async function loadPlan(projectDir, planId) {
   }
 }
 
-/**
- * Update a plan on disk (partial merge).
- * @returns {Promise<boolean>}
- */
-export async function updatePlan(projectDir, planId, patch) {
-  const plan = await loadPlan(projectDir, planId);
-  if (!plan) return false;
-  Object.assign(plan, patch);
-  plan.updatedAt = new Date().toISOString();
-  const filePath = path.join(plansDir(projectDir), `${planId}.json`);
-  await fs.writeFile(filePath, JSON.stringify(plan, null, 2), "utf8");
-  return true;
-}
-
 /**
  * Delete a plan from disk.
  * @returns {Promise<boolean>}

package/src/planning-game/client.js

@@ -93,20 +93,6 @@ export async function createCard({ projectId, card, timeoutMs = DEFAULT_TIMEOUT_
   return parseJsonResponse(response);
 }
 
-export async function createAdr({ projectId, adr, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/adrs`;
-  const response = await fetchWithRetry(
-    url,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(adr)
-    },
-    timeoutMs
-  );
-  return parseJsonResponse(response);
-}
-
 export async function relateCards({ projectId, sourceCardId, targetCardId, relationType, timeoutMs = DEFAULT_TIMEOUT_MS }) {
   const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards/relate`;
   const response = await fetchWithRetry(

package/src/planning-game/pipeline-adapter.js

@@ -42,7 +42,7 @@ export async function initPgAdapter({ session: _session, config, logger, pgTaskI
  * Handle PG task decomposition after triage.
  * Creates subtask cards in PG when triage recommends decomposition.
  */
-export async function handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger }) {
+async function handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger }) {
   const shouldDecompose = triageResult.stageResult?.shouldDecompose
     && triageResult.stageResult.subtasks?.length > 1
     && pgTaskId