karajan-code 3.5.1 → 3.7.0

package/src/autonomy/policy.js

@@ -0,0 +1,41 @@
+/**
+ * autonomy/policy — autonomy levels for Autonomous Delivery (KJC-TSK-0572,
+ * épica KJC-PCS-0062, design in docs/specs/autonomous-delivery.md §4).
+ *
+ * One configurable axis decides who resolves a pipeline question:
+ *   interactive — the human (current behaviour, default)
+ *   assisted    — the human only for high-risk decisions, the Arbiter otherwise
+ *   autonomous  — always the Arbiter; never asks a human, never blocks
+ *
+ * Precedence (most specific wins): CLI flags → env → config → default.
+ */
+
+export const AUTONOMY_LEVELS = Object.freeze(["interactive", "assisted", "autonomous"]);
+
+/** Risk of a decision — drives whether `assisted` escalates to the human. */
+export const RISK = Object.freeze({ LOW: "low", HIGH: "high" });
+
+const DEFAULT_LEVEL = "interactive";
+
+/**
+ * Resolve the active autonomy level. `--autonomous` is sugar for the
+ * `autonomous` level; `--autonomy <level>` sets it explicitly. An unknown
+ * value degrades to the safe default rather than throwing.
+ */
+export function resolveAutonomy({ config = {}, flags = {}, env = {} } = {}) {
+  const raw =
+    flags.autonomy ??
+    (flags.autonomous ? "autonomous" : null) ??
+    env.KJ_AUTONOMY ??
+    config.autonomy ??
+    DEFAULT_LEVEL;
+  const level = String(raw).toLowerCase();
+  return AUTONOMY_LEVELS.includes(level) ? level : DEFAULT_LEVEL;
+}
+
+/** True when the level should route decisions to the Arbiter for `risk`. */
+export function usesArbiter(level, risk = RISK.LOW) {
+  if (level === "autonomous") return true;
+  if (level === "assisted") return risk !== RISK.HIGH;
+  return false; // interactive
+}

package/src/autonomy/stage-ask.js

@@ -0,0 +1,30 @@
+/**
+ * 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;
+}

package/src/checks/ai-trash.js

@@ -23,7 +23,7 @@ function createAiTrashCheck() {
         ok: false,
         severity: "warn",
         detail: "kj-trash not found — destructive ops unprotected",
-        fix: "Reinstall karajan-code (kj-trash ships with the workspace) and run `kj-trash install --claude-code`",
+        fix: "Install karajan-code globally (npm i -g karajan-code) so kj-trash is on PATH, then run `kj-trash install --claude-code`",
       };
     },
   };

package/src/cli/register-meta.js

@@ -406,6 +406,10 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--no-config", "Skip lint/format/commit config files (hooks only)")
     .option("--no-ci", "Skip CI quality workflows")
     .option("--no-guidelines", "Skip AI-agent guideline files (AGENTS.md/CLAUDE.md)")
+    .option("--only <dirs...>", "Harden only these language roots (e.g. frontend backend)")
+    .option("--exclude <globs...>", "Skip language roots matching these globs (e.g. wrappers)")
+    .option("--report", "Read-only: show what kj would add/improve, change nothing")
+    .option("--interactive", "Adopt the kj standard piece by piece (default keeps yours)")
     .option("--dry-run", "Show what would change without writing")
     .option("--json", "Emit machine-readable JSON")
     .action(async (flags) => {
@@ -415,6 +419,10 @@ export function registerMeta(program, { pkgVersion }) {
           config: flags.config !== false,
           ci: flags.ci !== false,
           guidelines: flags.guidelines !== false,
+          only: flags.only ?? [],
+          exclude: flags.exclude ?? [],
+          report: Boolean(flags.report),
+          interactive: Boolean(flags.interactive),
           dryRun: Boolean(flags.dryRun),
           json: Boolean(flags.json),
           logger,

package/src/cli/register-pipeline.js

@@ -114,6 +114,8 @@ export function registerPipeline(program, { pkgVersion }) {
     .option("--skip-role <role...>", "Force one or more roles OFF regardless of triage (e.g. --skip-role tester security)")
     .option("--force-role <role...>", "Force one or more roles ON regardless of triage")
     .option("--skip-spec-review", "Bypass the spec-reviewer pre-pipeline audit")
+    .option("--autonomy <level>", "Autonomy level: interactive | assisted | autonomous (default: interactive)")
+    .option("--autonomous", "Shortcut for --autonomy autonomous: the Arbiter resolves every gate, no human prompts")
     .option("--no-rag-update", "Skip the pre-run RAG drift check (KJC-TSK-0455). Same as config.rag.autoUpdate.onRun=false.")
     .option("--dry-run", "Show what would be executed without running anything")
     .option("--json", "Output JSON only (no styled display)")
@@ -143,6 +145,25 @@ export function registerPipeline(program, { pkgVersion }) {
       });
     });
 
+  program
+    .command("autorun")
+    .description("Unattended delivery: spec → plan → run all HUs → outcome (defaults to --autonomous)")
+    .argument("[task]", "Spec/task description (or use --task-file)")
+    .option("--task-file <path>", "Read the spec from a file (e.g. spec.md)")
+    .option("--autonomy <level>", "interactive | assisted | autonomous (default: autonomous)")
+    .option("--autonomous", "Shortcut for --autonomy autonomous")
+    .option("--skip-spec-review", "Bypass the spec-reviewer pre-pipeline audit")
+    .action(async (task, flags) => {
+      const code = await withConfig(pkgVersion, "autorun", flags, async ({ config, logger }) => {
+        const { resolveTaskInput } = await import("../utils/task-file.js");
+        const { autorunCommand } = await import("../commands/autorun.js");
+        const resolvedTask = await resolveTaskInput({ task, taskFile: flags.taskFile, projectDir: config.projectDir, logger });
+        const res = await autorunCommand({ task: resolvedTask, config, logger, flags });
+        return res?.ok ? 0 : 1;
+      });
+      if (Number.isInteger(code)) process.exit(code);
+    });
+
   program
     .command("code")
     .description("Run only coder")

package/src/cli.js

@@ -41,6 +41,21 @@ program
   .allowUnknownOption(true)
   .allowExcessArguments(true);
 
+// KJC-TSK-0571: the command list is long (30+). Orient a newcomer to the few
+// commands they actually need; the rest are advanced/internal.
+program.addHelpText(
+  "after",
+  `
+Getting started (the basics — start here):
+  kj init             Set up Karajan in this project (run once)
+  kj run "<task>"     Build or fix something end-to-end (coder + review)
+  kj plan "<task>"    Break a task into user stories first, then run them
+  kj doctor           Check your environment is ready
+  kj harden           Add quality git hooks + CI to any repo
+
+Everything else is advanced or internal — you rarely call it directly.`
+);
+
 registerPipeline(program, { pkgVersion: PKG_VERSION });
 registerPlan(program, { pkgVersion: PKG_VERSION });
 registerRolesSkills(program, { pkgVersion: PKG_VERSION });
@@ -116,7 +131,6 @@ program.action(async (_opts, command) => {
 try {
   await migrateKjToKarajan();
 } catch (err) {
-  // eslint-disable-next-line no-console
   console.warn(`\x1b[33m[warn]\x1b[0m home migration skipped: ${err.message}`);
 }
 

package/src/commands/autorun.js

@@ -0,0 +1,49 @@
+/**
+ * `kj autorun <spec>` — the unattended delivery chain (KJC-TSK-0574, épica
+ * KJC-PCS-0062, design in docs/specs/autonomous-delivery.md §7).
+ *
+ * One command: spec → plan → run all HUs → outcome. It reuses `kj plan` and
+ * `kj run --plan` rather than reimplementing them, and defaults to the
+ * `autonomous` level so the Arbiter resolves every gate (no human in the loop).
+ * The rich outcome report lands in AUTO-F; here we chain + propagate exit code.
+ */
+
+import { planGenerateCommand } from "./plan/generate.js";
+import { runCommandHandler } from "./run.js";
+import { buildOutcome, formatOutcomeReport } from "../autonomy/outcome-report.js";
+
+export async function autorunCommand({
+  task,
+  config,
+  logger = console,
+  flags = {},
+  planFn = planGenerateCommand,
+  runFn = runCommandHandler,
+} = {}) {
+  // autorun implies unattended: default to autonomous unless the user picked a
+  // level explicitly (so `kj autorun --autonomy assisted` still works).
+  const autoFlags = flags.autonomy || flags.autonomous ? flags : { ...flags, autonomous: true };
+
+  logger.info?.("kj autorun — planning…");
+  const plan = await planFn({ task, config, logger, flags: autoFlags });
+  if (!plan?.ok || !plan.planId) {
+    logger.error?.(`kj autorun: planning failed${plan?.reason ? ` (${plan.reason})` : ""}.`);
+    return { ok: false, stage: "plan", reason: plan?.reason ?? "plan-failed" };
+  }
+
+  logger.info?.(`kj autorun — running plan ${plan.ref ?? plan.planId} (${plan.huCount ?? "?"} HUs)…`);
+  const run = await runFn({ config, logger, flags: { ...autoFlags, plan: plan.planId } });
+
+  const ok = run?.ok === true;
+  // AUTO-F: emit the auditable outcome — delivered/incomplete, HUs that met the
+  // ask, Arbiter decisions and residual defects (enriched as the run surfaces
+  // them; baseline today is delivered + plan ref).
+  const outcome = buildOutcome({
+    planRef: plan.ref ?? plan.planId,
+    delivered: ok,
+    hus: run?.hus ?? [],
+    decisions: run?.decisions ?? [],
+  });
+  for (const line of formatOutcomeReport(outcome)) logger.info?.(line);
+  return { ok, stage: ok ? "done" : "run", planId: plan.planId, ref: plan.ref ?? plan.planId, outcome };
+}

package/src/commands/harden.js

@@ -9,6 +9,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { compareHarden, formatAdvisoryReport } from "../harden/advisory.js";
+import { interactiveHarden } from "../harden/interactive.js";
+import { createWizard, isTTY } from "../utils/wizard.js";
 import { installConfigsForRoots } from "../harden/config-engine.js";
 import { installGuidelines } from "../harden/guidelines-engine.js";
 import { commandsForLanguage } from "../harden/hook-commands.js";
@@ -23,6 +26,21 @@ const JS_TEST_CMD = {
   mocha: "npx mocha",
 };
 
+/**
+ * Per-repo harden scope, persisted in package.json `kj.harden` so a repo with
+ * sub-tools (e.g. a python wrapper) excludes them once instead of on every
+ * invocation (KJC-TSK-0564). CLI flags are merged on top.
+ */
+function readHardenConfig(projectDir) {
+  const pkgPath = join(projectDir, "package.json");
+  if (!existsSync(pkgPath)) return {};
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf8")).kj?.harden ?? {};
+  } catch {
+    return {};
+  }
+}
+
 /**
  * Resolve the hook's lint/format/test commands for the primary language.
  * Non-JS stacks use their native toolchain (go/ruff/…); JS/TS is built from
@@ -60,9 +78,46 @@ export async function hardenCommand({
   guidelines = true,
   dryRun = false,
   json = false,
+  report = false,
+  interactive = false,
+  only = [],
+  exclude = [],
   logger = console,
 } = {}) {
-  const roots = detectStackRoots(projectDir);
+  const repoCfg = readHardenConfig(projectDir);
+  const onlyDirs = [...(repoCfg.only ?? []), ...only];
+  const excludeDirs = [...(repoCfg.exclude ?? []), ...exclude];
+
+  // --report is read-only: compare against the kj standard and print/emit the
+  // advisory (Advisory B, KJC-TSK-0566), honouring the same scope as an install
+  // so it never proposes a root that `kj harden` would skip. Writes nothing.
+  if (report) {
+    const result = compareHarden({ projectDir, profile, only: onlyDirs, exclude: excludeDirs });
+    if (json) logger.info?.(JSON.stringify(result));
+    else for (const line of formatAdvisoryReport(result)) logger.info?.(line);
+    return { ok: true, report: true, ...result };
+  }
+
+  // --interactive: adopt the kj standard piece by piece, default-safe (keep the
+  // user's own). Only meaningful with a TTY — without one (CI, --json) we fall
+  // through to the normal seed-if-absent install so nothing breaks (KJC-TSK-0567).
+  if (interactive && isTTY() && !json) {
+    const wizard = createWizard();
+    try {
+      return await interactiveHarden({
+        projectDir,
+        profile,
+        only: onlyDirs,
+        exclude: excludeDirs,
+        ask: (prompt, def) => wizard.confirm(prompt, def),
+        logger,
+      });
+    } finally {
+      wizard.close();
+    }
+  }
+
+  const roots = detectStackRoots(projectDir, { only: onlyDirs, exclude: excludeDirs });
   const cmds = await resolveCmds(projectDir, roots[0]?.language ?? null);
   let result;
   try {
@@ -102,6 +157,6 @@ export async function hardenCommand({
   for (const c of out.configs) logger.info?.(`  • ${c.file}: ${c.action}`);
   for (const w of out.workflows) logger.info?.(`  • ${w.file}: ${w.action}`);
   for (const g of out.guidelines) logger.info?.(`  • ${g.file}: ${g.action}`);
-  if (!dryRun) logger.info?.("core.hooksPath set. Verify later with `kj check` (H-E).");
+  if (!dryRun) logger.info?.("core.hooksPath set. Verify later with `kj check`.");
   return out;
 }

package/src/commands/init.js

@@ -91,17 +91,29 @@ async function askAgents(wizard, available, config, logger) {
  * `available.length === 1` short-circuits: every role uses the only CLI
  * available, no point asking.
  */
-async function askPerRoleProviders(wizard, available, config, { coder, reviewer }, logger) {
+async function askPerRoleProviders(wizard, available, config, { coder, reviewer }, logger, ask = true) {
   if (available.length <= 1) return;
 
-  logger.info("");
-  logger.info("Configure provider per role (Enter accepts the default):");
-
   // Make sure containers exist for every role/pipeline key we touch —
   // older configs may have a sparser shape than DEFAULTS.
   config.roles = config.roles || {};
   config.pipeline = config.pipeline || {};
 
+  // KJC-TSK-0571: per-role provider selection is advanced. By default every
+  // role inherits its provider from coder/reviewer — a newcomer has no context
+  // to pick an agent for "refactorer" or "perf". Only init the containers.
+  if (!ask) {
+    for (const role of PER_ROLE_QUESTIONS) {
+      config.roles[role.key] = config.roles[role.key] || { provider: null, model: null };
+      if (role.pipelineKey) config.pipeline[role.pipelineKey] = config.pipeline[role.pipelineKey] || { enabled: false };
+    }
+    logger.info("  Agent routing: every role inherits from your coder/reviewer (default).");
+    return;
+  }
+
+  logger.info("");
+  logger.info("Configure provider per role (Enter accepts the default):");
+
   for (const role of PER_ROLE_QUESTIONS) {
     config.roles[role.key] = config.roles[role.key] || { provider: null, model: null };
     if (role.pipelineKey) {
@@ -150,14 +162,14 @@ async function askFallbackChain(wizard, available, config, { coder, reviewer },
   if (available.length < 2) return;
 
   logger.info("");
-  logger.info("Plan B — fallback automático cuando un provider se queda sin créditos:");
+  logger.info("Plan B — automatic fallback when a provider runs out of credits:");
   const enable = await wizard.confirm(
-    "  ¿Configurar fallback? (default: 12h; si el cooldown supera ese tiempo, switch al provider alternativo)",
+    "  Configure a fallback? (default 12h; if the cooldown exceeds it, switch to the alternate provider)",
     true
   );
   if (!enable) return;
 
-  const maxHoursRaw = await wizard.input("  Máximo tiempo de espera antes de fallback (horas):", "12");
+  const maxHoursRaw = await wizard.input("  Max wait before falling back (hours):", "12");
   const maxHours = Number.parseFloat(maxHoursRaw) || 12;
 
   config.roles = config.roles || {};
@@ -168,18 +180,18 @@ async function askFallbackChain(wizard, available, config, { coder, reviewer },
   ];
   for (const role of KEY_ROLES) {
     config.roles[role.key] = config.roles[role.key] || {};
-    const opts = [{ label: "Sin fallback (hibernar)", value: "__none__", available: true }];
+    const opts = [{ label: "No fallback (hibernate)", value: "__none__", available: true }];
     for (const a of available) {
       if (a.name === role.primary) continue;
       opts.push({ label: a.name, value: a.name, available: true });
     }
-    const choice = await wizard.select(`  Fallback de ${role.label} cuando ${role.primary} se quede sin créditos:`, opts);
+    const choice = await wizard.select(`  Fallback for ${role.label} when ${role.primary} runs out of credits:`, opts);
     if (choice === "__none__") {
       delete config.roles[role.key].fallback;
-      logger.info(`    -> ${role.key}: sin fallback (hibernará)`);
+      logger.info(`    -> ${role.key}: no fallback (will hibernate)`);
     } else {
       config.roles[role.key].fallback = { provider: choice, max_wait_hours: maxHours };
-      logger.info(`    -> ${role.key}: ${role.primary} → ${choice} (tras ${maxHours}h)`);
+      logger.info(`    -> ${role.key}: ${role.primary} → ${choice} (after ${maxHours}h)`);
     }
   }
 }
@@ -206,7 +218,7 @@ async function askLanguages(wizard, config, logger) {
     ...allLangEntries.filter((o) => o.value !== detectedLocale),
   ];
 
-  const pipelineLang = await wizard.select("Pipeline language:", languageOptions);
+  const pipelineLang = await wizard.select("Language for agent messages and reports:", languageOptions);
   config.language = pipelineLang;
   logger.info(`  -> Pipeline language: ${pipelineLang}`);
 
@@ -214,14 +226,14 @@ async function askLanguages(wizard, config, logger) {
     ...allLangEntries.filter((o) => o.value === pipelineLang),
     ...allLangEntries.filter((o) => o.value !== pipelineLang),
   ];
-  const huLang = await wizard.select("HU language (for user stories):", huLangOptions);
+  const huLang = await wizard.select("Language for user stories (HUs):", huLangOptions);
   config.hu_language = huLang;
-  logger.info(`  -> HU language: ${huLang}`);
+  logger.info(`  -> User-story language: ${huLang}`);
 }
 
 async function askGitAutomation(wizard, config, logger) {
   config.git = config.git || {};
-  const autoCommit = await wizard.confirm("Auto-commit per HU? (recommended for `kj run` so commits show up in git log)", false);
+  const autoCommit = await wizard.confirm("Auto-commit per user story? (recommended for `kj run` so commits show up in git log)", false);
   config.git.auto_commit = autoCommit;
   logger.info(`  -> auto_commit: ${autoCommit}`);
 
@@ -268,30 +280,20 @@ async function askBoardSecurity(wizard, config, logger) {
 /**
  * Explicit, opt-in telemetry consent. We do NOT inherit a "Karajan-installed
  * users want to help" assumption — silence and missing config keys both mean
- * "no". The prompt is rendered in the OS locale (EN/ES today; falls back to
- * EN for everything else) so users see it in their own language even before
- * they've set `config.language`. See src/utils/telemetry.js and the
+ * "no". The prompt is English to match the rest of the wizard (KJC-BUG-0088).
+ * See src/utils/telemetry.js and the
  * "Privacy & Telemetry" section of README.md for what gets sent.
  */
 async function askTelemetry(wizard, config, logger) {
-  const locale = detectOsLocale();
-  const prompts = {
-    es: {
-      question: "¿Quieres ayudar a mejorar Karajan enviando telemetría anónima al proyecto?",
-      detail: "  (versión, OS, comandos, duración del pipeline — sin código, sin tareas, sin datos personales)",
-      previewIntro: "  Ejemplo del payload exacto que se enviaría al ejecutar `kj run` (puedes inspeccionar más con `kj telemetry preview`):",
-      enabled: "  -> Telemetría: activada (¡gracias!)",
-      disabled: "  -> Telemetría: desactivada",
-    },
-    en: {
-      question: "Help improve Karajan by sending anonymous telemetry to the project?",
-      detail: "  (version, OS, commands, pipeline duration — no code, no tasks, no personal data)",
-      previewIntro: "  Example of the exact payload that would be sent when you run `kj run` (inspect more with `kj telemetry preview`):",
-      enabled: "  -> Telemetry: enabled (thank you!)",
-      disabled: "  -> Telemetry: disabled",
-    },
+  // English to stay consistent with the rest of the wizard (KJC-BUG-0088); the
+  // user's chosen pipeline/HU language drives `kj run` output, not this prompt.
+  const t = {
+    question: "Help improve Karajan by sending anonymous telemetry to the project?",
+    detail: "  (version, OS, commands, pipeline duration — no code, no tasks, no personal data)",
+    previewIntro: "  Example of the exact payload sent when you run `kj run` (inspect more with `kj telemetry preview`):",
+    enabled: "  -> Telemetry: enabled (thank you!)",
+    disabled: "  -> Telemetry: disabled",
   };
-  const t = prompts[locale] || prompts.en;
   logger.info(t.detail);
   const example = buildTelemetryPayload("cli_command", { version: "x.y.z", command: "run" });
   logger.info(t.previewIntro);
@@ -330,7 +332,7 @@ async function runWizard(config, logger) {
   try {
     const { coder, reviewer } = await askAgents(wizard, available, config, logger);
 
-    const enableTriage = await wizard.confirm("Enable triage (auto-classify task complexity)?", false);
+    const enableTriage = await wizard.confirm("Enable triage (auto-pick a lighter pipeline for simple tasks)?", false);
     config.pipeline.triage = config.pipeline.triage || {};
     config.pipeline.triage.enabled = enableTriage;
     logger.info(`  -> Triage: ${enableTriage ? "enabled" : "disabled"}`);
@@ -339,7 +341,7 @@ async function runWizard(config, logger) {
     config.sonarqube.enabled = enableSonar;
     logger.info(`  -> SonarQube: ${enableSonar ? "enabled" : "disabled"}`);
 
-    const enableHuBoard = await wizard.confirm("Enable HU Board for story tracking?", false);
+    const enableHuBoard = await wizard.confirm("Enable the HU Board — a local web UI to track user stories (HUs)?", false);
     config.hu_board = config.hu_board || {};
     config.hu_board.enabled = enableHuBoard;
     if (enableHuBoard) {
@@ -348,8 +350,19 @@ async function runWizard(config, logger) {
     }
     logger.info(`  -> HU Board: ${enableHuBoard ? "enabled (auto-start on kj run)" : "disabled"}`);
 
-    await askPerRoleProviders(wizard, available, config, { coder, reviewer }, logger);
-    await askFallbackChain(wizard, available, config, { coder, reviewer }, logger);
+    // KJC-TSK-0571: per-role providers + fallback chains are advanced and
+    // collapse a newcomer's first run by ~12 questions. Ask one gate; default
+    // off → every role inherits from coder/reviewer.
+    const advancedRouting =
+      available.length > 1 &&
+      (await wizard.confirm(
+        "Configure advanced agent routing (a different AI per role + fallback chains)? Most users don't need this.",
+        false
+      ));
+    await askPerRoleProviders(wizard, available, config, { coder, reviewer }, logger, advancedRouting);
+    if (advancedRouting) {
+      await askFallbackChain(wizard, available, config, { coder, reviewer }, logger);
+    }
     await askMethodology(wizard, config, logger);
     await askLanguages(wizard, config, logger);
 
@@ -686,16 +699,24 @@ export async function resolveConfigScope({ flags, interactive }) {
   if (flags?.global) return { configPath: getConfigPath(), scope: "global" };
   if (flags?.local) return { configPath: getProjectConfigPath(process.cwd()), scope: "local" };
   if (interactive) {
+    const globalPath = getConfigPath();
+    // KJC-BUG-0087: on a true first run (no global config yet) there is no
+    // meaningful choice — set up the global config and skip a cold question a
+    // newcomer has no context to answer. Only when a global already exists is
+    // "override just for this project?" an actual decision worth asking.
+    if (!(await exists(globalPath))) {
+      return { configPath: globalPath, scope: "global" };
+    }
     const wizard = createWizard();
     try {
       const choice = await wizard.select(
-        "Where do you want to save the config? (default: global)",
+        "You already have a global Karajan config. For this project, do you want to…",
         [
-          { value: "global", label: `Global (${getConfigPath()} — applies to all projects)` },
-          { value: "local",  label: `Local  (${getProjectConfigPath(process.cwd())} — overrides global for this project only)` },
+          { value: "global", label: "Use the global config (your default for every project)" },
+          { value: "local", label: `Override it just for this project (${getProjectConfigPath(process.cwd())})` },
         ]
       );
-      return { configPath: choice === "local" ? getProjectConfigPath(process.cwd()) : getConfigPath(), scope: choice };
+      return { configPath: choice === "local" ? getProjectConfigPath(process.cwd()) : globalPath, scope: choice };
     } finally {
       wizard.close();
     }
@@ -717,7 +738,11 @@ export async function initCommand({ logger, flags = {} }) {
   const reviewRulesPath = path.resolve(karajanDir, "review-rules.md");
   const coderRulesPath = path.resolve(karajanDir, "coder-rules.md");
 
-  const { config, exists: configExists } = await loadConfig();
+  const { config } = await loadConfig();
+  // KJC-BUG-0087: ask "reconfigure?" only when a config exists AT THE CHOSEN
+  // scope path — not when the global cascade has one. Picking local scope in a
+  // fresh dir must not report the unrelated global config as "already exists".
+  const configExists = await exists(configPath);
 
   // Auto-detect language from OS locale for non-interactive mode
   if (!interactive && !configExists) {
@@ -807,7 +832,7 @@ export async function initCommand({ logger, flags = {} }) {
       await installAiTrashHook(logger);
     } else {
       logger.warn("ai-trash kj-trash binary not found — destructive ops unprotected.");
-      logger.warn("  Reinstall karajan-code so kj-trash is on PATH.");
+      logger.warn("  Install karajan-code globally (npm i -g karajan-code) so kj-trash is on PATH.");
     }
   }
 
@@ -864,6 +889,13 @@ export async function initCommand({ logger, flags = {} }) {
     const version = JSON.parse(readFileSync(pkgPath, "utf8")).version;
     sendTelemetryEvent("install", { version }, config).catch(() => {});
   } catch { /* non-blocking */ }
+
+  // Clear close so a first-time user knows setup finished and what to do next,
+  // instead of being left at the end of a wall of detection logs (KJC-BUG-0088).
+  logger.info("");
+  logger.info("✓ Karajan is set up in this project.");
+  logger.info('  Next:  kj run "describe what to build or fix"');
+  logger.info("  More:  kj --help   ·   kj doctor (check your setup)");
 }
 
 // Internal exports for unit testing (KJC-TSK-0367)

package/src/commands/plan/generate.js

@@ -457,7 +457,7 @@ async function planGenerateImpl({ task, config, logger, json, context, runLog, f
 
   if (json) {
     console.log(JSON.stringify(plan, null, 2));
-    return { ok: true };
+    return { ok: true, planId, ref: plan.alias || planId, huCount: plan.hus.length };
   }
 
   if (parsed?.approach) {
@@ -524,5 +524,6 @@ async function planGenerateImpl({ task, config, logger, json, context, runLog, f
       console.log(`\nVisualize: kj board start (http://localhost:${config?.hu_board?.port ?? 4000})`);
     }
   }
-  return { ok: true };
+  // KJC-TSK-0574: surface planId/ref so `kj autorun` can chain plan → run.
+  return { ok: true, planId, ref, huCount: plan.hus.length };
 }

package/src/commands/run.js

@@ -17,6 +17,8 @@ import { maybeAutoUpdate } from "../rag/auto-update.js";
 // keep working. KJC-BUG-0081 round 2 split the body into utils/ because
 // resume.js also needs the same contract.
 import { createCliAskQuestion } from "../utils/cli-ask-question.js";
+import { buildDecider } from "../autonomy/decider.js";
+import { createAutonomyAskQuestion } from "../autonomy/stage-ask.js";
 export { createCliAskQuestion };
 
 export async function runCommandHandler({ task, config, logger, flags }) {
@@ -129,12 +131,16 @@ export async function runCommandHandler({ task, config, logger, flags }) {
 
     const askQuestion = createCliAskQuestion({ flags });
 
+    // Autonomy (KJC-PCS-0062): wire the level to a resolver. In autonomous mode
+    // every gate is decided by the Arbiter instead of the human; interactive
+    // keeps the human prompts. The decider is threaded into the gates below.
+    const { autonomy, resolve: decide } = buildDecider({ config, flags, ask: askQuestion, logger });
+
     // Spec-reviewer pre-pipeline audit (KJC-PCS-0048). Runs BEFORE
-    // anything else — surfaces ambiguity / missing scope / missing AC
-    // and lets the user bail out cheap, before any tokens burn.
-    // Bypass with --skip-spec-review. Static import — the role runs
-    // on every kj invocation (modulo bypass), no lazy-load benefit.
-    const reviewResult = await runSpecReview({ spec: task, config, logger, askQuestion, flags });
+    // anything else — surfaces ambiguity / missing scope / missing AC.
+    // In autonomous mode the Arbiter decides (never aborts); interactive
+    // lets the user bail. Bypass with --skip-spec-review.
+    const reviewResult = await runSpecReview({ spec: task, config, logger, askQuestion, flags, resolve: decide, autonomy });
     if (!reviewResult.proceed) {
       logger.info("Aborted by user after spec review.");
       cleanupRegistry();
@@ -145,9 +151,14 @@ export async function runCommandHandler({ task, config, logger, flags }) {
     // user actually approved.
     const effectiveTask = reviewResult.refined && reviewResult.finalSpec ? reviewResult.finalSpec : task;
 
+    // AUTO-E: in autonomous mode the stages never ask a human or block on the
+    // board — they auto-continue with the least-bad choice. interactive/assisted
+    // keep the human prompts.
+    const stageAsk = createAutonomyAskQuestion({ baseAsk: askQuestion, autonomy, logger });
+
     let result;
     try {
-      result = await runFlow({ task: effectiveTask, config, logger, flags, emitter, askQuestion, pgTaskId: pgCardId || null, pgProject: pgProject || null });
+      result = await runFlow({ task: effectiveTask, config, logger, flags, emitter, askQuestion: stageAsk, pgTaskId: pgCardId || null, pgProject: pgProject || null });
     } finally {
       // KJC-TSK-0396: limpia el registro pase lo que pase (éxito,
       // throw, o paused). Los handlers de SIGINT/SIGTERM/exit son
@@ -163,6 +174,12 @@ export async function runCommandHandler({ task, config, logger, flags }) {
       // failed), tell the user the exact command to resume it.
       printResumeHint(result);
     }
-    return { ok: !result?.paused && result?.approved !== false };
+    // Surface per-HU results so `kj autorun` can build a real outcome report
+    // (KJC-BUG-0090: it showed "0/0 met the ask" because only { ok } came back).
+    // The plan run returns them as `huResults` (run-hu-batch finalResult).
+    const hus = Array.isArray(result?.huResults)
+      ? result.huResults.map((r) => ({ id: r.huId, met: r.approved === true }))
+      : [];
+    return { ok: !result?.paused && result?.approved !== false, hus };
   });
 }