@karajan-family/code 4.31.0 → 4.31.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karajan-family/code",
-  "version": "4.31.0",
+  "version": "4.31.1",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/checks/release-check.js

@@ -10,6 +10,7 @@ import { isAbsolute, join } from "node:path";
 import { runCommand } from "../utils/process.js";
 import { loadPrivacyList, scanPaths } from "../privacy/scan.js";
 import { checkStagedDiff, loadPolicy } from "../policy/engine.js";
+import { liftSealedSupervisorViolations } from "../policy/supervisor-verify.js";
 
 // KJC-TSK-0769 — the effect boundary: what ships is re-evaluated against the
 // policy IN FORCE now, not the one each PR was merged under. Artifact rules
@@ -28,7 +29,13 @@ async function policyRangeCheck(projectDir) {
       : ["-C", projectDir, "ls-tree", "-r", "--name-only", "HEAD"]);
     if (listed.exitCode !== 0) throw new Error((listed.stderr || "git failed").trim());
     const files = listed.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-    const violations = checkStagedDiff(policy, { role: "coder", files, netLinesAdded: null }).filter((v) => !prScoped.has(v.rule_id));
+    const raw = checkStagedDiff(policy, { role: "coder", files, netLinesAdded: null }).filter((v) => !prScoped.has(v.rule_id));
+    // KJC-BUG-0178 (ADR 0009): the supervisor seal trips the very rule that
+    // protects the supervisor. `kj review` and `kj policy check` already lift
+    // what the sealed provenance backs; without this the release check blocked
+    // every version cut after a human `kj harden --commit`, by its own seal.
+    const sup = liftSealedSupervisorViolations({ projectDir, violations: raw });
+    const violations = sup.violations;
     const hard = violations.filter((v) => v.enforcement === "deny");
     const skipped = prScoped.size > 0 ? `; ${prScoped.size} diff-threshold invariant(s) skipped (PR-scoped)` : "";
     if (hard.length > 0) {

package/src/cli/advanced-commands.js

@@ -9,6 +9,9 @@
 export const CORE_COMMANDS = [
   "go",
   "start",
+  // BOOT-A (KJC-TSK-0857): starting a project from nothing is as core as it
+  // gets — it is the first command a new project ever runs.
+  "bootstrap",
   "init",
   "run",
   "plan",

package/src/cli/register-meta.js

@@ -5,6 +5,8 @@ import { architectCommand } from "../commands/architect.js";
 import { onboardCommand } from "../commands/onboard.js";
 import { startCommand } from "../commands/start.js";
 import { goCommand } from "../commands/go.js";
+import { bootstrapCommand } from "../commands/bootstrap.js";
+import { PENDING_EXIT_CODE } from "../utils/pending-user-action.js";
 import { identityCommand } from "../commands/identity.js";
 import { policyCommand } from "../commands/policy.js";
 import { claimsCommand, claimsGateCommand } from "../commands/claims.js";
@@ -158,6 +160,18 @@ export function registerMeta(program, { pkgVersion }) {
       });
     });
 
+  // BOOT-A (KJC-TSK-0857, cold-start ADR): the pieces existed, the ORDER did
+  // not. One command from an empty directory to a project under the method.
+  program
+    .command("bootstrap")
+    .description("Del directorio vacío al método listo: repositorio, configuración, harness, gate y RAG, en el orden que funciona")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "bootstrap", flags, async ({ config, logger }) => {
+        const res = await bootstrapCommand({ config, logger, flags });
+        if (!res.ok) process.exitCode = PENDING_EXIT_CODE;
+      });
+    });
+
   // MGL-A (KJC-TSK-0808): the muggle launcher — one command, at most one
   // question, and the person lands inside a governed conversation.
   program

package/src/commands/bootstrap.js

@@ -0,0 +1,75 @@
+/**
+ * BOOT-A (KJC-TSK-0857, epic KJC-PCS-0088) — `kj bootstrap`: from an empty
+ * directory to a project under the method, in one command.
+ *
+ * It invents nothing. The pieces already existed; what was missing was the
+ * ORDER and somebody imposing it. The field report that opened the cold-start
+ * ADR found nine walls on that path, and several of them fired precisely
+ * because the repository had been raised by hand, in the wrong sequence.
+ *
+ * Rules this command obeys:
+ *  - Idempotent. What is already there is reported as `already`, never redone.
+ *  - Fail loud, never half. A step that needs the person's hands STOPS the
+ *    sequence and says which one; nothing downstream pretends it ran.
+ *  - No guarantees without git: the gates live in git hooks, so the repo comes
+ *    first and a git that cannot run is the end of the line, not a warning.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { ensureGitRepo } from "./init.js";
+import { initCommand } from "./init.js";
+import { envInstallCommand } from "./env.js";
+
+const STEP_LABEL = {
+  git: "repositorio",
+  config: "configuración del proyecto",
+  method: "método activo (harness, gate y RAG)",
+};
+
+/**
+ * @returns {Promise<{ok: boolean, pending: string|null, steps: Array<{name: string, status: "done"|"already"|"pending"}>}>}
+ */
+export async function bootstrapCommand({ config = {}, logger = console, flags = {}, deps = {} } = {}) {
+  const projectDir = config.projectDir || process.cwd();
+  const steps = [];
+  const say = (name, status, detail) => {
+    steps.push({ name, status });
+    const mark = status === "already" ? "·" : "✓";
+    logger.info?.(`${mark} ${STEP_LABEL[name]}${detail ? ` — ${detail}` : ""}`);
+  };
+  const stop = (name, why) => {
+    steps.push({ name, status: "pending" });
+    logger.error?.(`✗ ${STEP_LABEL[name]} — ${why}`);
+    return { ok: false, pending: name, steps };
+  };
+
+  // 1. The repository. Without it there are no hooks, and without hooks there
+  //    are no guarantees: this is the one step that cannot be skipped.
+  const hadRepo = existsSync(join(projectDir, ".git"));
+  if (!ensureGitRepo({ projectDir, logger: { info() {}, warn() {} }, gitFn: deps.gitFn })) {
+    return stop("git", "git no está disponible y las garantías de Karajan viven en sus hooks");
+  }
+  say("git", hadRepo ? "already" : "done", hadRepo ? "ya existía" : "creado, sin commit todavía");
+
+  // 2. The project's own configuration.
+  const hasConfig = existsSync(join(projectDir, ".karajan", "kj.config.yml"));
+  if (hasConfig) say("config", "already", "ya estaba");
+  else {
+    const init = await (deps.init ?? initCommand)({ logger, flags: { ...flags, noInteractive: true } });
+    if (init?.exitCode) return stop("config", "queda algo que solo puedes hacer tú, lo tienes arriba");
+    say("config", "done");
+  }
+
+  // 3. The method itself: harness, verdict gate, playbook and RAG index. This
+  //    is the step that turns an installed kj into an enforced one.
+  const hasGate = existsSync(join(projectDir, ".karajan", "review-gate"));
+  if (hasGate) say("method", "already", "ya estaba activo");
+  else {
+    const env = await (deps.env ?? envInstallCommand)({ config, logger, flags: { yes: true } });
+    if (env?.exitCode) return stop("method", "queda algo que solo puedes hacer tú, lo tienes arriba");
+    say("method", "done");
+  }
+
+  return { ok: true, pending: null, steps };
+}

package/src/orchestrator/fs-leak-detector.js

@@ -112,6 +112,24 @@ export function detectNewHomeEntries(before, projectDir) {
  * @param {string|null|undefined} transcript — coder's full output text
  * @returns {string[]} filtered leaks (the subset attributable to coder)
  */
+/**
+ * KJC-BUG-0180 — attribution is not severity. `verifyLeaksAgainstTranscript`
+ * stays strict on purpose: with no transcript it returns everything. But
+ * "the snapshot changed and there is NO evidence the coder did it" is a
+ * different fact from "the coder wrote there", and only the second one
+ * should kill the run. The flaky CI failure was exactly this: other test
+ * files writing under $HOME during the iteration window, an empty
+ * transcript from a mocked coder, and the whole flow failing and retrying.
+ *
+ * @returns {{attributed: string[], unattributed: string[]}} — `attributed`
+ *   fails the run; `unattributed` is reported and the work goes on.
+ */
+export function splitLeakEvidence(leaks, transcript) {
+  const hasTranscript = typeof transcript === "string" && transcript.length > 0;
+  const found = verifyLeaksAgainstTranscript(leaks, transcript);
+  return hasTranscript ? { attributed: found, unattributed: [] } : { attributed: [], unattributed: found };
+}
+
 export function verifyLeaksAgainstTranscript(leaks, transcript) {
   if (!Array.isArray(leaks) || leaks.length === 0) return [];
   if (!transcript || typeof transcript !== "string" || transcript.length === 0) {

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

@@ -20,7 +20,7 @@ import { detectRateLimit } from "../../utils/rate-limit-detector.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 import { buildStandbyState } from "../../brain/standby-store.js";
 import { applyQuotaSimulation } from "../../utils/quota-simulator.js";
-import { snapshotHomeTopLevel, detectNewHomeEntries, formatLeakMessage, verifyLeaksAgainstTranscript, detectTranscriptCdLeaks } from "../fs-leak-detector.js";
+import { snapshotHomeTopLevel, detectNewHomeEntries, formatLeakMessage, splitLeakEvidence, detectTranscriptCdLeaks } from "../fs-leak-detector.js";
 
 export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration, brainCtx, acceptanceTests = null, adrs = null, specSection = null, reviewerFindings = null, huId = null }) {
   logger.setContext({ iteration, stage: "coder" });
@@ -186,9 +186,14 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
   // detected entries against the coder's transcript: only flag those
   // the coder demonstrably referenced.
   const coderTranscript = coderExecResult.result?.output || "";
-  const layer1Leaks = verifyLeaksAgainstTranscript(candidateLeaks, coderTranscript);
+  // KJC-BUG-0180: only what the transcript ATTRIBUTES to the coder fails the
+  // run. Without a transcript there is no evidence it wrote anything, so the
+  // finding is reported and the work goes on — a concurrent host-side write
+  // under $HOME used to kill the whole flow.
+  const { attributed: layer1Leaks, unattributed } = splitLeakEvidence(candidateLeaks, coderTranscript);
   if (candidateLeaks.length > 0 && layer1Leaks.length === 0) {
-    logger.warn(`fs-leak-detector: ${candidateLeaks.length} new $HOME entr(y/ies) detected but none referenced in the coder transcript — likely a concurrent host-side write, not flagging (#546).`);
+    const why = unattributed.length > 0 ? "no coder transcript to attribute them" : "none referenced in the coder transcript";
+    logger.warn(`fs-leak-detector: ${candidateLeaks.length} new $HOME entr(y/ies) detected but ${why} — likely a concurrent host-side write, not flagging (#546).`);
   }
   // Layer 2 (BUG-0032): scan the transcript for `cd <abs-out-of-project> && <write-cmd>`
   // patterns the snapshot-diff misses (e.g. when target dir pre-existed).

package/src/privacy/scan.js

@@ -59,6 +59,17 @@ const SECRET_HEURISTICS = [
 // are blanked before redactPII and COUNTED, so a clean result can say
 // "nothing found" or "found and discarded by context" — never the same thing.
 // The personal denylist runs before this: the user's own datum always blocks.
+// KJC-BUG-0195 — a Google key inside a Firebase web config is public by
+// design: it names the project, and what protects the data are the Firestore
+// rules. It still BLOCKS (the shape alone cannot prove which key it is, and a
+// server key next to it would ride along), but the finding stops being a dead
+// end: it names the declared way out, the allowlist, and what actually
+// protects that key. A gate with no exit teaches people to skip the gate.
+// Markers kept unambiguous on purpose (codex caught projectId being generic
+// enough to appear next to a server key): only Firebase-specific ones count.
+const FIREBASE_WEB_MARKERS = /firebaseConfig|authDomain|firebasestorage|firestore\.googleapis\.com|firebaseapp\.com/;
+const FIREBASE_KEY_HINT = "si es la clave web de Firebase (publica por diseno): declarala en el allow de ~/.karajan/privacy.yml y restringela por dominio en la consola de Google";
+
 const CONTEXT_DISCARDS = [
   { type: "git-sha", re: /\b(?:[0-9a-f]{64}|[0-9a-f]{40})\b/g },
   { type: "doc-domain-email", re: /\b[A-Za-z0-9._%+-]+@(?:[A-Za-z0-9-]+\.)*(?:example\.(?:com|org|net)|test|invalid|localhost|example)\b/g },
@@ -71,6 +82,7 @@ const CONTEXT_DISCARDS = [
 export function scanText(text, { list = loadPrivacyList(), source = "<text>" } = {}) {
   const findings = [];
   let discarded = 0;
+  const firebaseWeb = FIREBASE_WEB_MARKERS.test(String(text));
   String(text).split("\n").forEach((line, i) => {
     let probe = line;
     for (const a of list.allow) probe = probe.split(a).join(" ");
@@ -85,7 +97,8 @@ export function scanText(text, { list = loadPrivacyList(), source = "<text>" } =
       re.lastIndex = 0;
       let m;
       while ((m = re.exec(probe)) !== null) {
-        findings.push({ severity: "block", type, source, line: i + 1, masked: maskValue(m[0]) });
+        const hint = type === "google-key" && firebaseWeb ? ` — ${FIREBASE_KEY_HINT}` : "";
+        findings.push({ severity: "block", type, source, line: i + 1, masked: `${maskValue(m[0])}${hint}` });
         probe = probe.slice(0, m.index) + " ".repeat(m[0].length) + probe.slice(m.index + m[0].length);
         re.lastIndex = m.index + m[0].length;
       }