karajan-code 4.70.4 → 5.0.1

package/src/session/journal/write-all.js

@@ -1,89 +0,0 @@
-/**
- * Session-journal writer shared by every terminal path (KJC-BUG-0084).
- *
- * Pre-fix, the iterations/decisions/tree/summary block lived inline in
- * finalizeApprovedSession(), so a run that died on a stage error
- * (sonar_repeat, gh pr create failure, thrown stage) left only triage.md
- * behind — the Cache hits table, the budget breakdown and the commit list
- * vanished exactly on the runs where they matter most. This module is the
- * single writer; the approved path calls it with its enriched extras and
- * flow-runner's `finally` calls it best-effort for every other ending.
- *
- * Never throws: a journal failure must not mask the run's real result.
- */
-
-import { writeIterationsJournal } from "../../orchestrator/session-journal.js";
-import { listCommitsBetween } from "../../utils/git.js";
-import { writeDecisionsJournal } from "./decisions-writer.js";
-import { writeTreeJournal } from "./tree-writer.js";
-import { writeSummaryJournal } from "./summary-writer.js";
-
-/**
- * Write iterations.md, decisions.md, tree.txt and summary.md for a session.
- *
- * @param {object} args
- * @param {object} args.session - live session (needs _journalDir to write)
- * @param {{info?: Function, warn?: Function}} [args.logger]
- * @param {string} [args.result] - summary badge: APPROVED | FAILED | STOPPED…
- * @param {number} [args.iterations]
- * @param {object|null} [args.budget] - budgetSummary() snapshot
- * @param {object} [args.stages] - stageResults map
- * @param {Array}  [args.commits] - precomputed commit list; computed from
- *   session_start_sha when omitted
- * @param {object|null} [args.planAdherence]
- * @returns {Promise<{written: boolean, reason?: string}>}
- */
-export async function writeSessionJournal({ session, logger, result = "APPROVED", iterations = 0, budget = null, stages = {}, commits = null, planAdherence = null }) {
-  const journalDir = session?._journalDir;
-  if (!journalDir) return { written: false, reason: "no journal dir" };
-
-  try {
-    await writeIterationsJournal(journalDir, session._journalIterations || []);
-    const decisionsResult = await writeDecisionsJournal(session, { journalDir, logger });
-    const treeResult = await writeTreeJournal(journalDir, session.session_start_sha, { logger });
-
-    const journalFiles = [...(session._journalFiles || [])];
-    if (session._journalIterations?.length) journalFiles.push("iterations.md");
-    if (decisionsResult.written) journalFiles.push("decisions.md");
-    if (treeResult.written) journalFiles.push("tree.txt");
-
-    // Commit range from session start so the summary shows every commit
-    // the run produced, not just the post-loop scaffold (2026-05-07
-    // dogfooding). try/catch tolerates promise rejection AND a sync
-    // undefined return from a resetAllMocks-stripped test mock.
-    let summaryCommits = Array.isArray(commits) ? commits : null;
-    if (!summaryCommits) {
-      try { summaryCommits = (await listCommitsBetween(session.head_at_start || session.session_start_sha)) || []; }
-      catch { summaryCommits = []; }
-    }
-
-    const startedAt = session._startedAt ? new Date(session._startedAt).toISOString() : undefined;
-    await writeSummaryJournal(journalDir, {
-      task: session.task,
-      result,
-      sessionId: session.id,
-      iterations,
-      durationMs: Date.now() - (session._startedAt || Date.now()),
-      budget,
-      stages,
-      commits: summaryCommits,
-      files: journalFiles,
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      brainDecisions: Array.isArray(session.brainDecisions) ? session.brainDecisions.length : 0,
-      solomonInvocations: Array.isArray(session.solomonRulings) ? session.solomonRulings.length : 0,
-      skills: {
-        addyosmani: session.addyosmaniSkills,
-        installed: session.autoInstalledSkills,
-        recommended: session.skillsRecommended,
-      },
-      planAdherence,
-    }, { logger });
-    session._journalWritten = true;
-    logger?.info?.(`Session journal written to ${journalDir}`);
-    return { written: true };
-  } catch (err) {
-    logger?.warn?.(`Journal write failed (non-blocking): ${err.message}`);
-    return { written: false, reason: err.message };
-  }
-}

package/src/session-cleanup.js

@@ -1,116 +0,0 @@
-/**
- * Automatic cleanup of expired sessions.
- *
- * Policy (by status):
- * - failed / stopped: removed after 1 day
- * - approved: removed after 7 days
- * - running (stale): marked failed + removed after 1 day (crash without cleanup)
- * - paused: kept (user may want to resume)
- *
- * Runs automatically at the start of every kj_run (best-effort, non-blocking).
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-import { getSessionRoot } from "./utils/paths.js";
-
-const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-const DEFAULT_APPROVED_EXPIRY_DAYS = 7;
-
-function buildPolicy(expiryDays) {
-  const approvedMs = (expiryDays ?? DEFAULT_APPROVED_EXPIRY_DAYS) * ONE_DAY_MS;
-  return {
-    failed:   { expiryMs: ONE_DAY_MS },
-    stopped:  { expiryMs: ONE_DAY_MS },
-    running:  { expiryMs: ONE_DAY_MS },   // stale — crashed without marking failed
-    approved: { expiryMs: approvedMs },
-    paused:   null                          // never auto-delete
-  };
-}
-
-const POLICY = buildPolicy();
-
-function shouldRemove(session, policy = POLICY) {
-  const status = session.status || "unknown";
-  const entry = policy[status];
-  if (!entry) return false;
-
-  const updatedAt = new Date(session.updated_at || session.created_at).getTime();
-  return Date.now() - updatedAt > entry.expiryMs;
-}
-
-async function tryCleanupSession({ sessionDir, dirName, removed, errors, logger, policy }) {
-  const sessionFile = path.join(sessionDir, "session.json");
-  let session;
-  try {
-    const raw = await fs.readFile(sessionFile, "utf8");
-    session = JSON.parse(raw);
-  } catch {
-    // Orphan dir without valid session.json — remove if older than 1 day
-    const stat = await fs.stat(sessionDir).catch(() => null);
-    if (stat && Date.now() - stat.mtimeMs > ONE_DAY_MS) {
-      try {
-        await fs.rm(sessionDir, { recursive: true, force: true });
-        removed.push(dirName);
-        logger?.debug?.(`Orphan session dir removed: ${dirName}`);
-      } catch (err) {
-        errors.push({ session: dirName, error: err.message });
-      }
-    }
-    return;
-  }
-
-  if (!shouldRemove(session, policy)) return;
-
-  try {
-    await fs.rm(sessionDir, { recursive: true, force: true });
-    removed.push(dirName);
-    logger?.debug?.(`Session cleaned up: ${dirName} (status: ${session.status})`);
-  } catch (err) {
-    errors.push({ session: dirName, error: err.message });
-  }
-}
-
-export async function cleanupExpiredSessions({ logger, config } = {}) {
-  const expiryDays = config?.session?.expiry_days;
-  const policy = expiryDays ? buildPolicy(expiryDays) : POLICY;
-  const sessionRoot = getSessionRoot();
-
-  let entries;
-  try {
-    entries = await fs.readdir(sessionRoot, { withFileTypes: true });
-  } catch { /* session root does not exist */
-    return { removed: 0, errors: [] };
-  }
-
-  const dirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("s_"));
-  const removed = [];
-  const errors = [];
-
-  for (const dir of dirs) {
-    const sessionDir = path.join(sessionRoot, dir.name);
-    await tryCleanupSession({ sessionDir, dirName: dir.name, removed, errors, logger, policy });
-  }
-
-  if (removed.length > 0) {
-    logger?.info?.(`Cleaned up ${removed.length} expired session(s)`);
-  }
-
-  // Truncate oversized project run logs
-  const maxLogSizeMb = config?.output?.max_log_size_mb ?? 50;
-  await truncateOversizedLog(path.join(process.cwd(), ".kj", "run.log"), maxLogSizeMb, logger);
-
-  return { removed: removed.length, errors };
-}
-
-async function truncateOversizedLog(logPath, maxSizeMb, logger) {
-  if (maxSizeMb <= 0) return;
-  try {
-    const stat = await fs.stat(logPath);
-    const maxBytes = maxSizeMb * 1024 * 1024;
-    if (stat.size > maxBytes) {
-      await fs.truncate(logPath, 0);
-      logger?.info?.(`Truncated oversized log ${logPath} (was ${(stat.size / 1024 / 1024).toFixed(1)}MB, limit ${maxSizeMb}MB)`);
-    }
-  } catch { /* file doesn't exist or can't be read */ }
-}

package/src/skills/semantic-detector.js

@@ -1,167 +0,0 @@
-/**
- * Semantic skill detection using the triage classifier.
- *
- * The regex-based detector (skill-detector.js) is fast but shallow: it only
- * catches dependencies that name themselves explicitly. A task like
- * "add a feature flag system" might benefit from an "a/b-testing" skill
- * that regex cannot guess without an exhaustive keyword list.
- *
- * Semantic mode asks the classifier agent to pick skills from a known
- * catalog given the task text and the skills already detected by regex.
- * The catalog is intentionally small and curated — we don't hit the
- * openskills.cc marketplace API (not available). If the classifier is
- * unavailable (missing provider / missing API key), we return [] and the
- * pipeline keeps working with the regex-only result.
- */
-
-import { createAgent } from "../agents/index.js";
-import { resolveRole } from "../config.js";
-import { withBrainRecovery } from "../brain/with-brain-recovery.js";
-
-/**
- * Curated catalog of skills the classifier is allowed to suggest. Keeping
- * this small prevents the model from hallucinating non-existent skills and
- * bounds the tokens spent on the prompt.
- */
-export const SEMANTIC_CATALOG = [
-  "astro", "nextjs", "react", "vue", "svelte", "angular",
-  "express", "fastify", "nestjs",
-  "java", "kotlin", "go", "rust", "ruby", "php", "dotnet", "elixir",
-  "python", "python-data", "python-ml", "pytest-patterns",
-  "django", "flask", "fastapi",
-  "sql-analysis", "prisma", "mongodb",
-  "owasp-top-10", "security-checklist",
-  "java-code-review", "python-code-review",
-  "frontend-design", "csv-transform", "data-report",
-  "vitest-patterns", "jest-patterns", "playwright-patterns", "cypress-patterns",
-];
-
-const PROMPT = (task, catalog, alreadyDetected) => `You are a classifier that picks which domain skills would help solve a task.
-
-Task:
-"""${task}"""
-
-Already detected skills (do NOT repeat, but consider the task context they imply):
-${alreadyDetected.length > 0 ? alreadyDetected.join(", ") : "(none)"}
-
-From this exact catalog, output a JSON array with the names of 0 to 5 additional skills that would meaningfully help. Output ONLY the JSON array, no prose.
-
-Catalog (pick strict matches only):
-${catalog.join(", ")}
-
-Rules:
-- Only names from the catalog. Do NOT invent.
-- Prefer precision over recall: empty array is a valid answer when nothing fits.
-- Do NOT include already-detected skills.
-- Respond with a single JSON array, e.g. ["python-data","sql-analysis"]
-`;
-
-function tryParseArray(raw) {
-  if (!raw) return [];
-  try {
-    const m = String(raw).match(/\[[^\]]*\]/);
-    if (!m) return [];
-    const parsed = JSON.parse(m[0]);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((s) => typeof s === "string");
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Ask the classifier for additional skills.
- *
- * @param {Object} args
- * @param {string} args.task
- * @param {string[]} args.alreadyDetected
- * @param {Object} args.config - Karajan config
- * @param {Object} [args.logger]
- * @returns {Promise<string[]>}
- */
-export async function refineSkillsSemantically({ task, alreadyDetected = [], config, logger }) {
-  if (!task || typeof task !== "string") return [];
-  let provider;
-  try {
-    provider = resolveRole(config, "triage")?.provider
-      || resolveRole(config, "planner")?.provider
-      || resolveRole(config, "coder")?.provider;
-  } catch {
-    provider = null;
-  }
-  if (!provider) {
-    logger?.debug?.("semantic-detector: no classifier provider — skipping");
-    return [];
-  }
-
-  let agent;
-  try {
-    agent = createAgent(provider, config, logger);
-  } catch (err) {
-    logger?.debug?.(`semantic-detector: classifier unavailable (${err.message}) — skipping`);
-    return [];
-  }
-  if (!agent || typeof agent.runTask !== "function") {
-    logger?.debug?.("semantic-detector: classifier agent has no runTask() — skipping");
-    return [];
-  }
-
-  const prompt = PROMPT(task, SEMANTIC_CATALOG, alreadyDetected);
-  // KJC-TSK-0413 step D: wrap with Brain Recovery. semantic-detector usa
-  // signature legacy `runTask(prompt, opts)` — adapter normaliza al estándar
-  // `runTask({ prompt, timeoutMs })` que withBrainRecovery espera.
-  const adapter = {
-    provider: agent.provider,
-    runTask: (args) => agent.runTask(args.prompt, { timeoutMs: args.timeoutMs }),
-  };
-  let res;
-  try {
-    res = await withBrainRecovery({
-      agent: adapter,
-      taskArgs: { prompt, timeoutMs: 30_000 },
-      role: "semantic-detector",
-      logger,
-    });
-  } catch (err) {
-    logger?.warn?.(`semantic-detector: classifier call failed (${err.message}) — skipping`);
-    return [];
-  }
-  if (!res?.ok) {
-    // En test env el sleep es no-op así que abort viene rápido. Skip-on-fail
-    // sigue siendo el comportamiento — semantic detection es best-effort.
-    logger?.debug?.(`semantic-detector: classifier returned not-ok (${res?.recovery?.class || "unknown"}) — skipping`);
-    return [];
-  }
-
-  const suggested = tryParseArray(res.output || res.result?.raw || "");
-  const allowed = new Set(SEMANTIC_CATALOG);
-  const alreadySet = new Set(alreadyDetected.map((s) => s.toLowerCase()));
-  return suggested
-    .map((s) => String(s).trim())
-    .filter((s) => s && allowed.has(s) && !alreadySet.has(s.toLowerCase()))
-    .slice(0, 5);
-}
-
-/**
- * Resolve the effective skills mode from config + flags.
- * Precedence: flags.skillsMode > config.skills.mode > config.testHarness.defaultSkillsMode > "auto".
- *
- * The testHarness default lets the test harness opt out of semantic
- * detection without each orchestrator test having to mock this module.
- * Production code reads `config.testHarness.defaultSkillsMode` only;
- * the legacy global override is documented and exclusively read in
- * src/config/test-harness.js (ESLint rule #557 blocks any reintroduction
- * of `globalThis.__KJ_*` outside that one file). Legacy callers without
- * a fully-loaded config still work because `config.testHarness` is
- * undefined → falls through to `"auto"`.
- *
- * @param {Object} config
- * @param {Object} [flags]
- * @returns {"auto"|"regex"|"semantic"|"none"}
- */
-export function resolveSkillsMode(config, flags = {}) {
-  const defaultMode = config?.testHarness?.defaultSkillsMode || "auto";
-  const candidate = flags.skillsMode ?? config?.skills?.mode ?? defaultMode;
-  const valid = new Set(["auto", "regex", "semantic", "none"]);
-  return valid.has(candidate) ? candidate : "auto";
-}