knodin 0.13.0 → 0.14.0

package/dist/bin/cli.js

@@ -31,6 +31,7 @@ import { exportContext, grepPackedArtifact, readPackedArtifact } from "../src/co
 import { clearDiagnostics, collectDiagnostics, diagnosticsStatus, disableDiagnostics, enableDiagnostics, inspectDiagnosticsBundle, persistDiagnosticsPreview, recordDiagnosticFailure, } from "../src/diagnostics.js";
 import { getDocSection, listDocTopics } from "../src/docs-sections.js";
 import { diagnoseInstallation } from "../src/doctor.js";
+import { sweepAbandonedCandidates } from "../src/engine/candidate-database.js";
 import { createEngine, describeThrown, KNODIN_SCHEMA_VERSION, REPO_WIDE_QUERY_PATTERNS, } from "../src/engine/index.js";
 import { runSeal } from "../src/engine/seal-command.js";
 import { runSealedQuery } from "../src/engine/sealed-query.js";
@@ -60,6 +61,8 @@ import { detectRepositorySignals, discoverRepositories, formatRepositoryHuman, i
 import { applyResponseBudget } from "../src/response-budget.js";
 import { appendSessionEvent, clearSessionTelemetry, disableSessionTelemetry, enableSessionTelemetry, readSessionEvents, sessionTelemetryStatus, } from "../src/session-telemetry.js";
 import { inspectKnodinSkills, installKnodinSkills, KNODIN_SKILLS, removeKnodinSkills, } from "../src/skill-management.js";
+import { inventoryStorage } from "../src/storage-inventory.js";
+import { configureStoragePolicy, postOperationStorageMaintenance, resolveStoragePolicy, } from "../src/storage-management.js";
 import { configuredRepositoryInitMemoryLimitBytes, enrichSystemRelationships, incorporateSystemQueryEvidence, indexModeForPath, loadSystemConfiguration, queryConfiguredSystem, systemMembershipsForPath, validateSystemHealth, } from "../src/system-config.js";
 import { applySystemPlan, planSystemImport, planSystemLink, planSystemRelate, planSystemUnlink, planSystemUnrelate, } from "../src/system-management.js";
 import { coordinationStatus } from "../src/update-coordination.js";
@@ -154,7 +157,17 @@ function formatRepairHuman(result) {
         result.after.missing.files.length + result.after.missing.records.length;
     const firstIssue = result.after.missing.files[0] ?? result.after.missing.records[0];
     const detail = firstIssue ? ` First issue: ${firstIssue}.` : "";
-    return `Repair finished with ${outstanding.toLocaleString()} remaining issue(s).${detail} Run \`knodin status --deep\` for details.\n`;
+    // Say when nothing moved: on nova the same 111-issue graph went through
+    // status -> repair -> status unchanged, and "Repair finished with 141
+    // remaining issue(s)" read as progress. Then print the audit's own remedy
+    // rather than a generic pointer; for a legacy epoch-less graph the audit
+    // already knows repair cannot fix it and index --clean can (KNODIN-50).
+    const unchanged = result.repaired.length === 0 &&
+        result.before.missing.files.length === result.after.missing.files.length &&
+        result.before.missing.records.length === result.after.missing.records.length;
+    const progress = unchanged ? "Repair made no changes; " : "Repair finished with ";
+    const remedy = result.after.repairSteps[0] ?? "Run `knodin status --deep` for details.";
+    return `${progress}${outstanding.toLocaleString()} remaining issue(s).${detail} ${remedy}\n`;
 }
 /**
  * The semantic gap, stated rather than left to be discovered.
@@ -195,7 +208,8 @@ function formatIndexVerificationError(result) {
     const condition = result.verification.issueCount > 0
         ? `${result.verification.issueCount.toLocaleString()} graph issue(s) remain`
         : `graph verification reported status "${result.verification.status}"`;
-    return `knodin index: requested work completed, but ${condition}.${detail} Run \`knodin repair\`.\n`;
+    const remedy = result.verification.repairSteps[0] ?? "Run `knodin repair`.";
+    return `knodin index: requested work completed, but ${condition}.${detail} ${remedy}\n`;
 }
 /**
  * The hooks/lifecycle line of `status`.
@@ -498,7 +512,14 @@ function formatStatusHuman(result) {
     const lifecycleOnly = result.lifecycle?.status === "degraded" &&
         (result.coverage.countsUnknown || result.missing.files.length === 0) &&
         result.missing.records.every((record) => result.lifecycle?.issues.includes(record));
-    const repairCommand = worktreeStep ?? (lifecycleOnly ? "Run `knodin repair --lifecycle`." : "Run `knodin repair`.");
+    // Otherwise the engine's first step is authoritative too: it distinguishes
+    // "rebuild damaged rows" from "this graph predates the content-proof epoch
+    // and only index --clean can certify it" — a case where sending the user to
+    // repair costs two failing round trips (KNODIN-50).
+    const repairCommand = worktreeStep ??
+        (lifecycleOnly
+            ? "Run `knodin repair --lifecycle`."
+            : (result.repairSteps?.[0] ?? "Run `knodin repair`."));
     return `Graph or lifecycle needs repair: ${outstanding} issue(s) found (${coverage}).${detail} ${repairCommand}\n${lifecycleLine}${integrationLine}`;
 }
 function humanLabel(key) {
@@ -1289,6 +1310,8 @@ async function main() {
         const depth = invocation.options.depth;
         const retentionDays = invocation.options.retentionDays;
         const keepNewest = invocation.options.keepNewest;
+        const maxCount = invocation.options.maxCount;
+        const maxAllocatedBytes = invocation.options.maxBytes;
         let output;
         if (action === "list")
             output = listBackups(defaultRoots(), { depth });
@@ -1297,16 +1320,70 @@ async function main() {
                 depth,
                 retentionDays,
                 keepNewest,
+                maxCount,
+                maxAllocatedBytes,
                 apply: invocation.options.apply === true,
             });
         }
+        else if (action === "policy") {
+            output = defaultRoots().map((repository) => {
+                if (retentionAction === "status")
+                    return {
+                        repository,
+                        policy: resolveStoragePolicy(repository),
+                        inventory: inventoryStorage(repository),
+                    };
+                if (retentionAction !== "preview" && retentionAction !== "apply")
+                    throw new Error("knodin backups policy requires preview, apply, or status");
+                const changes = {
+                    apply: retentionAction === "apply",
+                };
+                if (maxCount !== undefined)
+                    changes.maxCount = maxCount;
+                if (maxAllocatedBytes !== undefined)
+                    changes.maxAllocatedBytes = maxAllocatedBytes;
+                if (invocation.options.reserveBytes !== undefined)
+                    changes.minFreeBytes = invocation.options.reserveBytes;
+                const mode = invocation.options.mode;
+                if (mode !== undefined) {
+                    changes.enabled = mode !== "disabled";
+                    changes.dryRun = mode === "preview";
+                }
+                const configured = configureStoragePolicy(repository, changes);
+                const maintenance = retentionAction === "apply" ? postOperationStorageMaintenance(repository) : null;
+                const candidateWarnings = [];
+                const candidatesRemoved = maintenance?.policy?.enabled && !maintenance.policy.dryRun
+                    ? sweepAbandonedCandidates(repository, {
+                        onDiagnostic: (warning) => {
+                            if (candidateWarnings.length < 8)
+                                candidateWarnings.push(warning.reason.slice(0, 512));
+                        },
+                    })
+                    : 0;
+                return {
+                    repository,
+                    ...configured,
+                    inventory: inventoryStorage(repository),
+                    cleanup: retentionAction === "apply"
+                        ? { ...maintenance, candidatesRemoved, candidateWarnings }
+                        : pruneBackups([repository], {
+                            ...configured.policy,
+                            depth: 0,
+                            includeRegistry: false,
+                            apply: false,
+                        }),
+                };
+            });
+        }
         else if (action === "retention" && retentionAction === "install") {
             output = installBackupRetention(roots, {
                 depth,
                 retentionDays,
                 keepNewest,
+                maxCount,
+                maxAllocatedBytes,
                 schedule: invocation.options.schedule,
-                dryRun: invocation.options.dryRun === true,
+                dryRun: invocation.options.dryRun,
                 launcher: runtimeCommand,
             });
         }
@@ -1389,10 +1466,19 @@ async function main() {
     const repo = resolved.repo;
     if (cmd !== "doctor") {
         try {
-            maybeRunOpportunisticRetention(repo);
+            const maintenance = maybeRunOpportunisticRetention(repo);
+            const issues = "issues" in maintenance
+                ? maintenance.issues
+                : "result" in maintenance && maintenance.result
+                    ? maintenance.result.skipped.map((entry) => entry.reason)
+                    : [];
+            if (issues?.length)
+                process.stderr.write(`knodin storage: ${issues.slice(0, 8).join("; ").slice(0, 4096)}\n`);
         }
-        catch {
-            // Best-effort cleanup must never make an ordinary command fail.
+        catch (error) {
+            // Cleanup remains nonfatal, but failures are not hidden or reported as
+            // reclaimed storage. Keep stdout/JSON framing untouched.
+            process.stderr.write(`knodin storage: ${String(error).slice(0, 512)}\n`);
         }
     }
     if (cmd === "agent-event" && !fs.existsSync(resolveDbPath(repo)))
@@ -2168,10 +2254,34 @@ async function main() {
                     throw new Error("knodin hook-refresh: invalid lifecycle event");
                 }
                 const shared = await opportunisticSharedRestore();
+                // Keep the audit that the scoped index already ran. Before this the
+                // hook reported only the paths it wrote and exited 0, so a graph the
+                // audit refused to certify — nova's 0.13.0 graph after the 0.13.1
+                // upgrade, 33 commits behind with lifecycle "healthy" — looked like a
+                // success on every commit (KNODIN-49).
+                let verification;
                 const indexed = shared?.restored
                     ? []
-                    : await refreshFromGitEvent(repo, event, (target, files) => engine.index(target, files));
-                result = { indexed, ...(shared ? { sharedRestore: shared } : {}) };
+                    : await refreshFromGitEvent(repo, event, async (target, files) => {
+                        const indexResult = await engine.index(target, files);
+                        verification = indexResult.verification;
+                        return indexResult;
+                    });
+                if (verification?.status === "repair-needed") {
+                    const firstIssue = verification.missing.records[0] ?? verification.missing.files[0] ?? "unknown issue";
+                    const remedy = verification.repairSteps[0] ?? "Run `knodin repair`.";
+                    throw new Error(`knodin hook-refresh: indexed ${indexed.length} path(s) but the graph audit refused to certify the result (${verification.issueCount.toLocaleString()} issue(s); first: ${firstIssue}). ${remedy}`);
+                }
+                // `at` and `event` make each indexer.log record self-describing; the
+                // background script supplies the queued event's sequence through
+                // KNODIN_HOOK_EVENT_SEQUENCE so the line can be tied to its Git event.
+                result = {
+                    at: new Date().toISOString(),
+                    event: { ...event, sequence: process.env.KNODIN_HOOK_EVENT_SEQUENCE ?? null },
+                    indexed,
+                    ...(verification ? { verification } : {}),
+                    ...(shared ? { sharedRestore: shared } : {}),
+                };
             }
             finally {
                 lifecycleLease.release();
@@ -2525,6 +2635,7 @@ async function main() {
                     ? {
                         mode: "source",
                         identity: explained.identity,
+                        platformEntry: explained.platformEntry,
                         symbol: explained.symbol,
                         source: explained.source,
                         staleness: explained.staleness,