kibi-cli 0.19.0 → 2.0.0

package/dist/commands/discovery-shared.js

@@ -1,13 +1,12 @@
 import path from "node:path";
 import { EngineClient } from "../engine.js";
-import { getBranchOverride } from "../env.js";
 import { PrologProcess, resolveKbPlPath } from "../prolog.js";
 import { escapeAtom } from "../prolog/codec.js";
 import { executeOperation, } from "../public/operations/runtime-types.js";
 import { createCliRuntime } from "../runtime/cli-runtime.js";
+import { resolveBranchAttachment } from "../utils/branch-resolver.js";
 import { safeCleanupProlog } from "../utils/prolog-cleanup.js";
 import { renderDiscoveryTable } from "./discovery-table.js";
-import { getCurrentBranch } from "./init-helpers.js";
 export { renderCoverageTable } from "./discovery-table.js";
 // implements REQ-kibi-operation-interface-parity
 export async function executeReportingSpec(spec, input, options = {}) {
@@ -22,13 +21,10 @@ export async function withAttachedBranchProlog(callback, deps) {
     let attached = false;
     let branchName;
     try {
-        try {
-            branchName =
-                getBranchOverride() || (await getCurrentBranch(process.cwd()));
-        }
-        catch {
-            branchName = getBranchOverride() || "main";
-        }
+        const attachment = resolveBranchAttachment(process.cwd());
+        if ("error" in attachment)
+            throw new Error(attachment.error);
+        branchName = attachment.kbBranch;
         if (usesEngine) {
             engine = new EngineClient({
                 workspaceRoot: process.cwd(),
@@ -42,9 +38,8 @@ export async function withAttachedBranchProlog(callback, deps) {
             prolog = createProlog({ timeout: 120000 });
             await prolog.start();
         }
-        await prolog.query("set_prolog_flag(answer_write_options, [max_depth(0), spacing(next_argument)])");
         if (!usesEngine) {
-            const kbPath = path.join(process.cwd(), ".kb/branches", branchName);
+            const kbPath = attachment.storePath;
             const attachResult = await prolog.query(`kb_attach('${escapeAtom(kbPath)}')`);
             if (!attachResult.success) {
                 throw new Error(`Failed to attach KB: ${attachResult.error || "Unknown error"}`);
@@ -65,14 +60,10 @@ export async function withAttachedBranchProlog(callback, deps) {
 // implements REQ-003
 // implements REQ-003
 export async function resolveCurrentKbPath() {
-    let branch;
-    try {
-        branch = getBranchOverride() || (await getCurrentBranch(process.cwd()));
-    }
-    catch {
-        branch = getBranchOverride() || "main";
-    }
-    return path.join(process.cwd(), ".kb/branches", branch);
+    const attachment = resolveBranchAttachment(process.cwd());
+    if ("error" in attachment)
+        throw new Error(attachment.error);
+    return attachment.storePath;
 }
 // implements REQ-003
 export function resolveCoreModulePath(fileName, deps) {

package/dist/commands/doctor.d.ts

@@ -1,4 +1,29 @@
-export declare function doctorCommand(): Promise<{
+export interface DoctorOptions {
+    format?: "json" | "table";
+}
+export declare function doctorCommand(options?: DoctorOptions): Promise<{
     exitCode: number;
 }>;
+export declare function detectExecuteApplyPlanExport(load?: () => Promise<{
+    executeApplyPlan?: unknown;
+}>): Promise<boolean>;
+export declare function packageMigrationActions(runtime: Readonly<Record<string, unknown>>): Promise<Readonly<{
+    id: string;
+    code: string;
+    category: "package" | "branch" | "storage" | "schema" | "freshness" | "relationship" | "symbol" | "semantic" | "proof" | "quality";
+    state: import("../public/operations/migration-plan.js").MigrationActionState;
+    safety: import("../public/operations/migration-plan.js").MigrationSafety;
+    invocation: import("../public/operations/migration-plan.js").MigrationInvocation;
+    affectedEntityIds: readonly string[];
+    affectedFiles: readonly string[];
+    dependsOn: readonly string[];
+    preconditions: readonly Readonly<Record<string, unknown>>[];
+    postconditions: readonly Readonly<Record<string, unknown>>[];
+    evidence: Readonly<Record<string, unknown>>;
+    autoApplicable: boolean;
+    dispositionRequired: boolean;
+    allowedDispositions: readonly import("../public/operations/migration-plan.js").MigrationDisposition[];
+}>[]>;
+export declare function nextAncestorDirectory(current: string): string | undefined;
+export declare function nearestNamedPackageManifest(startDir: string, name: string): string | undefined;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AA4BA,wBAAsB,aAAa,IAAI,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAyDnE"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAmCA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAiF/B;AAED,wBAAsB,4BAA4B,CAChD,IAAI,GAAE,MAAM,OAAO,CAAC;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,CACT,GACxC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;MAkE3C;AAkGD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAepB"}

package/dist/commands/doctor.js

@@ -17,9 +17,14 @@
 */
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildMigrationPlan, migrationAction, } from "../public/operations/migration-plan.js";
+import { readKbManifestStatus } from "../utils/kb-manifest.js";
+import { planLegacyStorageMigration } from "./legacy-storage-migration.js";
 // implements REQ-003
-export async function doctorCommand() {
+export async function doctorCommand(options = {}) {
     const checks = [
         {
             name: "SWI-Prolog",
@@ -30,8 +35,12 @@ export async function doctorCommand() {
             check: checkKbDirectory,
         },
         {
-            name: "config.json",
-            check: checkConfigJson,
+            name: ".kb/ manifest",
+            check: checkKbManifest,
+        },
+        {
+            name: "Canonical storage",
+            check: checkLegacyStorage,
         },
         {
             name: "Git repository",
@@ -50,18 +59,35 @@ export async function doctorCommand() {
             check: checkPostRewriteHook,
         },
     ];
+    const results = checks.map(({ name, check }) => ({ name, ...check() }));
+    const allPassed = results.every((result) => result.passed);
+    const runtime = await runtimeProvenance();
+    const packageActions = await packageMigrationActions(runtime);
+    const migrationPlan = buildMigrationPlan({
+        expected: {
+            branch: null,
+            kbBranch: null,
+            configHash: null,
+        },
+        evaluatedDomains: ["package"],
+        actions: packageActions,
+    });
+    if (options.format === "json") {
+        console.log(JSON.stringify({
+            version: "kibi.doctor.v1",
+            passed: allPassed,
+            runtime,
+            checks: results,
+            migrationPlan,
+        }, null, 2));
+        return { exitCode: allPassed ? 0 : 1 };
+    }
     console.log("Kibi Environment Diagnostics\n");
-    let allPassed = true;
-    for (const { name, check } of checks) {
-        const result = check();
+    for (const result of results) {
         const status = result.passed ? "✓" : "✗";
-        console.log(`${status} ${name}: ${result.message}`);
-        if (!result.passed) {
-            allPassed = false;
-            if (result.remediation) {
-                console.log(`  → ${result.remediation}`);
-            }
-        }
+        console.log(`${status} ${result.name}: ${result.message}`);
+        if (!result.passed && result.remediation)
+            console.log(`  → ${result.remediation}`);
     }
     console.log();
     if (allPassed) {
@@ -71,6 +97,198 @@ export async function doctorCommand() {
     console.log("Some checks failed. Please address the issues above.");
     return { exitCode: 1 };
 }
+export async function detectExecuteApplyPlanExport(load = () => import("../public/operations/index.js")) {
+    try {
+        const operations = await load();
+        return typeof operations.executeApplyPlan === "function";
+    }
+    catch {
+        return false;
+    }
+}
+export async function packageMigrationActions(runtime) {
+    const actions = [];
+    const versions = ["cliVersion", "coreVersion", "mcpVersion"].filter((key) => runtime[key] === "unresolved" || runtime[key] === "unknown");
+    if (versions.length > 0) {
+        actions.push(migrationAction({
+            id: "package-provenance-unresolved",
+            code: "package_provenance_unresolved",
+            category: "package",
+            safety: "operator",
+            invocation: {
+                kind: "review",
+                instruction: "Install one coordinated Kibi artifact set and rerun kibi doctor; Kibi never selects a package manager or rewrites dependency configuration.",
+            },
+            evidence: { unresolvedVersions: versions },
+            dispositionRequired: true,
+        }));
+    }
+    const cliVersion = typeof runtime.cliVersion === "string" ? runtime.cliVersion : "unknown";
+    const mcpCliRange = typeof runtime.mcpCliRange === "string" ? runtime.mcpCliRange : "unknown";
+    if (cliVersion !== "unknown" &&
+        mcpCliRange !== "unknown" &&
+        !satisfiesCaretRange(cliVersion, mcpCliRange)) {
+        actions.push(migrationAction({
+            id: "package-mcp-cli-range-mismatch",
+            code: "package_dependency_range_mismatch",
+            category: "package",
+            safety: "operator",
+            invocation: {
+                kind: "review",
+                instruction: "Install a newly versioned coordinated Kibi package set whose MCP CLI dependency range includes the installed CLI; project-local overrides are temporary and Kibi never edits dependency configuration.",
+            },
+            evidence: { cliVersion, mcpCliRange },
+            dispositionRequired: true,
+        }));
+    }
+    if (runtime.executeApplyPlanExported === false) {
+        actions.push(migrationAction({
+            id: "package-cli-export-surface-drift",
+            code: "package_export_surface_drift",
+            category: "package",
+            safety: "operator",
+            invocation: {
+                kind: "review",
+                instruction: "Treat same-version artifacts with different exports as a release defect: obtain a newly versioned CLI/MCP pair and do not downgrade receipts or hand-edit package metadata.",
+            },
+            evidence: { executeApplyPlanExported: false },
+            dispositionRequired: true,
+        }));
+    }
+    return actions;
+}
+function satisfiesCaretRange(version, range) {
+    const match = range.trim().match(/^\^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return true;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    const actual = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!actual)
+        return false;
+    const aMajor = Number(actual[1]);
+    const aMinor = Number(actual[2]);
+    const aPatch = Number(actual[3]);
+    return (aMajor === major &&
+        (aMinor > minor || (aMinor === minor && aPatch >= patch)));
+}
+async function runtimeProvenance() {
+    const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    let cli = {};
+    try {
+        cli = JSON.parse(readFileSync(packagePath, "utf8"));
+    }
+    catch {
+        // Keep doctor JSON useful even from an unusual packed entrypoint.
+    }
+    const core = resolveInstalledPackageInfo("kibi-core");
+    const mcp = resolveInstalledPackageInfo("kibi-mcp");
+    const executeApplyPlanExported = await detectExecuteApplyPlanExport();
+    return {
+        cliVersion: typeof cli.version === "string" ? cli.version : "unknown",
+        coreVersion: core.version,
+        mcpVersion: mcp.version,
+        coreRange: cli.dependencies && typeof cli.dependencies === "object"
+            ? (cli.dependencies["kibi-core"] ??
+                "unknown")
+            : "unknown",
+        mcpCliRange: mcp.dependencies?.["kibi-cli"] ?? "unknown",
+        executeApplyPlanExported,
+        entrypoint: process.argv[1] ?? "unknown",
+        packageVersions: process.env.KIBI_PACKAGE_VERSIONS ?? "unknown",
+        locations: {
+            cli: packagePath,
+            cliEntrypoint: process.argv[1] ?? "unknown",
+            core: core.path,
+            coreEntrypoint: core.entrypoint,
+            mcp: mcp.path,
+            mcpEntrypoint: mcp.entrypoint,
+        },
+    };
+}
+function packageInfoFromManifest(manifestPath) {
+    let metadata;
+    try {
+        metadata = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch {
+        // Missing or unreadable manifest is not usable provenance.
+        return undefined;
+    }
+    return {
+        version: typeof metadata.version === "string" ? metadata.version : "unknown",
+        path: manifestPath,
+        entrypoint: typeof metadata.main === "string"
+            ? path.resolve(path.dirname(manifestPath), metadata.main)
+            : "unknown",
+        dependencies: metadata.dependencies && typeof metadata.dependencies === "object"
+            ? metadata.dependencies
+            : undefined,
+    };
+}
+export function nextAncestorDirectory(current) {
+    const parent = path.dirname(current);
+    return parent === current ? undefined : parent;
+}
+export function nearestNamedPackageManifest(startDir, name) {
+    let current = startDir;
+    while (current !== undefined) {
+        const candidate = path.join(current, "package.json");
+        try {
+            const metadata = JSON.parse(readFileSync(candidate, "utf8"));
+            if (metadata.name === name)
+                return candidate;
+        }
+        catch {
+            // Keep walking; an unrelated or absent manifest is not a match.
+        }
+        current = nextAncestorDirectory(current);
+    }
+    return undefined;
+}
+function resolveInstalledPackageInfo(name) {
+    const require = createRequire(import.meta.url);
+    // Preferred: direct manifest subpath. Works when the package exports
+    // "./package.json" or has no restrictive exports map at all.
+    try {
+        const info = packageInfoFromManifest(require.resolve(`${name}/package.json`));
+        if (info)
+            return info;
+    }
+    catch {
+        // Fall through to entrypoint-based resolution below.
+    }
+    // Fallback: a tight exports map may hide ./package.json while the package
+    // itself is installed and runnable. Resolve the entrypoint, then walk up to
+    // the nearest manifest that actually names the target package so doctor
+    // never reports a coordinated install as unresolved.
+    try {
+        const entrypoint = require.resolve(name);
+        const manifestPath = nearestNamedPackageManifest(path.dirname(entrypoint), name);
+        const info = manifestPath
+            ? packageInfoFromManifest(manifestPath)
+            : undefined;
+        if (info)
+            return info;
+    }
+    catch {
+        // The package is genuinely absent from this install graph.
+    }
+    // Last resort: sibling workspace package inside the Kibi monorepo.
+    const local = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", name.replace(/^kibi-/, ""), "package.json");
+    if (existsSync(local)) {
+        const info = packageInfoFromManifest(local);
+        if (info)
+            return info;
+    }
+    return {
+        version: "unresolved",
+        path: "unresolved",
+        entrypoint: "unresolved",
+        dependencies: undefined,
+    };
+}
 function checkSWIProlog() {
     try {
         const output = execSync("swipl --version", { encoding: "utf-8" });
@@ -125,30 +343,50 @@ function checkKbDirectory() {
         message: "Found",
     };
 }
-function checkConfigJson() {
-    const configPath = path.join(process.cwd(), ".kb/config.json");
-    if (!existsSync(configPath)) {
+function checkKbManifest() {
+    const status = readKbManifestStatus(process.cwd());
+    if (status.state === "missing") {
         return {
             passed: false,
             message: "Not found",
             remediation: "Run: kibi init",
         };
     }
-    try {
-        const content = readFileSync(configPath, "utf-8");
-        JSON.parse(content);
+    if (status.state !== "ok") {
         return {
-            passed: true,
-            message: "Valid JSON",
+            passed: false,
+            message: status.state === "invalid" ? "Invalid manifest" : "Future version",
+            remediation: `Repair .kb/manifest.json: ${status.warning}`,
         };
     }
-    catch (error) {
+    return {
+        passed: true,
+        message: `schemaVersion ${status.manifest.schemaVersion}`,
+    };
+}
+function checkLegacyStorage() {
+    const plan = planLegacyStorageMigration(process.cwd());
+    if (plan.legacyConfig === "malformed") {
+        return {
+            passed: false,
+            message: "Legacy .kb/config.json is malformed",
+            remediation: plan.legacyConfigError ??
+                "Repair or remove the legacy .kb/config.json, then run: kibi migrate --yes",
+        };
+    }
+    if (plan.legacyConfig === "present" || plan.moves.length > 0) {
         return {
             passed: false,
-            message: "Invalid JSON",
-            remediation: "Fix .kb/config.json syntax or run: kibi init",
+            message: plan.moves.length > 0
+                ? `${plan.moves.length} legacy knowledge file(s) still outside .kb/`
+                : "Legacy .kb/config.json still present",
+            remediation: "Run: kibi migrate --yes",
         };
     }
+    return {
+        passed: true,
+        message: "Canonical .kb/ layout",
+    };
 }
 function checkGitRepository() {
     try {
@@ -233,8 +471,13 @@ function checkPreCommitHook() {
         const preCommitExecutable = (preCommitStats.mode & 0o111) !== 0;
         // Read hook content to determine whether it's using the new staged check
         const content = readFileSync(preCommitPath, "utf-8");
-        const usesKibi = content.includes("kibi check");
-        const usesStaged = content.includes("kibi check --staged");
+        // Current templates resolve the kibi binary into KIBI_BIN before invoking
+        // it (git hooks do not get node_modules/.bin on PATH); legacy templates
+        // invoked bare `kibi`.
+        const resolvesKibi = content.includes("KIBI_BIN=");
+        const usesKibi = resolvesKibi || content.includes("kibi check");
+        const usesStaged = content.includes('"$KIBI_BIN" check --staged') ||
+            content.includes("kibi check --staged");
         if (!usesKibi) {
             // Fail if hook doesn't invoke kibi at all
             return {
@@ -245,15 +488,24 @@ function checkPreCommitHook() {
         }
         if (preCommitExecutable) {
             if (usesStaged) {
+                if (!resolvesKibi) {
+                    // Functional template that invokes bare `kibi`: it fails whenever
+                    // kibi is installed only as a project dependency.
+                    return {
+                        passed: true,
+                        message: "Installed and executable (legacy template without kibi CLI resolution — run 'kibi init' to regenerate so hooks work with local installs)",
+                        remediation: "Run: kibi init to update git hooks to the latest template",
+                    };
+                }
                 return {
                     passed: true,
-                    message: "Installed and executable (uses 'kibi check --staged')",
+                    message: "Installed and executable (resolves kibi CLI; uses 'kibi check --staged')",
                 };
             }
             // Warn but pass if using legacy kibi check without --staged
             return {
                 passed: true,
-                message: "Installed and executable (uses legacy 'kibi check' — consider running 'kibi init' to update hooks to use '--staged')",
+                message: "Installed and executable (uses legacy 'kibi check' — consider running 'kibi init' to update hooks to use '--staged' with CLI resolution)",
                 remediation: "Run: kibi init to update git hooks to the latest template",
             };
         }
@@ -294,9 +546,11 @@ function checkPostRewriteHook() {
     try {
         const postRewriteStats = statSync(postRewritePath);
         const postRewriteExecutable = (postRewriteStats.mode & 0o111) !== 0;
-        // Read hook content to verify it invokes kibi
+        // Read hook content to verify it invokes kibi. Current templates invoke
+        // the resolved KIBI_BIN; legacy templates invoked bare `kibi sync`.
         const content = readFileSync(postRewritePath, "utf-8");
-        const usesKibi = content.includes("kibi sync");
+        const usesKibi = content.includes('"$KIBI_BIN" sync') || content.includes("kibi sync");
+        const resolvesKibi = content.includes("KIBI_BIN=");
         if (!usesKibi) {
             return {
                 passed: false,
@@ -305,6 +559,13 @@ function checkPostRewriteHook() {
             };
         }
         if (postRewriteExecutable) {
+            if (!resolvesKibi) {
+                return {
+                    passed: true,
+                    message: "Installed and executable (legacy template without kibi CLI resolution — run 'kibi init' to regenerate so hooks work with local installs)",
+                    remediation: "Run: kibi init to update git hooks to the latest template",
+                };
+            }
             return {
                 passed: true,
                 message: "Installed and executable",

package/dist/commands/engine.d.ts

@@ -1,6 +1,18 @@
 export declare function engineStatusCommand(): Promise<void>;
 export declare function engineStopCommand(): Promise<void>;
 export declare function storageStatusCommand(): Promise<void>;
+export interface EngineJanitorOptions {
+    readonly all?: boolean;
+    readonly apply?: boolean;
+    readonly format?: string;
+}
+/**
+ * Classify and (optionally) clean stale engine daemons and branch-store
+ * locks: crashed engines leave ownership journals behind, worktree removals
+ * strand live daemons, dead daemons leave sockets. Report-only by default;
+ `--apply` executes the clean actions.
+ */
+export declare function engineJanitorCommand(options: EngineJanitorOptions): Promise<void>;
 export declare function storageCompactCommand(): Promise<void>;
 export declare function storageExportCommand(options: {
     output: string;

package/dist/commands/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/commands/engine.ts"],"names":[],"mappings":"AAwCA,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4BzD;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAWvD;AAED,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1D;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAU3D;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhB"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/commands/engine.ts"],"names":[],"mappings":"AAkCA,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4BzD;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAWvD;AAED,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1D;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AAEH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAyCf;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAkB3D;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhB"}

package/dist/commands/engine.js

@@ -1,16 +1,12 @@
 import path from "node:path";
 import { EngineClient } from "../engine.js";
-import { resolveActiveBranch } from "../utils/branch-resolver.js";
+import { resolveBranchAttachment } from "../utils/branch-resolver.js";
 function currentBranch(root) {
-    const resolved = resolveActiveBranch(root);
+    const resolved = resolveBranchAttachment(root);
     if ("error" in resolved) {
-        if (resolved.code === "NOT_A_GIT_REPO" ||
-            resolved.code === "GIT_NOT_AVAILABLE") {
-            return "main";
-        }
         throw new Error(resolved.error);
     }
-    return resolved.branch;
+    return resolved.kbBranch;
 }
 function client() {
     const workspaceRoot = path.resolve(process.env.KIBI_WORKSPACE ??
@@ -73,7 +69,54 @@ export async function engineStopCommand() {
 export async function storageStatusCommand() {
     await engineStatusCommand();
 }
+/**
+ * Classify and (optionally) clean stale engine daemons and branch-store
+ * locks: crashed engines leave ownership journals behind, worktree removals
+ * strand live daemons, dead daemons leave sockets. Report-only by default;
+ `--apply` executes the clean actions.
+ */
+// implements REQ-core-journaled-engine-persistence
+export async function engineJanitorCommand(options) {
+    const { runtimeDirectory } = await import("../engine.js");
+    const { runJanitor } = await import("../prolog/janitor.js");
+    const findings = runJanitor({
+        workspaceRoot: workspaceRoot(),
+        runtimeDirectory: runtimeDirectory(),
+        all: options.all === true,
+        apply: options.apply === true,
+    });
+    const cleanable = findings.filter((f) => f.action !== "keep").length;
+    const cleaned = options.apply === true ? cleanable : 0;
+    if (options.format === "json") {
+        console.log(JSON.stringify({ findings, cleaned, cleanable, total: findings.length }));
+        return;
+    }
+    if (findings.length === 0) {
+        console.log("No engine or lock artifacts found.");
+        return;
+    }
+    for (const finding of findings) {
+        const holder = "pid" in finding && finding.pid !== undefined ? ` pid=${finding.pid}` : "";
+        const workspace = finding.kind === "store-lock" && finding.workspaceRoot !== undefined
+            ? ` workspace=${finding.workspaceRoot}`
+            : "";
+        const scope = finding.kind === "store-lock"
+            ? `store ${finding.storePath}`
+            : `socket ${finding.socketPath}`;
+        console.log(`[${finding.action}] ${scope}${holder}${workspace} holder=${finding.holderState}`);
+    }
+    console.log(options.apply === true
+        ? `${findings.length} finding(s), ${cleaned} cleaned`
+        : `${findings.length} finding(s), ${cleanable} cleanable (report only; re-run with --apply)`);
+}
 export async function storageCompactCommand() {
+    const root = workspaceRoot();
+    const attachment = resolveBranchAttachment(root);
+    if ("error" in attachment)
+        throw new Error(attachment.error);
+    if (attachment.migrationRequired) {
+        throw new Error(`Storage compaction blocked by legacy attachment (${attachment.gitBranch} -> ${attachment.kbBranch}); migrate the branch KB first.`);
+    }
     const engine = client();
     try {
         const result = await engine.compact();

package/dist/commands/gc.d.ts

@@ -1,6 +1,9 @@
-export declare function gcCommand(options: {
+type GcOptions = {
     dryRun?: boolean;
     force?: boolean;
-}): Promise<void>;
+    purge?: boolean;
+    retentionDays?: number;
+};
+export declare function gcCommand(options?: GcOptions): Promise<void>;
 export default gcCommand;
 //# sourceMappingURL=gc.d.ts.map

package/dist/commands/gc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../src/commands/gc.ts"],"names":[],"mappings":"AAsBA,wBAAsB,SAAS,CAAC,OAAO,EAAE;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,iBAiFA;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../src/commands/gc.ts"],"names":[],"mappings":"AAWA,KAAK,SAAS,GAAG;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA0GF,wBAAsB,SAAS,CAAC,OAAO,GAAE,SAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAgFtE;AAED,eAAe,SAAS,CAAC"}