karajan-code 4.70.3 → 5.0.0

package/src/hu/board-lookup.js

@@ -0,0 +1,29 @@
+/**
+ * KJC-BUG-0454: one card of the HU Board, read where `kj hu` keeps it. `kj code --card`
+ * looked in the old kj run store, so every card `kj hu add` created was "not found".
+ * Shared board: the GitHub issue HU-<n>, as `kj hu list` reads it. Local board: the
+ * plan backlog, by id or short id.
+ */
+import { listPlans, loadPlan } from "../plan/plan-store.js";
+import { readBoardConfig } from "./board-config.js";
+import { listHus } from "./github-board.js";
+import { pinGhIdentity } from "./gh-identity.js";
+import { listWithCache } from "./team-board-cache.js";
+
+const SHARED_ID = /^HU-[1-9]\d*$/i;
+
+export async function findBoardHu(projectDir, ref, deps = {}) {
+  const board = await (deps.boardConfig ?? readBoardConfig)(projectDir);
+  if (board.backend === "github" && SHARED_ID.test(ref)) {
+    (deps.pinGhIdentity ?? pinGhIdentity)({ projectDir });
+    const { rows } = await (deps.cache?.list ?? listWithCache)({ projectDir, repo: board.repo, list: deps.listTeamHus ?? listHus });
+    const hu = rows.find((h) => h.short_id.toUpperCase() === ref.toUpperCase());
+    if (hu) return hu;
+  }
+  for (const meta of await (deps.listPlans ?? listPlans)(projectDir)) {
+    const plan = await (deps.loadPlan ?? loadPlan)(projectDir, meta.planId);
+    const hu = (plan.hus || []).find((h) => h.id === ref || h.short_id === ref);
+    if (hu) return hu;
+  }
+  throw new Error(`HU ${ref} is not on the HU Board — kj hu list shows its cards`);
+}

package/src/hu/gh-identity.js

@@ -2,6 +2,7 @@
 // accounts on one machine, another session switching the active one turned `kj hu move` into an
 // opaque GraphQL permission error, three times in a day. The clone declares its account in
 // .karajan/identity.local.yml (ADR 0005): with a declaration, the active account must be it.
+import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -42,3 +43,25 @@ export function assertGhIdentity({ projectDir, env = process.env }) {
   }
   return { declared, active };
 }
+
+/** The token gh keeps for `user`, read without switching the active account; null when it has none. */
+function ghTokenOf(user, env) {
+  const res = spawnSync("gh", ["auth", "token", "--hostname", "github.com", "--user", user], { env, encoding: "utf8" });
+  return res.status === 0 ? res.stdout.trim() || null : null;
+}
+
+/**
+ * KJC-BUG-0406: checking the active account and then calling gh was a race; another session could
+ * switch it in between. With an identity declared, GH_TOKEN is pinned to that account's token for
+ * the rest of the command, so every gh call goes out as it. A token already in the environment is
+ * the user's explicit choice and is left alone.
+ * @returns {{ declared: string | null, pinned: boolean }}
+ */
+export function pinGhIdentity({ projectDir, env = process.env, tokenOf = ghTokenOf }) {
+  const declared = readIdentity(projectDir)?.gh_user ?? null;
+  if (!declared || env.GH_TOKEN || env.GITHUB_TOKEN) return { declared, pinned: false };
+  const token = tokenOf(declared, env);
+  if (!token) throw new BoardRejectedError(`gh has no login for ${declared}, the account this clone declares: run gh auth login and retry`);
+  env.GH_TOKEN = token;
+  return { declared, pinned: true };
+}

package/src/hu/github-board.js

@@ -70,8 +70,10 @@ export async function createHu({ repo, title, acceptanceCriteria = [], tests = [
 
 /** Every HU of the repo, with its status and who holds it. */
 export async function listHus({ repo, run = runCommand }) {
-  const issues = listOf(await gh(run, ["issue", "list", "-R", repo, "--label", HU_LABEL, "--state", "all", "--limit", "1000", "--json", "number,title,state,labels,assignees"]));
-  return issues.map((i) => ({ short_id: `HU-${i.number}`, number: i.number, title: i.title, status: statusOf(i), claimed_by: i.assignees[0]?.login ?? null }));
+  const issues = listOf(await gh(run, ["issue", "list", "-R", repo, "--label", HU_LABEL, "--state", "all", "--limit", "1000", "--json", "number,title,state,labels,assignees,body"]));
+  // KJC-BUG-0443: the tracker reference kj hu add --ref wrote in the body.
+  const refOf = (body) => /^Ref: (\S.*)$/m.exec(body ?? "")?.[1].trim() ?? null;
+  return issues.map((i) => ({ short_id: `HU-${i.number}`, number: i.number, title: i.title, status: statusOf(i), claimed_by: i.assignees[0]?.login ?? null, ref: refOf(i.body) }));
 }
 
 /** The one kj:<status> of an issue; none or several is a board someone broke by hand. */

package/src/hu/lane-prune.js

@@ -6,6 +6,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import { laneWork } from "./lane-setup.js";
 
 const IDLE_HOURS = 24;
 const REGENERABLE = new Set(["node_modules", "dist", "build", "coverage", ".venv", "venv", "__pycache__", ".cache", "target"]);
@@ -55,15 +56,16 @@ export async function classifyLanes({ git, laneRoot, base, processes, now = Date
   }
   return Promise.all(lanes.map(async (lane) => {
     const reasons = [];
-    const { stdout: status } = await git(["status", "--porcelain", "--ignored=matching"], lane.path);
-    const entries = status.split("\n").filter(Boolean);
+    // KJC-TSK-1371: the identity and Sentinel files lane setup wrote are not the lane's work.
+    const { stdout: status } = await git(["status", "--porcelain", "--ignored=matching", "--untracked-files=all"], lane.path);
+    const entries = laneWork(status, lane.path);
     if (entries.some((e) => !e.startsWith("!! "))) reasons.push("uncommitted changes");
     // Ignored files can be valuable (.env, local artifacts); only regenerable dirs are not.
     const precious = entries.filter((e) => e.startsWith("!! ") && !REGENERABLE.has(e.slice(3).split("/")[0]));
     if (precious.length > 0) reasons.push(`ignored files that are not regenerable (${precious[0].slice(3)}${precious.length > 1 ? ", …" : ""})`);
     // The lane's HEAD, branch or detached: a detached lane's commits have no other name.
-    const { stdout: ahead } = await git(["rev-list", "--count", `${base}..HEAD`], lane.path);
-    if (Number(ahead) > 0) reasons.push(`${Number(ahead)} commit(s) not in ${base}`);
+    const ahead = await commitsNotIn({ git, base, cwd: lane.path });
+    if (ahead > 0) reasons.push(`${ahead} commit(s) not in ${base}`);
     if (processes === null) reasons.push("cannot check for live processes on this platform");
     else if ([...processes.cwds].some((cwd) => inside(cwd, lane.path))) reasons.push("a live process works in it");
     else if (processes.unseen > 0 && (await idleHours(git, lane.path, now)) < IDLE_HOURS) {
@@ -83,6 +85,12 @@ export async function resolveBase({ git, base }) {
   }
 }
 
+/** Commits of `ref` (default HEAD, run in `cwd`) that `base` lacks; 0 means merged. */
+export async function commitsNotIn({ git, base, ref = "HEAD", cwd }) {
+  const { stdout } = await git(["rev-list", "--count", `${base}..${ref}`], cwd);
+  return Number(stdout);
+}
+
 /** KJC-TSK-1037: loose kj-hu-* branches (no worktree): the empty ones, and the ones with work and how much. */
 export async function looseLaneBranches({ git, base }) {
   const { stdout: listed } = await git(["for-each-ref", "--format=%(refname:short) %(worktreepath)", "refs/heads/kj-hu-*"]);
@@ -90,9 +98,9 @@ export async function looseLaneBranches({ git, base }) {
   const empty = [];
   const withWork = [];
   for (const branch of loose) {
-    const { stdout: ahead } = await git(["rev-list", "--count", `${base}..${branch}`]);
-    if (Number(ahead) === 0) empty.push(branch);
-    else withWork.push({ branch, reason: `${Number(ahead)} commit(s) not in ${base}` });
+    const ahead = await commitsNotIn({ git, base, ref: branch });
+    if (ahead === 0) empty.push(branch);
+    else withWork.push({ branch, reason: `${ahead} commit(s) not in ${base}` });
   }
   return { empty, withWork };
 }

package/src/hu/lane-setup.js

@@ -0,0 +1,65 @@
+/**
+ * Lane setup (KJC-TSK-1371, #2852, step 6 of #2566): a lane `kj worktree start` creates is
+ * ready on creation. Two things a fresh git worktree lacks, because git does not track them:
+ * - the clone identity (.karajan/identity.local.yml), which the hooks read from the lane root
+ *   so the identity lock knows who pushes; copied from the main checkout when it has one;
+ * - the Sentinel wiring (.claude/settings.json hooks and .karajan/harness), installed in the
+ *   lane with the same installers `kj harden` uses, so the first write there is governed.
+ * A step that fails stops the start loudly, naming the step: never a half-set lane in silence.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+import { installSentinelHooks } from "../harden/sentinel-hooks.js";
+import { installHarnessHooks } from "../harden/harness-hooks.js";
+
+const IDENTITY = path.join(".karajan", "identity.local.yml");
+const INSTALLERS = { sentinel: installSentinelHooks, harness: installHarnessHooks };
+
+/** What setupLane writes into a lane (and the Sentinel's runtime state): never the lane's work. */
+export const isLaneSetupPath = (p) => p === IDENTITY || p === path.join(".claude", "settings.json") || p.startsWith(path.join(".karajan", "harness") + path.sep);
+
+/** A folder git lists whole (an ignored `.claude/`) is setup only when every file in it is. */
+function onlySetup(lanePath, dir) {
+  try {
+    const files = fs.readdirSync(path.join(lanePath, dir), { recursive: true, withFileTypes: true }).filter((d) => d.isFile());
+    return files.every((d) => isLaneSetupPath(path.relative(lanePath, path.join(d.parentPath, d.name))));
+  } catch {
+    return false;
+  }
+}
+
+/** `git status --porcelain` lines that are the lane's own work, setup files left out. */
+export const laneWork = (porcelain, lanePath) => porcelain.split("\n").filter(Boolean).filter((line) => {
+  const p = line.slice(3);
+  return !(isLaneSetupPath(p) || (p.endsWith("/") && lanePath && onlySetup(lanePath, p)));
+});
+
+function step(name, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    throw new Error(`lane setup failed at ${name}: ${err?.message || err}`, { cause: err });
+  }
+}
+
+/** @returns {Promise<{ identity: boolean, wired: boolean }>} */
+export async function setupLane({ mainDir, lanePath, logger = console, install = INSTALLERS }) {
+  const source = path.join(mainDir, IDENTITY);
+  const identity = step("the clone identity", () => {
+    if (!fs.existsSync(source)) return false;
+    fs.mkdirSync(path.join(lanePath, ".karajan"), { recursive: true });
+    fs.copyFileSync(source, path.join(lanePath, IDENTITY));
+    return true;
+  });
+  if (identity) logger.info?.(`  identity: ${IDENTITY} copied from the main checkout`);
+  else logger.warn?.(`! no ${IDENTITY} in the main checkout: run kj identity set in the lane before pushing`);
+
+  step("the Sentinel wiring", () => {
+    const quiet = { info: () => {}, warn: (m) => logger.warn?.(m) };
+    const results = [install.sentinel({ projectDir: lanePath, logger: quiet }), install.harness({ projectDir: lanePath, logger: quiet })];
+    if (results.some((r) => !r?.wired)) throw new Error("the hooks were not wired (unreadable .claude/settings.json?)");
+  });
+  logger.info?.("  Sentinel: hooks wired in the lane");
+  return { identity, wired: true };
+}

package/src/hu/lanes.js

@@ -0,0 +1,66 @@
+/**
+ * KJC-TSK-1313: which card each worktree lane works on. Read from git every time, never stored on
+ * the card, so a lane removed by hand never lingers on the board.
+ */
+import path from "node:path";
+
+/**
+ * The worktrees with a branch in `git worktree list --porcelain`. The first entry is the main
+ * checkout and is left out, as are detached worktrees. With `root`, only the lanes under it.
+ * @returns {{slug: string, branch: string, path: string}[]}
+ */
+export function parseLanes(porcelain, { root = null } = {}) {
+  const lanes = [];
+  let current = null;
+  let seen = 0;
+  for (const line of porcelain.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      current = seen++ === 0 ? null : { path: line.slice(9).trim() };
+    } else if (line.startsWith("branch ") && current) {
+      lanes.push({ slug: path.basename(current.path), branch: line.slice(7).trim().replace(/^refs\/heads\//, ""), path: current.path });
+    }
+  }
+  return root ? lanes.filter((l) => l.path.startsWith(root + path.sep)) : lanes;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+
+/**
+ * The lanes of each card: those whose branch carries the card id as a whole token (so HU-2 never
+ * claims HU-27). Cards without a lane have no entry.
+ * @returns {Map<string, {slug: string, branch: string, path: string}[]>}
+ */
+export function lanesByCard(lanes, cardIds) {
+  const byCard = new Map();
+  for (const id of new Set(cardIds)) {
+    const token = new RegExp(`(^|[^a-z0-9])${escapeRe(id)}($|[^a-z0-9])`, "i");
+    const hits = lanes.filter((l) => token.test(l.branch));
+    if (hits.length > 0) byCard.set(id, hits);
+  }
+  return byCard;
+}
+
+/**
+ * The cards a lane works on: those whose id or any of whose references (a tracker card, an
+ * issue) its branch names. `cards` are `{id, refs}`.
+ * @returns {string[]}
+ */
+/**
+ * KJC-TSK-1316: one PR per branch from `gh pr list --json number,url,state,headRefName`: an open
+ * one wins, else the newest (a merged lane is what KJC-TSK-1314 warns about).
+ * @returns {Map<string, {number: number, url: string, state: string}>}
+ */
+export function prsByBranch(prs) {
+  const byBranch = new Map();
+  const open = (p) => (p.state === "OPEN" ? 1 : 0);
+  for (const p of prs) {
+    const cur = byBranch.get(p.headRefName);
+    if (!cur || open(p) > open(cur) || (open(p) === open(cur) && p.number > cur.number)) {
+      byBranch.set(p.headRefName, { number: p.number, url: p.url, state: p.state });
+    }
+  }
+  return byBranch;
+}
+
+export const cardsOfLane = (lane, cards) =>
+  cards.filter((c) => lanesByCard([lane], [c.id, ...c.refs]).size > 0).map((c) => c.id);

package/src/hu/team-board-mirror.js

@@ -19,10 +19,11 @@ export async function writeTeamMirror(projectDir, rows, { repo }) {
   const plan = {
     version: 2, planId: MIRROR_PLAN_ID, name: "github", alias: "github", projectDir,
     task: `Shared HU Board: GitHub Issues of ${repo}`,
-    status: "ready", readonly: "github", createdAt: now,
+    status: "ready", readonly: "github", repo, createdAt: now,
     hus: rows.map((r) => ({
       id: r.short_id, short_id: r.short_id, title: r.title, status: r.status,
-      claimed_by: r.claimed_by ?? null, created_by: "github", external_ref: `${repo}#${r.number}`,
+      // KJC-BUG-0443: the tracker card it replicates too, so the gates find it by that reference.
+      claimed_by: r.claimed_by ?? null, created_by: "github", external_ref: [`${repo}#${r.number}`, r.ref].filter(Boolean).join(" · "),
       acceptance_criteria: [], acceptance_tests: [], createdAt: now, updatedAt: now,
     })),
   };

package/src/infrastructure/command-runner.js

@@ -8,7 +8,7 @@
  *
  * This adapter preserves the runCommand API exactly, so current consumers
  * can opt-in to DI without behavioural changes. A matching MockCommandRunner
- * lives in src/infrastructure/mocks.js and lets tests script outputs per
+ * lives in tests/support/infrastructure-mocks.js and lets tests script outputs per
  * invocation.
  *
  * @typedef {Object} CommandRunResult

package/src/infrastructure/file-system-service.js

@@ -8,7 +8,7 @@
  * This adapter preserves the exact native API shapes for the handful of
  * operations actually used in the codebase, so consumers can opt-in to DI
  * without rewriting call sites. A matching MockFileSystem lives in
- * src/infrastructure/mocks.js.
+ * tests/support/infrastructure-mocks.js.
  *
  * Scope for TSK-0316: intentionally minimal. Only the operations already used
  * by orchestrator + agents. Additional methods added on demand.

package/src/mcp/handlers/direct-handlers.js

@@ -1,6 +1,6 @@
 /**
- * Direct role handler logic (code, review, plan, audit, discover, triage, researcher, architect, impeccable).
- * Extracted from server-handlers.js for maintainability.
+ * Direct role handler logic (code, audit, discover). KJC-TSK-1318: review,
+ * plan, triage, researcher and architect left with the kj run pipeline.
  */
 
 import fs from "node:fs/promises";
@@ -8,12 +8,7 @@ import { resolveRole } from "../../config.js";
 import { createLogger } from "../../utils/logger.js";
 import { assertAgentsAvailable } from "../../agents/availability.js";
 import { createAgent } from "../../agents/index.js";
-import { buildPlannerPrompt } from "../../prompts/planner.js";
 import { buildCoderPrompt } from "../../prompts/coder.js";
-import { buildReviewerPrompt } from "../../prompts/reviewer.js";
-import { parseMaybeJsonString, agentAnswerText } from "../../review/parser.js";
-import { computeBaseRef, generateDiff } from "../../review/diff-generator.js";
-import { resolveReviewProfile } from "../../review/profiles.js";
 import { createRunLog } from "../../utils/run-log.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 import { sendTrackerLog } from "../progress.js";
@@ -66,165 +61,6 @@ function applySessionOverrides(a, roleKeys) {
   }
 }
 
-export async function handlePlanDirect(a, server, extra) {
-  // KJC-PCS-0048 PR 3b: same `specReviewMode: skip` → skipSpecReview
-  // mapping as kj_run. Default "auto" keeps the reviewer enabled.
-  if (a.specReviewMode === "skip") a.skipSpecReview = true;
-  const { normalizePlanArgs } = await import("../tool-arg-normalizers.js");
-  const options = normalizePlanArgs(a);
-  const config = await buildConfig(options, "plan");
-  const logger = createLogger(config.output.log_level, "mcp");
-
-  const plannerRole = resolveRole(config, "planner");
-  await assertAgentsAvailable([plannerRole.provider]);
-
-  const projectDir = await resolveProjectDir(server, a.projectDir);
-  await ensureTaskFromFile(a, projectDir);
-  const runLog = createRunLog(projectDir);
-  const silenceTimeoutMs = Number(config?.session?.max_agent_silence_minutes) > 0
-    ? Math.round(Number(config.session.max_agent_silence_minutes) * 60 * 1000)
-    : undefined;
-  const plannerTimeoutMs = Number(config?.session?.max_planner_minutes) > 0
-    ? Math.round(Number(config.session.max_planner_minutes) * 60 * 1000)
-    : undefined;
-  const silenceLabel = silenceTimeoutMs ? `${Math.round(silenceTimeoutMs / 1000)}s` : "disabled";
-  const runtimeLabel = plannerTimeoutMs ? `${Math.round(plannerTimeoutMs / 1000)}s` : "disabled";
-  runLog.logText(
-    `[kj_plan] started — provider=${plannerRole.provider}, max_silence=${silenceLabel}, max_runtime=${runtimeLabel}`
-  );
-  const emitter = buildDirectEmitter(server, runLog, extra);
-  const eventBase = { sessionId: null, iteration: 0, startedAt: Date.now() };
-
-  // --- Phase 1: Researcher (codebase context) ---
-  let researchContext = null;
-  try {
-    const { ResearcherRole } = await import("../../roles/researcher-role.js");
-    const researcherRole = resolveRole(config, "researcher");
-    const researcherOnOutput = ({ stream, line }) => {
-      emitter.emit("progress", { type: "agent:output", stage: "researcher", message: line, detail: { stream, agent: researcherRole.provider } });
-    };
-    const researcherStall = createStallDetector({
-      onOutput: researcherOnOutput, emitter, eventBase, stage: "researcher", provider: researcherRole.provider
-    });
-
-    sendTrackerLog(server, "researcher", "running", researcherRole.provider);
-    runLog.logText(`[researcher] agent launched for plan context...`);
-    const researcher = new ResearcherRole({ config, logger, emitter });
-    await researcher.init({ task: a.task });
-    let researchOutput;
-    try {
-      researchOutput = await researcher.run({ task: a.task, onOutput: researcherStall.onOutput });
-    } finally {
-      researcherStall.stop();
-    }
-    if (researchOutput.ok) {
-      researchContext = researchOutput.result;
-      sendTrackerLog(server, "researcher", "done");
-      runLog.logText(`[researcher] completed — context available`);
-    } else {
-      sendTrackerLog(server, "researcher", "failed");
-      runLog.logText(`[researcher] failed: ${researchOutput.summary || "unknown"}`);
-    }
-  } catch (err) {
-    logger.warn(`Researcher phase skipped: ${err.message}`);
-  }
-
-  // --- Phase 2: Architect (solution design) ---
-  let architectContext = null;
-  try {
-    const { ArchitectRole } = await import("../../roles/architect-role.js");
-    const architectRole = resolveRole(config, "architect");
-    const architectOnOutput = ({ stream, line }) => {
-      emitter.emit("progress", { type: "agent:output", stage: "architect", message: line, detail: { stream, agent: architectRole.provider } });
-    };
-    const architectStall = createStallDetector({
-      onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectRole.provider
-    });
-
-    sendTrackerLog(server, "architect", "running", architectRole.provider);
-    runLog.logText(`[architect] agent launched for plan context...`);
-    const architect = new ArchitectRole({ config, logger, emitter });
-    await architect.init({ task: a.task });
-    let architectOutput;
-    try {
-      architectOutput = await architect.run({ task: a.task, researchContext, onOutput: architectStall.onOutput });
-    } finally {
-      architectStall.stop();
-    }
-    if (architectOutput.ok) {
-      architectContext = architectOutput.result;
-      sendTrackerLog(server, "architect", "done");
-      runLog.logText(`[architect] completed — context available`);
-    } else {
-      sendTrackerLog(server, "architect", "failed");
-      runLog.logText(`[architect] failed: ${architectOutput.summary || "unknown"}`);
-    }
-  } catch (err) {
-    logger.warn(`Architect phase skipped: ${err.message}`);
-  }
-
-  // --- Phase 3: Planner (with research + architecture context) ---
-  const onOutput = ({ stream, line }) => {
-    emitter.emit("progress", { type: "agent:output", stage: "planner", message: line, detail: { stream, agent: plannerRole.provider } });
-  };
-  const stallDetector = createStallDetector({
-    onOutput, emitter, eventBase, stage: "planner", provider: plannerRole.provider
-  });
-
-  const planner = createAgent(plannerRole.provider, config, logger);
-  const prompt = buildPlannerPrompt({ task: a.task, context: a.context, architectContext });
-  sendTrackerLog(server, "planner", "running", plannerRole.provider);
-  runLog.logText(`[planner] agent launched, waiting for response...`);
-  let result;
-  let plannerStats;
-  try {
-    result = await planner.runTask({
-      prompt,
-      role: "planner",
-      onOutput: stallDetector.onOutput,
-      silenceTimeoutMs,
-      timeoutMs: plannerTimeoutMs
-    });
-  } finally {
-    stallDetector.stop();
-    plannerStats = stallDetector.stats();
-    runLog.logText(
-      `[planner] finished — lines=${plannerStats.lineCount}, bytes=${plannerStats.bytesReceived}, elapsed=${Math.round(plannerStats.elapsedMs / 1000)}s`
-    );
-    runLog.close();
-  }
-
-  if (!result.ok) {
-    sendTrackerLog(server, "planner", "failed");
-    const baseError = result.error || result.output || "Planner failed";
-    const statsSuffix = plannerStats
-      ? ` [lines=${plannerStats.lineCount}, bytes=${plannerStats.bytesReceived}, elapsed=${Math.round(plannerStats.elapsedMs / 1000)}s]`
-      : "";
-    throw new Error(`${baseError}${statsSuffix}`);
-  }
-
-  sendTrackerLog(server, "planner", "done");
-  const parsed = parseMaybeJsonString(result.output);
-
-  // --- Persist plan ---
-  let planId = null;
-  try {
-    const { savePlan } = await import("../../plan/plan-store.js");
-    planId = await savePlan(projectDir, {
-      task: a.task,
-      researchContext,
-      architectContext,
-      plan: parsed || result.output,
-      raw: result.output
-    });
-    runLog.logText(`[kj_plan] plan persisted — planId=${planId}`);
-  } catch (err) {
-    logger.warn(`Plan persistence failed (non-blocking): ${err.message}`);
-  }
-
-  return { ok: true, plan: parsed || result.output, raw: result.output, planId, researchContext, architectContext };
-}
-
 export async function handleCodeDirect(a, server, extra) {
   const config = await buildConfig(a, "code");
   await assertNotOnBaseBranch(config);
@@ -277,55 +113,6 @@ export async function handleCodeDirect(a, server, extra) {
   return { ok: true, output: result.output, exitCode: result.exitCode };
 }
 
-export async function handleReviewDirect(a, server, extra) {
-  const config = await buildConfig(a, "review");
-  await assertNotOnBaseBranch(config);
-  const logger = createLogger(config.output.log_level, "mcp");
-
-  const reviewerRole = resolveRole(config, "reviewer");
-  await assertAgentsAvailable([reviewerRole.provider]);
-
-  const projectDir = await resolveProjectDir(server, a.projectDir);
-  await ensureTaskFromFile(a, projectDir);
-  const runLog = createRunLog(projectDir);
-  runLog.logText(`[kj_review] started — provider=${reviewerRole.provider}`);
-  const emitter = buildDirectEmitter(server, runLog, extra);
-  const eventBase = { sessionId: null, iteration: 0, startedAt: Date.now() };
-  const onOutput = ({ stream, line }) => {
-    emitter.emit("progress", { type: "agent:output", stage: "reviewer", message: line, detail: { stream, agent: reviewerRole.provider } });
-  };
-  const stallDetector = createStallDetector({
-    onOutput, emitter, eventBase, stage: "reviewer", provider: reviewerRole.provider
-  });
-
-  const reviewer = createAgent(reviewerRole.provider, config, logger);
-  const resolvedBase = await computeBaseRef({ baseBranch: config.base_branch, baseRef: a.baseRef });
-  const diff = await generateDiff({ baseRef: resolvedBase });
-  const { rules } = await resolveReviewProfile({ mode: config.review_mode, projectDir: process.cwd() });
-
-  const prompt = await buildReviewerPrompt({ task: a.task, diff, reviewRules: rules, mode: config.review_mode });
-  sendTrackerLog(server, "reviewer", "running", reviewerRole.provider);
-  runLog.logText(`[reviewer] agent launched, waiting for response...`);
-  let result;
-  try {
-    result = await reviewer.reviewTask({ prompt, role: "reviewer", onOutput: stallDetector.onOutput });
-  } finally {
-    stallDetector.stop();
-    const stats = stallDetector.stats();
-    runLog.logText(`[reviewer] finished — lines=${stats.lineCount}, bytes=${stats.bytesReceived}, elapsed=${Math.round(stats.elapsedMs / 1000)}s`);
-    runLog.close();
-  }
-
-  if (!result.ok) {
-    sendTrackerLog(server, "reviewer", "failed");
-    throw new Error(result.error || result.output || `Reviewer failed (exit ${result.exitCode})`);
-  }
-
-  sendTrackerLog(server, "reviewer", "done");
-  const parsed = parseMaybeJsonString(agentAnswerText(result.output));
-  return { ok: true, review: parsed || result.output, raw: result.output };
-}
-
 export async function handleDiscoverDirect(a, server, extra) {
   // Build context from pgTask if provided
   let context = a.context || null;
@@ -350,34 +137,6 @@ export async function handleDiscoverDirect(a, server, extra) {
   });
 }
 
-export async function handleTriageDirect(a, server, extra) {
-  return runDirectRole({
-    roleName: "triage",
-    importRole: async () => {
-      const { TriageRole } = await import("../../roles/triage-role.js");
-      return { RoleClass: TriageRole };
-    },
-    initContext: { task: a.task },
-    runInput: { task: a.task },
-    args: a, server, extra,
-    resolveProjectDir, buildConfig, buildDirectEmitter
-  });
-}
-
-export async function handleResearcherDirect(a, server, extra) {
-  return runDirectRole({
-    roleName: "researcher",
-    importRole: async () => {
-      const { ResearcherRole } = await import("../../roles/researcher-role.js");
-      return { RoleClass: ResearcherRole };
-    },
-    initContext: { task: a.task },
-    runInput: { task: a.task },
-    args: a, server, extra,
-    resolveProjectDir, buildConfig, buildDirectEmitter
-  });
-}
-
 export async function handleAuditDirect(a, server, extra) {
   const task = a.task || "Analyze the full codebase";
   return runDirectRole({
@@ -394,20 +153,6 @@ export async function handleAuditDirect(a, server, extra) {
   });
 }
 
-export async function handleArchitectDirect(a, server, extra) {
-  return runDirectRole({
-    roleName: "architect",
-    importRole: async () => {
-      const { ArchitectRole } = await import("../../roles/architect-role.js");
-      return { RoleClass: ArchitectRole };
-    },
-    initContext: { task: a.task },
-    runInput: { task: a.task, researchContext: a.context || null },
-    args: a, server, extra,
-    resolveProjectDir, buildConfig, buildDirectEmitter
-  });
-}
-
 export async function handleCode(a, server, extra) {
   const missingTask = await requireTask(a, server);
   if (missingTask) return missingTask;
@@ -422,20 +167,6 @@ export async function handleCode(a, server, extra) {
   return handleCodeDirect(a, server, extra);
 }
 
-export async function handleReview(a, server, extra) {
-  const missingTask = await requireTask(a, server);
-  if (missingTask) return missingTask;
-  await runBootstrapGate(server, a);
-  return handleReviewDirect(a, server, extra);
-}
-
-export async function handlePlan(a, server, extra) {
-  const missingTask = await requireTask(a, server);
-  if (missingTask) return missingTask;
-  await runBootstrapGate(server, a);
-  return handlePlanDirect(a, server, extra);
-}
-
 export async function handleDiscover(a, server, extra) {
   const missingTask = await requireTask(a, server);
   if (missingTask) return missingTask;
@@ -447,27 +178,6 @@ export async function handleDiscover(a, server, extra) {
   return handleDiscoverDirect(a, server, extra);
 }
 
-export async function handleTriage(a, server, extra) {
-  const missingTask = await requireTask(a, server);
-  if (missingTask) return missingTask;
-  await runBootstrapGate(server, a);
-  return handleTriageDirect(a, server, extra);
-}
-
-export async function handleResearcher(a, server, extra) {
-  const missingTask = await requireTask(a, server);
-  if (missingTask) return missingTask;
-  await runBootstrapGate(server, a);
-  return handleResearcherDirect(a, server, extra);
-}
-
-export async function handleArchitect(a, server, extra) {
-  const missingTask = await requireTask(a, server);
-  if (missingTask) return missingTask;
-  await runBootstrapGate(server, a);
-  return handleArchitectDirect(a, server, extra);
-}
-
 export async function handleAudit(a, server, extra) {
   await runBootstrapGate(server, a);
   const result = await handleAuditDirect(a, server, extra);