karajan-code 4.35.1 → 4.37.0

package/package.json

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

package/packages/hu-board/public/utils/board-view.js

@@ -267,7 +267,8 @@ async function renderBoard() {
       try {
         const res = await fetch('/api/rag/query', {
           method: 'POST', headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ text, topK: 5, scope: ragScope?.value || 'all' }),
+          // KJC-TSK-0885: the scoped view searches its own project's index.
+          body: JSON.stringify({ text, topK: 5, scope: ragScope?.value || 'all', ...(scopedProjectSlug ? { project: scopedProjectSlug } : {}) }),
         });
         const body = await res.json();
         if (!res.ok) { ragResults.innerHTML = `<span style="color:var(--color-red);">Error: ${esc(body.error || res.status)}</span>`; return; }

package/packages/hu-board/public/utils/config-editor.js

@@ -27,7 +27,10 @@ async function showConfigEditor(scope = 'global') {
   // resuelve <projectDir> desde KJ_PROJECT_DIR || cwd.
   let cfg;
   try {
-    const r = await fetch(`/api/config?scope=${encodeURIComponent(scope)}`);
+    // KJC-TSK-0885: a scoped view (/p/<slug>, app.js) names its project, so
+    // 'project' is THAT project's file, not the daemon's cwd.
+    const project = scopedProjectSlug ? `&project=${encodeURIComponent(scopedProjectSlug)}` : '';
+    const r = await fetch(`/api/config?scope=${encodeURIComponent(scope)}${project}`);
     if (!r.ok) throw new Error(`HTTP ${r.status}`);
     cfg = await r.json();
   } catch (err) {
@@ -163,7 +166,7 @@ async function showConfigEditor(scope = 'global') {
       const r = await fetch('/api/config', {
         method: 'PUT',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ patch, scope }),
+        body: JSON.stringify({ patch, scope, ...(scopedProjectSlug ? { project: scopedProjectSlug } : {}) }),
       });
       if (!r.ok) {
         const body = await r.json().catch(() => ({}));

package/packages/hu-board/public/utils/terminal-panel.js

@@ -28,7 +28,8 @@ async function openConversationPanel() {
       headers: { 'Content-Type': 'application/json' },
       // Sin agente en el body: decide el servidor (kj go --window fija el
       // elegido por env; sin él, claude).
-      body: JSON.stringify({}),
+      // KJC-TSK-0885: la vista scoped (/p/<slug>) abre la terminal en SU proyecto.
+      body: JSON.stringify(scopedProjectSlug ? { project: scopedProjectSlug } : {}),
     });
     started = await res.json();
     if (!res.ok) throw new Error(started.error || `HTTP ${res.status}`);

package/packages/hu-board/src/config-yaml.js

@@ -52,9 +52,11 @@ function getProjectDir() {
   return process.env.KJ_PROJECT_DIR || process.cwd();
 }
 
-function configPath(scope = 'global') {
+// KJC-TSK-0885: a scoped view passes its project's dir; only without one does
+// the daemon's KJ_PROJECT_DIR || cwd stand in (dashboard, old clients).
+function configPath(scope = 'global', projectDir = null) {
   if (scope === 'project') {
-    return join(getProjectDir(), '.karajan', 'kj.config.yml');
+    return join(projectDir || getProjectDir(), '.karajan', 'kj.config.yml');
   }
   // Same path the parent uses (src/utils/paths.js::getKarajanHome).
   // KJC-TSK-0420: delegate to db.js::getKjHome — gives us KARAJAN_HOME
@@ -63,7 +65,7 @@ function configPath(scope = 'global') {
   return join(getKjHome(), 'kj.config.yml');
 }
 
-function backupPath(scope = 'global') { return `${configPath(scope)}.bak`; }
+function backupPath(scope = 'global', projectDir = null) { return `${configPath(scope, projectDir)}.bak`; }
 
 /**
  * v2.30.0 — Categorías para agrupar los campos en el modal. El backend
@@ -433,13 +435,13 @@ function applyModelMode(parsed, mode) {
  *
  * Returns sane defaults when the file doesn't exist yet.
  */
-export function readConfig({ scope = 'global' } = {}) {
+export function readConfig({ scope = 'global', projectDir = null } = {}) {
   // PR4 — accept scope. Default 'global' preserves the previous behavior;
   // 'project' reads <projectDir>/.karajan/kj.config.yml.
   if (!SCOPES.includes(scope)) {
     throw new Error(`Scope inválido: ${scope}. Permitidos: ${SCOPES.join(', ')}`);
   }
-  const p = configPath(scope);
+  const p = configPath(scope, projectDir);
   let parsed = {};
   let exists = false;
   if (existsSync(p)) {
@@ -471,16 +473,16 @@ export function readConfig({ scope = 'global' } = {}) {
  *
  * @returns {{ path: string, written: boolean, applied: object[], errors: string[] }}
  */
-export function writeConfigPatch(patch, { scope = 'global' } = {}) {
+export function writeConfigPatch(patch, { scope = 'global', projectDir = null } = {}) {
   // PR4 — same shape as readConfig: scope decides target file.
   if (!SCOPES.includes(scope)) {
     return { path: '', scope, written: false, applied: [], errors: [`Scope inválido: ${scope}. Permitidos: ${SCOPES.join(', ')}`] };
   }
   if (!patch || typeof patch !== 'object') {
-    return { path: configPath(scope), scope, written: false, applied: [], errors: ['patch debe ser un objeto'] };
+    return { path: configPath(scope, projectDir), scope, written: false, applied: [], errors: ['patch debe ser un objeto'] };
   }
   // Read current state (or empty if file doesn't exist yet).
-  const p = configPath(scope);
+  const p = configPath(scope, projectDir);
   let parsed = {};
   if (existsSync(p)) {
     try { parsed = yaml.load(readFileSync(p, 'utf8'), { json: true }) || {}; }
@@ -517,7 +519,7 @@ export function writeConfigPatch(patch, { scope = 'global' } = {}) {
   // existing file first so the user can recover.
   const dir = dirname(p);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  if (existsSync(p)) { try { copyFileSync(p, backupPath(scope)); } catch { /* best-effort */ } }
+  if (existsSync(p)) { try { copyFileSync(p, backupPath(scope, projectDir)); } catch { /* best-effort */ } }
   const dump = yaml.dump(parsed, { lineWidth: 120 });
   // mkstemp would be nicer but we want to stay in the same dir for
   // a guaranteed-atomic rename across the same filesystem.

package/packages/hu-board/src/project-dir.js

@@ -0,0 +1,42 @@
+/**
+ * KJC-TSK-0885 (BRD-P2, ADR 0011): the project behind a scoped view.
+ *
+ * The daemon's cwd is not the project (one board serves every project), so a
+ * `/p/<slug>` view sends its slug and the server resolves the directory. It
+ * never takes a path from the client: it reads the `projectDir` the project's
+ * own plans recorded, and accepts it only if it exists and its slug is the one
+ * asked for, so a plan cannot point the board at another directory.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { getHuBoardPlansDirs } from './db.js';
+import { deriveProjectIdFromDir } from './sync.js';
+
+const SLUG_RE = /^[a-zA-Z0-9_.-]+$/;
+
+/** @returns {string|null} the project's directory, or null when unresolvable. */
+export function projectDirForSlug(slug, { plansDirs = getHuBoardPlansDirs() } = {}) {
+  if (typeof slug !== 'string' || !SLUG_RE.test(slug) || slug.startsWith('.')) return null;
+  for (const root of plansDirs) {
+    let names;
+    try { names = readdirSync(join(root, slug)); } catch { continue; }
+    for (const name of names.filter((n) => n.endsWith('.json'))) {
+      let dir;
+      try { dir = JSON.parse(readFileSync(join(root, slug, name), 'utf8'))?.projectDir; } catch { continue; }
+      if (typeof dir === 'string' && deriveProjectIdFromDir(dir) === slug && existsSync(dir)) return dir;
+    }
+  }
+  return null;
+}
+
+/**
+ * The project a request is about: none when it names none (dashboard), its
+ * directory when it resolves, and an Error that says why when it does not.
+ */
+export function requestProjectDir(project) {
+  if (project === undefined || project === null || project === '') return null;
+  const dir = projectDirForSlug(project);
+  if (!dir) throw new Error(`project "${project}" has no plan recording where it lives: run a kj command in it once`);
+  return dir;
+}

package/packages/hu-board/src/routes/api.js

@@ -49,6 +49,7 @@ import { subscribe as subscribeEvents } from '../event-bus.js';
 import { runKjCommand, listSupportedCommands } from '../command-runner.js';
 import { runPreflight } from '../preflight.js';
 import { readConfig, writeConfigPatch } from '../config-yaml.js';
+import { requestProjectDir } from '../project-dir.js';
 import { BOOT_TIME, PKG_VERSION } from '../boot-info.js';
 import { addTombstone, getDb, isTombstoned as isTombstonedFn, removeTombstone, listTombstones } from '../db.js';
 import { publish as publishEvent } from '../event-bus.js';
@@ -1095,7 +1096,8 @@ router.post('/projects/:id/run', (req, res) => {
 router.get('/config', (req, res) => {
   try {
     const scope = req.query?.scope || 'global';
-    const data = readConfig({ scope });
+    // KJC-TSK-0885: a scoped view names its project; the daemon's cwd is not it.
+    const data = readConfig({ scope, projectDir: requestProjectDir(req.query?.project) });
     res.json(data);
   } catch (err) {
     res.status(400).json({ error: err.message });
@@ -1116,7 +1118,9 @@ router.put('/config', (req, res) => {
   try {
     const patch = req.body?.patch;
     const scope = req.body?.scope || 'global';
-    const result = writeConfigPatch(patch, { scope });
+    let projectDir;
+    try { projectDir = requestProjectDir(req.body?.project); } catch (err) { return res.status(400).json({ error: err.message }); }
+    const result = writeConfigPatch(patch, { scope, projectDir });
     if (!result.written) {
       return res.status(400).json({ error: 'No se pudo guardar la configuración', details: result });
     }
@@ -1353,13 +1357,17 @@ router.post('/rag/query', async (req, res) => {
   if (typeof text !== 'string' || text.length === 0) {
     return res.status(400).json({ error: "'text' is required (non-empty string)" });
   }
+  // KJC-TSK-0885 (ADR 0011): a scoped view searches ITS project's index; the
+  // machine-wide store (no filter) returned chunks of any repo.
+  let projectDir;
+  try { projectDir = requestProjectDir(req.body?.project); } catch (err) { return res.status(400).json({ error: err.message }); }
   try {
     const { openVecStore, countChunks } = await import('karajan-core/vec-store');
     // KJC-TSK-0632: resolved from karajan-core — the board carries zero
     // relative imports into the CLI src tree (see no-cli-imports test).
     const { makeEmbedder } = await import('karajan-core/rag/embedders/factory');
     const { query } = await import('karajan-core/rag/retriever');
-    const db = openVecStore({ dim: 768 });
+    const db = openVecStore({ dim: 768, ...(projectDir ? { path: path.join(projectDir, '.karajan', 'rag.db') } : {}) });
     try {
       if (countChunks(db) === 0) return res.json({ hits: [], empty: true, topK, scope });
       const embedder = makeEmbedder({});

package/packages/hu-board/src/terminal-wire.js

@@ -9,6 +9,8 @@
 import { Router } from 'express';
 import { WebSocket, WebSocketServer } from 'ws';
 
+import { requestProjectDir } from './project-dir.js';
+
 const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
 const WS_PATH = '/api/terminal/ws';
 
@@ -20,7 +22,9 @@ export function terminalRouter(manager, { defaultAgent = 'claude' } = {}) {
   const router = Router();
   router.post('/start', (req, res) => {
     try {
-      res.json(manager.start({ agent: req.body?.agent ?? defaultAgent }));
+      // KJC-TSK-0885: la vista scoped nombra su proyecto; el servidor resuelve el dir.
+      const projectDir = requestProjectDir(req.body?.project);
+      res.json(manager.start({ agent: req.body?.agent ?? defaultAgent, ...(projectDir ? { cwd: projectDir } : {}) }));
     } catch (err) {
       res.status(400).json({ error: err.message });
     }

package/packages/hu-board/src/terminal.js

@@ -47,8 +47,12 @@ export function createTerminalManager({ spawnPty, cwd, env = process.env, prompt
 
   return {
     /** Arranca (o devuelve) LA sesión — reutilizar la viva evita que cada
-     *  recarga multiplique agentes. @param {{agent: string}} params */
-    start({ agent }) {
+     *  recarga multiplique agentes. KJC-TSK-0885: `cwd` es el proyecto de la
+     *  vista; sin él, el del daemon. @param {{agent: string, cwd?: string}} params */
+    start({ agent, cwd: wanted = cwd }) {
+      if (session && session.cwd !== wanted) {
+        throw new Error(`terminal: ya hay una sesión viva en ${session.cwd}; termínala antes de abrir otra en ${wanted}.`);
+      }
       if (session) return { termId: session.termId, token: session.token, reused: true };
       // hasOwn: sin él, "constructor"/"__proto__" indexarían el prototipo.
       const spec = Object.hasOwn(TERMINAL_AGENTS, agent) ? TERMINAL_AGENTS[agent] : null;
@@ -65,10 +69,11 @@ export function createTerminalManager({ spawnPty, cwd, env = process.env, prompt
         name: 'xterm-256color',
         cols: 120,
         rows: 32,
-        cwd,
+        cwd: wanted,
         env: cleanEnv,
       });
       const current = {
+        cwd: wanted,
         termId: `term-${randomBytes(8).toString('hex')}`,
         token: randomBytes(16).toString('hex'),
         pty,

package/src/checks/rag-coverage.js

@@ -4,21 +4,22 @@
  * Red only when an index EXISTS and is incomplete or stale: a machine with
  * no index yet (CI, a fresh clone) gets the command, not a failure.
  */
-import { openVecStore } from "../rag/vec-store.js";
+import { openProjectStore } from "../rag/project-store.js";
 import { ragIndexCoverage } from "../rag/coverage.js";
+import { ragExclude } from "../rag/indexable.js";
 import { STRATEGY } from "./types.js";
 
-export function createRagCoverageCheck({ openStore = (dim) => openVecStore({ dim }) } = {}) {
+export function createRagCoverageCheck({ openStore = (dim, projectDir) => openProjectStore({ projectDir, dim }) } = {}) {
   return {
     name: "rag-coverage",
     label: "RAG index coverage (ADR 0010)",
     strategy: STRATEGY.NONE,
     async detect({ config = {}, projectDir = process.cwd() } = {}) {
-      const db = openStore(config?.rag?.embedder?.dim || 768);
+      const db = openStore(config?.rag?.embedder?.dim || 768, projectDir);
       try {
         let c;
         try {
-          c = await ragIndexCoverage(projectDir, { db });
+          c = await ragIndexCoverage(projectDir, { db, exclude: ragExclude(config) });
         } catch (err) {
           // Corrupt store, unreachable stamp, git failure: a failing check,
           // never a silent pass. The only tolerated non-red state is "no index".

package/src/cli/advanced-commands.js

@@ -34,7 +34,7 @@ export const ADVANCED_GROUPS = [
   { title: "Pipeline (piezas sueltas)", commands: ["autorun", "code", "review", "solomon", "agent", "scan", "tournament"] },
   { title: "Análisis pre-run", commands: ["discover", "triage", "researcher", "architect", "onboard", "brief"] },
   { title: "Búsqueda / RAG", commands: ["rag", "qmd", "watch"] },
-  { title: "Calidad / auditoría", commands: ["audit", "check", "mutate", "webperf", "sonar", "privacy", "release", "policy", "claims", "steward"] },
+  { title: "Calidad / auditoría", commands: ["audit", "check", "mutate", "webperf", "sonar", "privacy", "release", "policy", "claims", "steward", "pr-size"] },
   { title: "Sesión / board", commands: ["resume", "report", "board", "hu", "adr", "worktree", "undo", "standby", "sentinel", "identity"] },
   { title: "Infra / setup", commands: ["install-tools", "ollama", "skills", "roles", "agents", "env"] },
   { title: "Mantenimiento", commands: ["clean", "sync", "telemetry", "report-issue"] },

package/src/cli/register-meta.js

@@ -11,7 +11,7 @@ import { identityCommand } from "../commands/identity.js";
 import { policyCommand } from "../commands/policy.js";
 import { claimsCommand, claimsGateCommand } from "../commands/claims.js";
 import { stewardSweepCommand } from "../commands/steward.js";
-import { ragIndexCommand, ragQueryCommand, ragInstallHooksCommand, ragEvalCommand, ragCoversCommand } from "../commands/rag.js";
+import { ragIndexCommand, ragQueryCommand, ragInstallHooksCommand, ragEvalCommand, ragCoversCommand, ragMigrateCommand } from "../commands/rag.js";
 import { qmdQueryCommand } from "../commands/qmd.js";
 import { ragMcpCommand } from "../commands/rag-mcp.js";
 import { watchStartCommand, watchStopCommand, watchStatusCommand } from "../commands/watch.js";
@@ -480,6 +480,7 @@ export function registerMeta(program, { pkgVersion }) {
       // KJC-BUG-0197: manipulación y desfase son hechos distintos y se leen
       // distinto. Un desfase no es un defecto: los guardias que corren están
       // sellados, solo son más viejos que las plantillas de este árbol.
+      else if (res.regenerated?.length && res.ok && !res.drift?.length) console.log(`sentinel verify: ${res.reason}`);
       else if (res.drift?.length && res.ok) console.log(`sentinel verify: scripts sellados, con desfase (${res.drift.join(", ")}) — ${res.reason}`);
       else console.log(res.ok ? "sentinel verify: scripts intactos" : `sentinel verify: modificados fuera de kj harden: ${res.mismatched.join(", ")} — restaura con kj harden`);
       process.exitCode = res.ok ? 0 : 1;
@@ -521,11 +522,23 @@ export function registerMeta(program, { pkgVersion }) {
       await privacyScanCommand({ paths, flags });
     });
 
+  // KJC-TSK-0910: the branch's size while it is written, same budget as CI.
+  program.command("pr-size")
+    .description("Lines this branch adds against its base, with the CI budget (committed, uncommitted and new files)")
+    .option("--json", "Machine-readable result")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "pr-size", flags, async ({ config, logger }) => {
+        const { prSizeCommand } = await import("../commands/pr-size.js");
+        await prSizeCommand({ config, logger, flags });
+      });
+    });
+
   const rag = program.command("rag").description("Retrieval-augmented search over Karajan plans, onboarding briefs and project code");
   rag.command("index")
     .description("Index plans + onboarding (and optionally project sources) into the local vector store")
     .option("--with-sources", "Also index the projectDir's JS/TS files")
     .option("--since <ref>", "Only re-index files changed since <ref> ('auto' uses the last indexed commit; falls back to full index if unset). KJC-TSK-0455.")
+    .option("--file <paths...>", "Index exactly these files (a missing one leaves the index): the remedy for a file absent from the index")
     .option("--json", "Output the totals as JSON")
     .action(async (flags) => {
       await withConfig(pkgVersion, "rag-index", flags, async ({ config, logger }) => {
@@ -534,6 +547,15 @@ export function registerMeta(program, { pkgVersion }) {
     });
   // KJC-BUG-0216: el gate rag-first no puede pedir lo imposible. Esto responde
   // si el RAG PUEDE hablar de un fichero, y si no, por que.
+  // KJC-TSK-0888 (ADR 0011): el paso al indice por proyecto, sin reindexar.
+  rag.command("migrate")
+    .description("Copy this project's chunks from the machine-wide index into its own .karajan/rag.db, embeddings included (no re-embedding); the global index is left untouched")
+    .option("--json", "Emit the result as JSON")
+    .action(async (flags) => {
+      await withConfig(pkgVersion, "rag-migrate", flags, async ({ config }) => {
+        await ragMigrateCommand({ config, flags });
+      });
+    });
   rag.command("covers <file>")
     .description("Whether the RAG can answer about a file: exit 0 when indexed, 1 with the reason it cannot (no adapter, skipped path, empty or stale index)")
     .option("--json", "Emit the state as JSON")
@@ -564,7 +586,7 @@ export function registerMeta(program, { pkgVersion }) {
     .option("--rag-mode <mode>", "hybrid (default) | semantic (cosine only) | keyword (BM25 only)", "hybrid")
     .option("--alpha <n>", "Hybrid weight for semantic component (0..1). Default 0.6", "0.6")
     .option("--where <clause>", "Metadata filter, e.g. 'symbol=loadConfig' or 'hu_id=HU-003 AND kind=plan'")
-    .option("--library", "Query the distilled engineering canon (pattern cards shipped with kj + ~/.karajan/library + project .karajan/library) instead of the project corpus. Cards carry problem signatures, when-NOT-to-apply and canonical citations (KJC-TSK-0697).")
+    .option("--library", "Query the distilled engineering canon (pattern cards shipped with kj + ~/.karajan/library, in ~/.karajan/library.db) instead of the project corpus; a project's own .karajan/library cards live in its index and answer normal queries. Cards carry problem signatures, when-NOT-to-apply and canonical citations (KJC-TSK-0697).")
     .option("--rerank", "Apply cross-encoder rerank to top-K (needs @huggingface/transformers, slower but more precise)")
     .option("--rerank-model <name>", "Cross-encoder model id. Default: Xenova/ms-marco-MiniLM-L-6-v2")
     .option("--json", "Output the hits as JSON")
@@ -627,10 +649,10 @@ export function registerMeta(program, { pkgVersion }) {
     await withConfig(pkgVersion, "watch:start", flags, async ({ config, logger }) => watchStartCommand({ config, logger, flags }));
   });
   watch.command("stop").description("Stop the watcher daemon").action(async () => {
-    await withConfig(pkgVersion, "watch:stop", {}, async ({ logger }) => watchStopCommand({ logger }));
+    await withConfig(pkgVersion, "watch:stop", {}, async ({ config, logger }) => watchStopCommand({ config, logger }));
   });
   watch.command("status").description("Report watcher daemon state").action(async () => {
-    await withConfig(pkgVersion, "watch:status", {}, async ({ logger }) => watchStatusCommand({ logger }));
+    await withConfig(pkgVersion, "watch:status", {}, async ({ config, logger }) => watchStatusCommand({ config, logger }));
   });
 
   program

package/src/commands/board.js

@@ -2,8 +2,9 @@ import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
 import net from "node:net";
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { getKarajanHome } from "../utils/paths.js";
+import { projectSlug as slugOfDir } from "../plan/plan-store.js";
 import { getPortOccupant } from "../utils/port-occupant.js";
 
 const BOARD_DIR = path.resolve(import.meta.dirname, "../../packages/hu-board");
@@ -76,18 +77,29 @@ async function findAvailablePort(desiredPort, maxTries = 10) {
 }
 
 /**
- * Build the board URL. When `projectSlug` is provided, the URL points at
- * the per-project view via the SPA hash route (`#board/<slug>`) so the
- * caller's project shows up pre-filtered instead of "All projects". The
- * frontend router is hash-based (see public/utils/init-listeners.js); a
- * real `/p/<slug>` path is not a route and silently falls back to the
- * global dashboard. KJC-BUG-0093.
+ * Build the board URL. KJC-TSK-0884 (ADR 0011, board scoped): with a project,
+ * the scoped view `/p/<slug>`, one project with the multi-project affordances
+ * hidden (app.js scoped-mode, served by the SPA fallback; checked in a browser).
+ * It replaces KJC-BUG-0093's `#board/<slug>`, which kept the global dashboard.
  * @param {number} port
  * @param {string|null} [projectSlug]
  * @returns {string}
  */
 export function buildBoardUrl(port, projectSlug) {
-  return projectSlug ? boardUrl(port, `/#board/${projectSlug}`) : boardUrl(port);
+  return projectSlug ? boardUrl(port, `/p/${encodeURIComponent(projectSlug)}`) : boardUrl(port);
+}
+
+/**
+ * KJC-TSK-0884: the board slug of a project is its PARENT repo's, even from a
+ * `kj worktree` lane, or the lane opens an empty view.
+ */
+export function boardSlug(projectDir) {
+  let dir = projectDir;
+  try {
+    const common = execFileSync("git", ["-C", projectDir, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (path.basename(common) === ".git") dir = path.dirname(common);
+  } catch { /* not a git repo: the dir is the project */ }
+  return slugOfDir(dir);
 }
 
 /**

package/src/commands/bootstrap.js

@@ -42,6 +42,8 @@ const CONTRACT_PATHS = [
   "CLAUDE.md",
   "AGENTS.md",
   "GEMINI.md",
+  // KJC-TSK-0879: in a Rulesync repo kj's rules live in .rulesync/rules/karajan.md.
+  ".rulesync",
 ];
 const CONTRACT_MESSAGE = "chore(bootstrap): el contrato del método, para que quien clone lo herede";
 

package/src/commands/env.js

@@ -7,7 +7,7 @@
 import { installPlaybook, renderPlaybook } from "../environment/playbook.js";
 import { renderBrief, listBriefs } from "../environment/briefs.js";
 import { existsSync } from "node:fs";
-import { openVecStore, projectSlug, getLastIndexedCommit, dbPath } from "../rag/vec-store.js";
+import { projectSlug, getLastIndexedCommit } from "../rag/vec-store.js";
 import { ragIndexCommand } from "./rag.js";
 import { renderPendingBlock, PENDING_EXIT_CODE } from "../utils/pending-user-action.js";
 import { onnxConfig, persistOnnxChoice, resetEmptyStore } from "../rag/onnx-fallback.js";
@@ -19,13 +19,15 @@ import { createWizard } from "../utils/wizard.js";
 import { hardenCommand } from "./harden.js";
 import { reviewGateCommand } from "./review-gate.js";
 import { join } from "node:path";
+import { openProjectStore, projectDbPath } from "../rag/project-store.js";
+import { maybeRulesyncGenerate } from "../utils/rulesync.js";
 
 function hasRagIndex(config, projectDir) {
   // KJC-BUG-0128: probing must never CREATE the store — openVecStore runs
   // the DDL, and a table born at the default dim (768) breaks the ONNX
   // fallback (384) later. No file → no index, without side effects.
-  if (!existsSync(dbPath())) return false;
-  const db = openVecStore({ dim: config?.rag?.embedder?.dim || 768 });
+  if (!existsSync(projectDbPath(projectDir))) return false;
+  const db = openProjectStore({ projectDir, dim: config?.rag?.embedder?.dim || 768 });
   try { return Boolean(getLastIndexedCommit(db, projectSlug(projectDir))); }
   finally { db.close(); }
 }
@@ -74,6 +76,8 @@ export async function envInstallCommand({ config = null, logger = null, flags =
     config, // KJC-TSK-0865: the panel travels with the method
   });
   console.log(`✓ Karajan playbook installed in: ${result.files.join(", ")}`);
+  // KJC-TSK-0879: in a Rulesync repo, spread the rules only if the project opted in.
+  maybeRulesyncGenerate({ projectDir, config, logger: console });
 
   // KJC-TSK-0711 — RAG as a native tool: agents use what is in their
   // toolbox, so the official path must be cheaper than the grep shortcut.
@@ -169,7 +173,7 @@ export async function envInstallCommand({ config = null, logger = null, flags =
         // KJC-BUG-0128: an empty store may carry a vec table at the wrong
         // dim (the old probe created it at 768) — reset it so ONNX (384)
         // can index. A store with data is never touched.
-        if (!resetEmptyStore()) {
+        if (!resetEmptyStore(projectDir)) {
           console.log("  the vector store already has data at another dimension — not switching automatically");
           return false;
         }

package/src/commands/harden.js

@@ -17,6 +17,7 @@ import { createWizard, isTTY } from "../utils/wizard.js";
 import { commitSupervisorRegeneration } from "../harden/supervisor-commit.js";
 import { installConfigsForRoots } from "../harden/config-engine.js";
 import { installGuidelines } from "../harden/guidelines-engine.js";
+import { maybeRulesyncGenerate } from "../utils/rulesync.js";
 import { commandsForLanguage } from "../harden/hook-commands.js";
 import { installHooks } from "../harden/harden-engine.js";
 import { installHarnessHooks } from "../harden/harness-hooks.js";
@@ -76,6 +77,18 @@ export async function resolveCmds(projectDir, language) {
   return cmds;
 }
 
+/**
+ * KJC-BUG-0233: loadConfig returns `{ config, ... }`; reading `base_branch` off
+ * the result was always undefined, so the guard always protected "main".
+ */
+export async function resolveBaseBranch(projectDir, load = loadConfig) {
+  try {
+    return (await load(projectDir))?.config?.base_branch || "main";
+  } catch {
+    return "main"; // no kj config: the default stands
+  }
+}
+
 export async function hardenCommand({
   projectDir = process.cwd(),
   profile = "standard",
@@ -139,10 +152,7 @@ export async function hardenCommand({
   // KJC-TSK-0648: branch-first guard — the base branch only moves via PR.
   // Resolved from the project's kj config (default "main"); best-effort so
   // harden keeps working on repos that never ran kj init.
-  let baseBranch = "main";
-  try {
-    baseBranch = (await loadConfig(projectDir))?.base_branch || "main";
-  } catch { /* no kj config — default stands */ }
+  const baseBranch = await resolveBaseBranch(projectDir);
   let result;
   try {
     result = await installHooks({ projectDir, profile, cmds, dryRun, baseBranch });
@@ -177,6 +187,12 @@ export async function hardenCommand({
   // KJC-BUG-0199 (issue #1773): the same detected language the workflows and
   // the configs already use — a Python project must not be told to use `const`.
   const gl = withGuidelines ? installGuidelines({ projectDir, language: roots[0]?.language ?? null, dryRun }) : null;
+  // KJC-TSK-0879: in a Rulesync repo, spread the rules only if the project opted in.
+  if (withGuidelines && !dryRun) {
+    let kjConfig = null;
+    try { kjConfig = (await loadConfig(projectDir))?.config; } catch { /* no kj config: not opted in */ }
+    maybeRulesyncGenerate({ projectDir, config: kjConfig, logger });
+  }
   const out = {
     ok: true,
     ...result,
@@ -202,6 +218,12 @@ export async function hardenCommand({
     logger.info?.(`  • ${g.file}: ${g.action}`);
     // KJC-BUG-0206: quitar reglas no puede leerse como "updated" y nada más.
     if (g.shrank) logger.warn?.(`    ⚠ ${g.file} queda con MENOS reglas que antes — revisa si el lenguaje detectado es el que crees (kj check lo dice)`);
+    // KJC-BUG-0232: cuales. Si una es tuya, vivia dentro del bloque: va fuera.
+    if (g.removed?.length) {
+      for (const line of g.removed.slice(0, 10)) logger.warn?.(`      - ${line.length > 120 ? `${line.slice(0, 117)}...` : line}`);
+      if (g.removed.length > 10) logger.warn?.(`      (+${g.removed.length - 10} más)`);
+      logger.warn?.("      Si alguna es vuestra, estaba dentro del bloque gestionado: recuperadla de git y ponedla fuera de él.");
+    }
   }
   if (!dryRun) logger.info?.("core.hooksPath set. Verify later with `kj check`.");
   // IDN-A (KJC-TSK-0762): a hardened clone declares who works it. Captured

package/src/commands/init.js

@@ -344,7 +344,8 @@ async function runWizard(config, logger) {
     config.sonarqube.enabled = enableSonar;
     logger.info(`  -> SonarQube: ${enableSonar ? "enabled" : "disabled"}`);
 
-    const enableHuBoard = await wizard.confirm("Enable the HU Board — a local web UI to track user stories (HUs)?", false);
+    // KJC-TSK-0884: on by default, like Sonar; answering no is a declared opt-out.
+    const enableHuBoard = await wizard.confirm("Enable the HU Board — a local web UI to track user stories (HUs)?", true);
     config.hu_board = config.hu_board || {};
     config.hu_board.enabled = enableHuBoard;
     if (enableHuBoard) {

package/src/commands/plan/generate.js

@@ -512,13 +512,11 @@ async function planGenerateImpl({ task, config, logger, json, context, runLog, f
   // vitest / test mode, and never when `--json` is active.
   if (plan.hus.length > 0 && !process.env.VITEST && process.env.NODE_ENV !== "test") {
     try {
-      const { startBoard, renderBoardBanner } = await import("../board.js");
-      const { projectSlug: slugFor } = await import("../../plan/plan-store.js");
+      const { startBoard, renderBoardBanner, boardSlug } = await import("../board.js");
       const boardPort = config?.hu_board?.port ?? 4000;
-      // `projectSlug` scopes the board URL to this project's view
-      // (`#board/<slug>`) instead of the global "All projects" dashboard.
-      // The hash route opens the board pre-filtered to that project.
-      const boardResult = await startBoard(boardPort, { projectSlug: slugFor(projectDir) });
+      // KJC-TSK-0884: this project's scoped view (/p/<slug>), the parent
+      // repo's even from a worktree lane, never the global dashboard.
+      const boardResult = await startBoard(boardPort, { projectSlug: boardSlug(projectDir) });
       const status = boardResult.alreadyRunning ? "already running" : "started";
       console.log(renderBoardBanner({ url: boardResult.url, status, projectName: plan.name }));
     } catch (err) {

package/src/commands/pr-size.js

@@ -0,0 +1,45 @@
+/**
+ * KJC-TSK-0910 — `kj pr-size`: the branch's size while it is being written,
+ * with the SAME budget the CI gate applies (loc-budget.js). It counts what is
+ * committed, what is not yet, and new files not yet added, against the merge
+ * base with the base branch, so the Sentinel can warn before the gate blocks.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { budgetedAdded } from "../review/loc-budget.js";
+
+const git = (projectDir, args) =>
+  execFileSync("git", ["-C", projectDir, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+
+function mergeBase(projectDir, base) {
+  for (const ref of [`origin/${base}`, base]) {
+    try { return git(projectDir, ["merge-base", "HEAD", ref]).trim(); } catch { /* try the next ref */ }
+  }
+  throw new Error(`pr-size: no merge base with ${base} (nor origin/${base})`);
+}
+
+/** @returns {Promise<{added: number, exempt: number, testAdded: number, base: string}>} */
+export async function branchSize({ projectDir = process.cwd(), base = "main" } = {}) {
+  const from = mergeBase(projectDir, base);
+  // Working tree against the merge base: committed and uncommitted together.
+  let numstat = git(projectDir, ["diff", "--numstat", from]);
+  // New files not yet added are where a branch grows while it is written.
+  for (const file of git(projectDir, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean)) {
+    let text;
+    try { text = readFileSync(join(projectDir, file), "utf8"); } catch { continue; }
+    if (text.includes("\0")) continue; // binary
+    // Lines as git counts them: an empty file adds none.
+    const n = text === "" ? 0 : text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+    numstat += `${n}\t0\t${file}\n`;
+  }
+  return { ...budgetedAdded(numstat), base };
+}
+
+export async function prSizeCommand({ config, logger = console, flags = {} }) {
+  const s = await branchSize({ projectDir: config?.projectDir || process.cwd(), base: config?.base_branch || "main" });
+  if (flags.json) process.stdout.write(`${JSON.stringify(s)}\n`);
+  else logger.info(`pr-size: ${s.added} line(s) added against ${s.base} (${s.testAdded} in tests, ${s.exempt} exempt)`);
+  return s;
+}