karajan-code 3.0.0 → 3.2.0

package/src/orchestrator/config-init.js

@@ -229,6 +229,7 @@ export function resolvePipelineFlags(config) {
     securityEnabled: Boolean(config.pipeline?.security?.enabled),
     impeccableEnabled: Boolean(config.pipeline?.impeccable?.enabled),
     perfEnabled: Boolean(config.pipeline?.perf?.enabled),
+    toolJudgeEnabled: Boolean(config.pipeline?.tool_judge?.enabled),
     reviewerEnabled: config.pipeline?.reviewer?.enabled !== false,
     discoverEnabled: Boolean(config.pipeline?.discover?.enabled),
     architectEnabled: Boolean(config.pipeline?.architect?.enabled),

package/src/orchestrator/drivers/iteration-phases/quality-gates.js

@@ -19,6 +19,8 @@ import {
 } from "../../iteration-stages.js";
 import { runImpeccableStage } from "../../post-loop-stages.js";
 import { runPerfStage } from "../../stages/perf-stage.js";
+import { runTddDisciplineStage } from "../../stages/tdd-discipline-stage.js";
+import { runToolJudgeStage } from "../../stages/tool-judge-stage.js";
 import { tryCiComment } from "../../ci-integration.js";
 
 export async function runQualityGateStages({ config, logger, emitter, eventBase, session, trackBudget, i, askQuestion, repeatDetector, budgetSummary, sonarState, task, stageResults, coderRole, pipelineFlags, brainCtx }) {
@@ -26,6 +28,16 @@ export async function runQualityGateStages({ config, logger, emitter, eventBase,
   if (tddResult.action === "pause") return { action: "return", result: tddResult.result };
   if (tddResult.action === "continue") return { action: "continue" };
 
+  // KJC-TSK-0398 PR3: opt-in red-then-green check.
+  if (config.development?.require_red_then_green) {
+    const disc = await runTddDisciplineStage({
+      config, logger, emitter, eventBase,
+      sourceFiles: tddResult.sourceFiles || [],
+      testFiles: tddResult.testFiles || [],
+    });
+    if (disc.action === "continue") return { action: "continue" };
+  }
+
   // Sonar runs for code tasks per policy. Since v2.7.4 it is NOT
   // toggleable via config — that's intrinsic to Karajan. The taskType
   // policy (resolved_policies.sonar) is the single source of truth.
@@ -84,5 +96,16 @@ export async function runQualityGateStages({ config, logger, emitter, eventBase,
     if (perfResult.action === "continue") return { action: "continue" };
   }
 
+  // KJC-TSK-0375 PR3: opt-in tool-call quality judge. Non-blocking.
+  if (pipelineFlags?.toolJudgeEnabled) {
+    const judgeResult = await runToolJudgeStage({
+      config, logger, emitter, eventBase, session, coderRole, trackBudget,
+      iteration: i, task,
+    });
+    if (judgeResult.stageResult) {
+      stageResults.toolJudge = judgeResult.stageResult;
+    }
+  }
+
   return { action: "ok" };
 }

package/src/orchestrator/drivers/pre-loop-phases/inject-loaded-plan.js

@@ -302,10 +302,26 @@ function wirePlanCallbacks({ session, loadedPlan, projectDir, syncResultsToPlan,
   // PR3: per-HU outcome. Stamped once per HU at runSingleHu's exit
   // so the board can show the 📄 indicator as soon as each HU
   // finishes (iterations / duration / commits / blockers / summary).
+  //
+  // Cost D (KJC-TSK-0515): the outcome may carry `cost_usd` (USD
+  // spent on this HU). When present and finite, also persist it to
+  // board.db so the per-card badge (Cost F) and the project total
+  // chip (Cost G) have data to show — without this write, the
+  // `cost_usd` column would always stay NULL and the UI would render
+  // nothing. Lazy-import to keep the pre-loop phase free of board
+  // deps until we actually need them.
   setLiveOutcomeUpdater(session, async (huId, outcome) => {
     try {
       if (!setHuOutcomeFn(loadedPlan, huId, outcome)) return;
       await savePlanToDisk(projectDir, loadedPlan);
+      if (outcome && Number.isFinite(outcome.cost_usd)) {
+        try {
+          const { setStoryCost } = await import("../../../../packages/hu-board/src/db.js");
+          setStoryCost(huId, outcome.cost_usd);
+        } catch (err) {
+          logger?.warn?.(`Cost write failed for ${huId}: ${err.message}`);
+        }
+      }
     } catch (err) {
       logger?.warn?.(`Live outcome update failed for ${huId}: ${err.message}`);
     }

package/src/orchestrator/drivers/run-hu-batch.js

@@ -360,7 +360,11 @@ export async function runHuBatch({ ctx, task, askQuestion, emitter, logger }) {
     onStatusChange: ctx.session?._liveStatusUpdater || null,
     // PR3 (per-HU outcome): same pattern, but for the rich
     // outcome blob written ONCE per HU at the end of runSingleHu.
-    onOutcome: ctx.session?._liveOutcomeUpdater || null
+    onOutcome: ctx.session?._liveOutcomeUpdater || null,
+    // Cost D (KJC-TSK-0515): the sub-pipeline slices BudgetTracker
+    // entries per HU and stamps `outcome.cost_usd` so the board can
+    // show per-HU spend. Without this the tracker is invisible to it.
+    budgetTracker: ctx.budgetTracker || null
   });
 
   emitProgress(emitter, makeEvent("hu:sub-pipeline:end", { ...ctx.eventBase, stage: "hu-sub-pipeline" }, {

package/src/orchestrator/hu-sub-pipeline.js

@@ -74,6 +74,37 @@ function buildHuTask(story) {
   return `Implement HU ${story.id}`;
 }
 
+/**
+ * Sum the cost_usd of a slice of BudgetTracker entries. Returns null
+ * (not 0) when the slice is empty or contains no usable cost data —
+ * the board uses null as "unmeasured" and renders no badge, while 0
+ * means "really free run". Mixing the two would silently hide free
+ * runs and falsely show "$0.00" for runs with no telemetry.
+ *
+ * Cost D (KJC-TSK-0515): the orchestrator calls this once per HU at
+ * runSingleHu exit, passing the slice of entries recorded during that
+ * HU (snapshotted via the entries.length cursor before the iteration
+ * starts). The resulting number flows through buildHuOutcome →
+ * notifyOutcome → setStoryCost in inject-loaded-plan.js.
+ *
+ * @param {Array<{cost_usd?: number}>} entries
+ * @returns {number|null}
+ */
+function sumCostUsd(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+  let total = 0;
+  let hasAny = false;
+  for (const e of entries) {
+    const n = Number(e?.cost_usd);
+    if (Number.isFinite(n)) {
+      total += n;
+      hasAny = true;
+    }
+  }
+  if (!hasAny) return null;
+  return Math.round(total * 1e6) / 1e6;
+}
+
 /**
  * Build the per-HU outcome blob from whatever metadata the iteration
  * loop returned. Tolerant by design — most fields are optional and we
@@ -90,9 +121,11 @@ function buildHuTask(story) {
  * @param {object} args.iterResult — whatever runIterationFn returned
  * @param {string} args.status — HU_STATUS.* terminal value
  * @param {number} args.startedAt — Date.now() when runSingleHu started
+ * @param {Array} [args.huBudgetEntries] — slice of BudgetTracker
+ *   entries recorded during this HU. Cost D (KJC-TSK-0515).
  * @returns {object}
  */
-function buildHuOutcome({ story: _story, iterResult, status, startedAt }) {
+function buildHuOutcome({ story: _story, iterResult, status, startedAt, huBudgetEntries }) {
   const r = iterResult || {};
   const git = r.git || {};
   // Iterations are tracked in the standard pipeline as
@@ -123,6 +156,7 @@ function buildHuOutcome({ story: _story, iterResult, status, startedAt }) {
     pr_url: r.pr_url || r.prUrl || git.pr_url || null,
     blockers,
     summary,
+    cost_usd: sumCostUsd(huBudgetEntries),
     finishedAt: new Date().toISOString(),
   };
 }
@@ -134,7 +168,7 @@ function buildHuOutcome({ story: _story, iterResult, status, startedAt }) {
  * @param {object} params
  * @returns {Promise<{huId: string, approved: boolean, result?: object, error?: string, blockedDependents?: string[]}>}
  */
-async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emitter, eventBase, logger, config, results, worktreePath, onStatusChange = null, onOutcome = null }) {
+async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emitter, eventBase, logger, config, results, worktreePath, onStatusChange = null, onOutcome = null, budgetTracker = null }) {
   // PR1 (live HU status): every saveHuBatch should also notify the
   // plan JSON so the board reflects state in real time. Defined as a
   // local helper so we don't repeat the try/null-check boilerplate.
@@ -157,6 +191,16 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
   // outcome (wall-clock per HU is what the user needs in the board,
   // not internal stage timings).
   const huStartedAt = Date.now();
+  // Cost D (KJC-TSK-0515): snapshot the budget cursor so we can slice
+  // out only the entries this HU produced. BudgetTracker is session-
+  // scoped (it accumulates across all HUs of the run), so without this
+  // cursor every HU after the first would inherit the previous ones'
+  // cost too. Null-safe — older callers without a tracker still work.
+  const huBudgetStartIdx = budgetTracker?.entries?.length ?? 0;
+  const sliceHuBudget = () => {
+    if (!budgetTracker?.entries) return [];
+    return budgetTracker.entries.slice(huBudgetStartIdx);
+  };
   const story = batch.stories.find(s => s.id === storyId);
 
   // --- Lazy refinement ---
@@ -226,7 +270,7 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
       await saveHuBatch(batchSessionId, batch);
       await notifyStatus(story.id, HU_STATUS.DONE);
       // PR3: build + persist the per-HU outcome.
-      const okOutcome = buildHuOutcome({ story, iterResult, status: HU_STATUS.DONE, startedAt: huStartedAt });
+      const okOutcome = buildHuOutcome({ story, iterResult, status: HU_STATUS.DONE, startedAt: huStartedAt, huBudgetEntries: sliceHuBudget() });
       await notifyOutcome(story.id, okOutcome);
       emitProgress(emitter, makeEvent("hu:status-change", { ...eventBase, stage: "hu-sub-pipeline" }, {
         message: `HU ${story.id} status → done`,
@@ -242,7 +286,7 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
       updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
       await saveHuBatch(batchSessionId, batch);
       await notifyStatus(story.id, HU_STATUS.FAILED);
-      const failOutcome = buildHuOutcome({ story, iterResult, status: HU_STATUS.FAILED, startedAt: huStartedAt });
+      const failOutcome = buildHuOutcome({ story, iterResult, status: HU_STATUS.FAILED, startedAt: huStartedAt, huBudgetEntries: sliceHuBudget() });
       await notifyOutcome(story.id, failOutcome);
       emitProgress(emitter, makeEvent("hu:status-change", { ...eventBase, stage: "hu-sub-pipeline" }, {
         message: `HU ${story.id} status → failed`,
@@ -259,7 +303,7 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
     updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
     await saveHuBatch(batchSessionId, batch);
     await notifyStatus(story.id, HU_STATUS.FAILED);
-    const errOutcome = buildHuOutcome({ story, iterResult: { error: err.message }, status: HU_STATUS.FAILED, startedAt: huStartedAt });
+    const errOutcome = buildHuOutcome({ story, iterResult: { error: err.message }, status: HU_STATUS.FAILED, startedAt: huStartedAt, huBudgetEntries: sliceHuBudget() });
     await notifyOutcome(story.id, errOutcome);
     emitProgress(emitter, makeEvent("hu:status-change", { ...eventBase, stage: "hu-sub-pipeline" }, {
       message: `HU ${story.id} status → failed`,
@@ -287,7 +331,7 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
  * @param {object} params.logger - Logger instance
  * @returns {Promise<{approved: boolean, results: object[], blockedIds: string[]}>}
  */
-export async function runHuSubPipeline({ huReviewerResult, runIterationFn, emitter, eventBase, logger, config = null, onStatusChange = null, onOutcome = null }) {
+export async function runHuSubPipeline({ huReviewerResult, runIterationFn, emitter, eventBase, logger, config = null, onStatusChange = null, onOutcome = null, budgetTracker = null }) {
   const batchSessionId = huReviewerResult.batchSessionId;
   let batch;
   try {
@@ -404,7 +448,7 @@ export async function runHuSubPipeline({ huReviewerResult, runIterationFn, emitt
       // Single HU: run as before, no worktree needed
       const singleResult = await runSingleHu({
         storyId: runnableIds[0], batch, batchSessionId, runIterationFn,
-        emitter, eventBase, logger, config, results, onStatusChange, onOutcome
+        emitter, eventBase, logger, config, results, onStatusChange, onOutcome, budgetTracker
       });
       results.push(singleResult);
       if (!singleResult.approved) {
@@ -443,7 +487,7 @@ export async function runHuSubPipeline({ huReviewerResult, runIterationFn, emitt
           storyId, batch, batchSessionId, runIterationFn,
           emitter, eventBase, logger, config, results,
           worktreePath: worktrees.get(storyId),
-          onStatusChange, onOutcome
+          onStatusChange, onOutcome, budgetTracker
         });
       });
 

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

@@ -8,7 +8,7 @@ import { CoderRole } from "../../roles/coder-role.js";
 import { RefactorerRole } from "../../roles/refactorer-role.js";
 import { addCheckpoint, markSessionStatus, saveSession } from "../../session/store.js";
 import {
-  setReviewerFeedback, incrementRetryCount, resetRetryCount,
+  setReviewerFeedback, setCoderTranscript, incrementRetryCount, resetRetryCount,
 } from "../../session/mutators.js";
 import { generateDiff, getUntrackedFiles } from "../../review/diff-generator.js";
 import { evaluateTddPolicy } from "../../review/tdd-policy.js";
@@ -223,6 +223,12 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
     logger?.warn?.(`[verification-gate] Skipped: ${err?.message || err}`);
   }
 
+  // KJC-TSK-0375 PR3: stash the coder's raw transcript on the session so
+  // the optional tool-judge stage can extract structured tool calls later
+  // without re-invoking the coder. Cleared between iterations by the coder
+  // overwriting it; ignored when the tool-judge flag is off.
+  setCoderTranscript(session, coderTranscript);
+
   await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null, filesChanged });
   emitProgress(
     emitter,
@@ -459,5 +465,5 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
     return handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion, task, brainCtx });
   }
 
-  return { action: "ok" };
+  return { action: "ok", sourceFiles: tddEval.sourceFiles, testFiles: tddEval.testFiles };
 }

package/src/orchestrator/stages/tdd-discipline-stage.js

@@ -0,0 +1,56 @@
+// TDD discipline stage (KJC-TSK-0398 PR3).
+// Runs the red-then-green check when `development.require_red_then_green`
+// is true. Wraps `verifyTddDiscipline` with the surgical stash helper and
+// the project's detected test framework. Gate is opt-in; an unsupported
+// framework reports a warning and does not block the iteration.
+
+import { detectTestFramework } from "../../utils/project-detect.js";
+import { verifyTddDiscipline } from "../../review/tdd-discipline.js";
+import { stashFilesAside, restoreFiles } from "../../review/git-stash-helper.js";
+import { runCommand } from "../../utils/process.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+
+const TDD_DISCIPLINE_COMMANDS = {
+  vitest: ["npx", ["vitest", "run", "--reporter=verbose"]],
+  jest: ["npx", ["jest", "--verbose"]],
+  pytest: ["pytest", ["--tb=short"]],
+};
+
+export async function runTddDisciplineStage({
+  config, logger, emitter, eventBase, sourceFiles = [], testFiles = [],
+  detectFramework = detectTestFramework,
+  runTestsImpl,
+  stashImpl = stashFilesAside,
+  restoreImpl = restoreFiles,
+} = {}) {
+  const projectDir = config?.projectDir || process.cwd();
+  const detection = await detectFramework(projectDir);
+  const framework = detection?.framework || null;
+
+  const runTests = runTestsImpl || (async () => {
+    const cmd = TDD_DISCIPLINE_COMMANDS[framework];
+    if (!cmd) return { exitCode: 0, output: "" };
+    const res = await runCommand(cmd[0], cmd[1], { cwd: projectDir, reject: false });
+    return { exitCode: res.exitCode ?? 0, output: `${res.stdout || ""}\n${res.stderr || ""}` };
+  });
+
+  const result = await verifyTddDiscipline({
+    projectDir, sourceFiles, testFiles, framework,
+    runTests,
+    stashFiles: (files) => stashImpl(files, { projectDir }),
+    restoreFiles: (token) => restoreImpl(token, { projectDir }),
+  });
+
+  emitProgress(emitter, makeEvent("tdd:discipline", { ...eventBase, stage: "tdd" }, {
+    status: result.ok ? "ok" : "fail",
+    message: result.message || `TDD discipline: ${result.reason}`,
+    detail: { reason: result.reason, framework },
+  }));
+
+  if (result.warning) logger?.warn?.(result.warning);
+  if (!result.ok) {
+    logger?.warn?.(`TDD discipline violation: ${result.reason}`);
+    return { action: "continue", result };
+  }
+  return { action: "ok", result };
+}

package/src/orchestrator/stages/tool-judge-stage.js

@@ -0,0 +1,53 @@
+// KJC-TSK-0375 PR3 — ToolJudgeStage.
+// Opt-in (`pipeline.tool_judge.enabled`). Scores the coder's tool calls
+// extracted from `session.last_coder_transcript`. Non-blocking: a low
+// score emits a warn event and surfaces in summary but never gates the
+// iteration loop. Wiring lives in `quality-gates.js`.
+
+import { ToolCorrectnessJudgeRole } from "../../roles/tool-correctness-judge-role.js";
+import { extractToolCalls } from "../../utils/tool-call-extractor.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+
+export async function runToolJudgeStage({
+  config, logger, emitter, eventBase, session, coderRole, trackBudget,
+  iteration, task,
+  extractFn = extractToolCalls,
+  RoleClass = ToolCorrectnessJudgeRole,
+} = {}) {
+  logger?.setContext?.({ iteration, stage: "tool-judge" });
+  emitProgress(emitter, makeEvent("toolJudge:start", { ...eventBase, stage: "tool-judge" }, {
+    message: "Tool-judge scoring coder tool calls",
+  }));
+
+  const transcript = session?.last_coder_transcript || "";
+  const provider = coderRole?.provider || "claude";
+  const toolCalls = extractFn({ transcript, provider });
+
+  const role = new RoleClass({ config, logger, emitter });
+  const roleResult = await role.execute({ task, toolCalls });
+
+  try { trackBudget?.("tool-judge", roleResult.usage || { tokens_in: 0, tokens_out: 0, cost_usd: 0 }); } catch { /* best-effort */ }
+
+  const r = roleResult.result;
+  const status = r?.skipped ? "skip" : r?.lowQuality ? "warn" : roleResult.ok ? "ok" : "fail";
+
+  emitProgress(emitter, makeEvent("toolJudge:end", { ...eventBase, stage: "tool-judge" }, {
+    status,
+    message: roleResult.summary || "tool-judge done",
+    detail: { score: r?.score ?? null, threshold: r?.threshold ?? null, skipped: Boolean(r?.skipped), callCount: toolCalls.length },
+  }));
+
+  return {
+    action: "ok",
+    stageResult: {
+      ok: roleResult.ok !== false,
+      score: r?.score ?? null,
+      lowQuality: Boolean(r?.lowQuality),
+      skipped: Boolean(r?.skipped),
+      threshold: r?.threshold ?? null,
+      summary: roleResult.summary || "",
+      breakdown: r?.breakdown || [],
+      callCount: toolCalls.length,
+    },
+  };
+}