kibi-cli 1.0.1 → 2.1.0

package/dist/public/operations/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/catalog.js

@@ -5,11 +5,11 @@ import { querySpec, searchSpec, statusSpec } from "./specs/discovery.js";
 import { modelRequirementSpec, suggestPredicatesSpec, } from "./specs/modeling.js";
 import { deleteSpec, upsertSpec, validateUpsertSpec, } from "./specs/mutation.js";
 import { applyPlanSpec, compileIntentSpec } from "./specs/planning.js";
+import { ingestProofSpec } from "./specs/proof.js";
 import { coverageSpec, findGapsSpec, graphSpec } from "./specs/reporting.js";
 import { semanticAdvisorSpec } from "./specs/semantic.js";
 import { skillsListSpec, skillsLoadSpec, skillsReadSpec, } from "./specs/skills.js";
 import { sparqlRemoteSpec } from "./specs/sparql.js";
-import { ingestVerificationSpec } from "./specs/verification.js";
 export const OPERATION_CATALOG = [
     skillsListSpec,
     skillsLoadSpec,
@@ -31,7 +31,7 @@ export const OPERATION_CATALOG = [
     sparqlRemoteSpec,
     compileIntentSpec,
     applyPlanSpec,
-    ingestVerificationSpec,
+    ingestProofSpec,
 ];
 function envelopeSchema(spec, resultVersion) {
     const data = OPERATION_DATA_SCHEMAS[spec.name];
@@ -151,13 +151,15 @@ export function withContractDefaults(spec) {
 }
 const SPECS_BY_NAME = new Map(OPERATION_CATALOG.map((spec) => [spec.name, withContractDefaults(spec)]));
 // implements REQ-kibi-operation-interface-parity
-export function getSpec(name) {
-    const spec = SPECS_BY_NAME.get(name);
+export function requireKnownSpec(spec, name) {
     if (!spec) {
         throw new RangeError(`Unknown Kibi operation: ${name}`);
     }
     return spec;
 }
+export function getSpec(name) {
+    return requireKnownSpec(SPECS_BY_NAME.get(name), name);
+}
 // implements REQ-kibi-operation-interface-parity
 export function listSpecs() {
     return OPERATION_CATALOG.map(withContractDefaults);

package/dist/public/operations/check-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAqDF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAuJxC"}
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAqDF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAmJxC"}

package/dist/public/operations/check-executor.js

@@ -52,7 +52,7 @@ export async function executeCheck(args, context, options = {}) {
         const workspaceRoot = args.workspaceRoot ?? context.workspaceRoot;
         const prolog = requireProlog(context);
         const snapshotEvidence = await readWorkspaceSnapshot(context);
-        const verificationSnapshot = snapshotEvidence.available
+        const proofSnapshot = snapshotEvidence.available
             ? snapshotEvidence.snapshot.hash
             : undefined;
         const checkedAt = context.clock().toISOString();
@@ -60,7 +60,7 @@ export async function executeCheck(args, context, options = {}) {
         // version. `args.rules` is an invocation-time diagnostic selector only.
         const rulesAllowlist = resolveCheckRules(args);
         const hasExplicitRules = args.rules !== undefined;
-        const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
+        const impactResult = await analyzeKbCheckImpact(workspaceRoot, args);
         const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
         const maxDiagnosticsOption = args.maxDiagnostics !== undefined
             ? { maxDiagnostics: args.maxDiagnostics }
@@ -74,9 +74,7 @@ export async function executeCheck(args, context, options = {}) {
                     : await collectFullKbQualityDiagnostics({
                         prolog,
                         workspaceRoot,
-                        ...(verificationSnapshot !== undefined
-                            ? { verificationSnapshot }
-                            : {}),
+                        ...(proofSnapshot !== undefined ? { proofSnapshot } : {}),
                         checkedAt,
                         now: context.clock(),
                         ...maxDiagnosticsOption,
@@ -134,9 +132,7 @@ export async function executeCheck(args, context, options = {}) {
                     prolog,
                     hardViolationEntityIds: new Set(violations.map((v) => v.entityId)),
                     workspaceRoot,
-                    ...(verificationSnapshot !== undefined
-                        ? { verificationSnapshot }
-                        : {}),
+                    ...(proofSnapshot !== undefined ? { proofSnapshot } : {}),
                     checkedAt,
                     now: context.clock(),
                     ...maxDiagnosticsOption,

package/dist/public/operations/check-helpers.d.ts

@@ -30,6 +30,6 @@ export declare function resolveCheckRules(args: Pick<CheckInput, "rules">): Set<
  */
 export declare function readLegacyChecksHint(workspaceRoot: string): Promise<string | null>;
 export declare function hasImpactOptions(args: CheckInput): boolean;
-export declare function analyzeKbCheckImpact(workspaceRoot: string, args: CheckInput): ChangedFileImpactResult | undefined;
+export declare function analyzeKbCheckImpact(workspaceRoot: string, args: CheckInput): Promise<ChangedFileImpactResult | undefined>;
 export declare function qualityDiagnosticsFromImpact(impactResult: ChangedFileImpactResult | undefined): readonly QualityDiagnostic[];
 //# sourceMappingURL=check-helpers.d.ts.map

package/dist/public/operations/check-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-helpers.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-helpers.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,UAAU,EACV,KAAK,SAAS,EACd,iBAAiB,EAGlB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AAEzC;;;;;;;GAOG;AAEH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,GAAG;IACtE,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;CACzC,CA0BA;AAQD,wBAAgB,gCAAgC,IAAI,SAAS,EAAE,CAU9D;AAED;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAC9B,GAAG,CAAC,MAAM,CAAC,CAQb;AAED;;;;GAIG;AAEH,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQxB;AAGD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAO1D;AAGD,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,GACf,uBAAuB,GAAG,SAAS,CAoBrC;AAGD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,uBAAuB,GAAG,SAAS,GAChD,SAAS,iBAAiB,EAAE,CAK9B"}
+{"version":3,"file":"check-helpers.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-helpers.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,UAAU,EACV,KAAK,SAAS,EACd,iBAAiB,EAGlB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AAEzC;;;;;;;GAOG;AAEH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,GAAG;IACtE,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;CACzC,CA0BA;AAQD,wBAAgB,gCAAgC,IAAI,SAAS,EAAE,CAU9D;AAED;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAC9B,GAAG,CAAC,MAAM,CAAC,CAQb;AAED;;;;GAIG;AAEH,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQxB;AAGD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAO1D;AAGD,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAoB9C;AAGD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,uBAAuB,GAAG,SAAS,GAChD,SAAS,iBAAiB,EAAE,CAK9B"}

package/dist/public/operations/check-helpers.js

@@ -114,7 +114,7 @@ export function hasImpactOptions(args) {
         (args.sourceFiles !== undefined && args.sourceFiles.length > 0));
 }
 // implements REQ-mcp-tool-check
-export function analyzeKbCheckImpact(workspaceRoot, args) {
+export async function analyzeKbCheckImpact(workspaceRoot, args) {
     if (!hasImpactOptions(args)) {
         return undefined;
     }

package/dist/public/operations/contracts.d.ts

@@ -1,11 +1,18 @@
 import type { OperationEffect, OperationEffectDeclaration, OperationName } from "./types.js";
 /** A JSON Schema object emitted in the public operation catalog. */
 export type OperationJsonSchema = Readonly<Record<string, unknown>>;
+/** Preserve JSON Schema's nullable scalar/object representation in every
+ * generated consumer contract.  Using a `type` union keeps the catalog
+ * readable and lets the MCP bridge round-trip the same wire schema. */
+export declare function nullableJsonSchema(schema: OperationJsonSchema): OperationJsonSchema;
 /**
  * The data contract is deliberately maintained separately from the operation
  * implementations.  Every catalog entry therefore has a concrete payload
  * shape, while nested domain records can still evolve independently.
  */
 export declare const OPERATION_DATA_SCHEMAS: Readonly<Record<OperationName, OperationJsonSchema>>;
+export declare function assertUniqueEffectKinds(operation: string, declarations: readonly {
+    readonly kind: string;
+}[], expectedSize: number): void;
 export declare function declaredEffects(operation: OperationName, effects: readonly OperationEffect[]): readonly OperationEffectDeclaration[];
 //# sourceMappingURL=contracts.d.ts.map

package/dist/public/operations/contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/public/operations/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAgDpE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAuO3C,CAAC;AAgDF,wBAAgB,eAAe,CAC7B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,0BAA0B,EAAE,CAsBvC"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/public/operations/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAwDpE;;uEAEuE;AACvE,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAMrB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAsP3C,CAAC;AAgDF,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAClD,YAAY,EAAE,MAAM,GACnB,IAAI,CAIN;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,0BAA0B,EAAE,CAoBvC"}

package/dist/public/operations/contracts.js

@@ -19,6 +19,21 @@ function objectData(properties, required = []) {
         properties,
     };
 }
+/**
+ * kibi.job.v1 receipt returned by async-mode operations (kb_check with
+ * `async: true`) instead of the synchronous payload. Agents poll
+ * kb_job_status with the jobId. Declared as a union member of the operation
+ * data contract so hosts validating tool output against the declared schema
+ * accept the receipt without weakening the synchronous payload contract.
+ */
+const jobReceiptData = objectData({
+    kibiProtocol: { const: 1 },
+    jobVersion: { const: "kibi.job.v1" },
+    jobId: { type: "string" },
+    tool: { type: "string" },
+    status: { type: "string" },
+    pollWith: { const: "kb_job_status" },
+}, ["kibiProtocol", "jobVersion", "jobId", "tool", "status", "pollWith"]);
 const stringValue = { type: "string" };
 const integerValue = { type: "integer" };
 const numberValue = { type: "number" };
@@ -30,7 +45,7 @@ const stringArray = {
 /** Preserve JSON Schema's nullable scalar/object representation in every
  * generated consumer contract.  Using a `type` union keeps the catalog
  * readable and lets the MCP bridge round-trip the same wire schema. */
-function nullable(schema) {
+export function nullableJsonSchema(schema) {
     const type = schema.type;
     if (typeof type === "string") {
         return { ...schema, type: [type, "null"] };
@@ -65,19 +80,23 @@ export const OPERATION_DATA_SCHEMAS = {
         syncState: stringValue,
         kbPath: stringValue,
         lastSyncSource: stringValue,
-        verificationSnapshot: stringValue,
-        verificationSnapshotAvailable: booleanValue,
-        verificationSnapshotDirty: booleanValue,
-        verificationSnapshotFileCount: integerValue,
-        verificationSnapshotVersion: stringValue,
-        verificationSnapshotError: stringValue,
+        attachedPath: stringValue,
+        attachedGeneration: stringValue,
+        attachedDev: integerValue,
+        attachedIno: integerValue,
+        proofSnapshot: stringValue,
+        proofSnapshotAvailable: booleanValue,
+        proofSnapshotDirty: booleanValue,
+        proofSnapshotFileCount: integerValue,
+        proofSnapshotVersion: stringValue,
+        proofSnapshotError: stringValue,
         staleReasons: recordArray,
         staleReasonCount: integerValue,
         staleReasonsTruncated: booleanValue,
         branchAttachment: recordValue,
-        verificationSnapshotChanges: recordArray,
-        verificationSnapshotChangeCount: integerValue,
-        verificationSnapshotChangesTruncated: booleanValue,
+        proofSnapshotChanges: recordArray,
+        proofSnapshotChangeCount: integerValue,
+        proofSnapshotChangesTruncated: booleanValue,
         branchStore: recordValue,
         engineStatus: recordValue,
         schemaStatus: recordValue,
@@ -108,6 +127,7 @@ export const OPERATION_DATA_SCHEMAS = {
     kb_semantic_advisor: objectData({
         receipt: recordValue,
         warnings: stringArray,
+        capabilityPlugins: recordValue,
     }),
     kb_model_requirement: objectData({
         statement: stringValue,
@@ -180,8 +200,8 @@ export const OPERATION_DATA_SCHEMAS = {
         valid: booleanValue,
         errors: valueArray,
         warnings: valueArray,
-        semanticAdvisor: nullable(recordValue),
-        normalizedPreview: nullable(recordValue),
+        semanticAdvisor: nullableJsonSchema(recordValue),
+        normalizedPreview: nullableJsonSchema(recordValue),
     }),
     kb_upsert: objectData({
         created: integerValue,
@@ -210,18 +230,24 @@ export const OPERATION_DATA_SCHEMAS = {
         effectFailures: recordArray,
         nextActions: recordArray,
     }),
-    kb_check: objectData({
-        violations: valueArray,
-        count: integerValue,
-        diagnostics: recordArray,
-        qualityDiagnostics: recordArray,
-        impactDiagnostics: recordArray,
-        sourceFiles: stringArray,
-        extractedSymbols: recordArray,
-        linkedEntities: recordArray,
-        nextActions: valueArray,
-        migrationPlan: recordValue,
-    }),
+    kb_check: {
+        description: "Synchronous check payload, or a kibi.job.v1 receipt when async:true detached the check into a background job (poll kb_job_status with the jobId).",
+        anyOf: [
+            objectData({
+                violations: valueArray,
+                count: integerValue,
+                diagnostics: recordArray,
+                qualityDiagnostics: recordArray,
+                impactDiagnostics: recordArray,
+                sourceFiles: stringArray,
+                extractedSymbols: recordArray,
+                linkedEntities: recordArray,
+                nextActions: valueArray,
+                migrationPlan: recordValue,
+            }),
+            jobReceiptData,
+        ],
+    },
     kb_compile_intent: objectData({
         version: stringValue,
         planHash: stringValue,
@@ -235,6 +261,7 @@ export const OPERATION_DATA_SCHEMAS = {
         steps: valueArray,
         sourceWrites: recordArray,
         diagnostics: stringArray,
+        capabilityPlugins: recordValue,
     }),
     kb_apply_plan: objectData({
         version: stringValue,
@@ -256,12 +283,14 @@ export const OPERATION_DATA_SCHEMAS = {
         effectFailures: recordArray,
         nextActions: recordArray,
     }),
-    kb_ingest_verification: objectData({
-        receipt: recordValue,
-        testId: stringValue,
-        proofOutcome: stringValue,
-        receiptCount: integerValue,
-        upsert: recordValue,
+    kb_ingest_proof: objectData({
+        artifactDigest: stringValue,
+        environmentHash: stringValue,
+        integration: stringValue,
+        passed: integerValue,
+        failed: integerValue,
+        unchanged: integerValue,
+        results: recordArray,
         status: stringValue,
         effectFailures: recordArray,
         nextActions: recordArray,
@@ -297,10 +326,15 @@ const EFFECT_OVERRIDES = {
         "kb-write": { destructive: true, retrySafety: "unsafe" },
         "workspace-write": { destructive: true, retrySafety: "unsafe" },
     },
-    kb_ingest_verification: {
+    kb_ingest_proof: {
         "kb-write": { destructive: true, retrySafety: "unsafe" },
     },
 };
+export function assertUniqueEffectKinds(operation, declarations, expectedSize) {
+    if (new Set(declarations.map(({ kind }) => kind)).size !== expectedSize) {
+        throw new Error(`Duplicate effect contract for ${operation}`);
+    }
+}
 export function declaredEffects(operation, effects) {
     const overrides = EFFECT_OVERRIDES[operation];
     if (!overrides)
@@ -318,8 +352,6 @@ export function declaredEffects(operation, effects) {
             openWorld: override.openWorld === true,
         };
     });
-    if (new Set(declarations.map(({ kind }) => kind)).size !== expected.size) {
-        throw new Error(`Duplicate effect contract for ${operation}`);
-    }
+    assertUniqueEffectKinds(operation, declarations, expected.size);
     return declarations;
 }

package/dist/public/operations/discovery-entities.d.ts

@@ -4,11 +4,26 @@ export type EntityQueryInput = {
     readonly id?: string;
     readonly tags?: readonly string[];
     readonly sourceFile?: string;
+    /** Page size for index-backed queries; bounds each query's output. */
+    readonly limit?: number;
+    readonly offset?: number;
 };
 export declare const VALID_ENTITY_TYPES: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
 export declare function validateEntityType(type?: string): void;
 export declare function buildEntityGoal(input: EntityQueryInput): string;
 export declare function loadEntities(prolog: Pick<PrologPort, "query">, input: EntityQueryInput): Promise<Record<string, unknown>[]>;
 export declare function paginateResults<T>(results: readonly T[], limit?: number, offset?: number): T[];
+/**
+ * Page size for index-backed search candidate fetches. Each page is one
+ * Prolog query, so a fixed page size substantially bounds each response and
+ * fixes the observed large-KB output overflow; it is a practical bound, not
+ * a byte-size guarantee for arbitrarily large individual entity payloads.
+ */
+export declare const SEARCH_CANDIDATE_PAGE_SIZE = 500;
+export declare function loadSearchCandidates(prolog: Pick<PrologPort, "searchEntities">, input: {
+    readonly query: string;
+    readonly type?: string;
+    readonly maxCandidates?: number;
+}, signal?: AbortSignal): Promise<Record<string, unknown>[]>;
 export declare function dedupeEntities(entities: readonly Record<string, unknown>[]): Record<string, unknown>[];
 //# sourceMappingURL=discovery-entities.d.ts.map

package/dist/public/operations/discovery-entities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-entities.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-entities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,gFASrB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAMtD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAgC/D;AAGD,wBAAsB,YAAY,CAChC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,KAAK,SAAM,EACX,MAAM,SAAI,GACT,CAAC,EAAE,CAEL;AAGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}
+{"version":3,"file":"discovery-entities.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-entities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,gFASrB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAMtD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAoC/D;AAGD,wBAAsB,YAAY,CAChC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,KAAK,SAAM,EACX,MAAM,SAAI,GACT,CAAC,EAAE,CAEL;AAED;;;;;GAKG;AAEH,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAG9C,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,EAC1C,KAAK,EAAE;IACL,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC,EACD,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}

package/dist/public/operations/discovery-entities.js

@@ -45,6 +45,10 @@ export function buildEntityGoal(input) {
     }
     if (type) {
         const safeType = escapeAtomContent(type);
+        if (input.limit !== undefined) {
+            const offset = input.offset ?? 0;
+            return `kb_query_entities('${safeType}', none, [], none, ${input.limit}, ${offset}, Results, Count)`;
+        }
         return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
     }
     return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
@@ -79,6 +83,40 @@ export async function loadEntities(prolog, input) {
 export function paginateResults(results, limit = 100, offset = 0) {
     return results.slice(offset, offset + limit);
 }
+/**
+ * Page size for index-backed search candidate fetches. Each page is one
+ * Prolog query, so a fixed page size substantially bounds each response and
+ * fixes the observed large-KB output overflow; it is a practical bound, not
+ * a byte-size guarantee for arbitrarily large individual entity payloads.
+ */
+// implements REQ-kibi-operation-interface-parity, REQ-mcp-search-discovery
+export const SEARCH_CANDIDATE_PAGE_SIZE = 500;
+// implements REQ-kibi-operation-interface-parity, REQ-mcp-search-discovery
+export async function loadSearchCandidates(prolog, input, signal) {
+    const maxCandidates = input.maxCandidates ?? Number.POSITIVE_INFINITY;
+    const candidates = [];
+    let offset = 0;
+    let total = Number.POSITIVE_INFINITY;
+    while (offset < total && candidates.length < maxCandidates) {
+        // Call through the port property, never via a detached local: EngineClient
+        // searchEntities depends on `this` (this.command), and the PrologPort
+        // contract does not promise a pre-bound method.
+        const page = await prolog.searchEntities?.({
+            query: input.query,
+            ...(input.type !== undefined ? { type: input.type } : {}),
+            limit: SEARCH_CANDIDATE_PAGE_SIZE,
+            offset,
+        }, signal);
+        if (!page || page.entities.length === 0)
+            break;
+        candidates.push(...page.entities);
+        total = page.count;
+        offset += page.entities.length;
+    }
+    return Number.isFinite(maxCandidates)
+        ? candidates.slice(0, maxCandidates)
+        : candidates;
+}
 // implements REQ-002
 export function dedupeEntities(entities) {
     const seen = new Set();

package/dist/public/operations/discovery-executors.d.ts

@@ -40,12 +40,12 @@ export type StatusPayload = {
     readonly syncState: string;
     readonly kbPath?: string;
     readonly lastSyncSource?: string;
-    readonly verificationSnapshot?: string;
-    readonly verificationSnapshotAvailable?: boolean;
-    readonly verificationSnapshotDirty?: boolean;
-    readonly verificationSnapshotFileCount?: number;
-    readonly verificationSnapshotVersion?: string;
-    readonly verificationSnapshotError?: string;
+    readonly proofSnapshot?: string;
+    readonly proofSnapshotAvailable?: boolean;
+    readonly proofSnapshotDirty?: boolean;
+    readonly proofSnapshotFileCount?: number;
+    readonly proofSnapshotVersion?: string;
+    readonly proofSnapshotError?: string;
     readonly staleReasons?: readonly Record<string, unknown>[];
     readonly staleReasonCount?: number;
     readonly staleReasonsTruncated?: boolean;
@@ -55,9 +55,9 @@ export type StatusPayload = {
         readonly kind: "exact" | "explicit_override" | "legacy_compat";
         readonly migrationRequired: boolean;
     };
-    readonly verificationSnapshotChanges?: readonly Record<string, unknown>[];
-    readonly verificationSnapshotChangeCount?: number;
-    readonly verificationSnapshotChangesTruncated?: boolean;
+    readonly proofSnapshotChanges?: readonly Record<string, unknown>[];
+    readonly proofSnapshotChangeCount?: number;
+    readonly proofSnapshotChangesTruncated?: boolean;
     readonly branchStore?: BranchStoreInspection;
     readonly engineStatus?: {
         readonly state: "healthy" | "unavailable";

package/dist/public/operations/discovery-executors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-executors.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-executors.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAGpB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9C,QAAQ,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IAC7C,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,iBAAiB,CAAC,EAAE,CAAC;IAC/D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,OAAO,CAAC;IACjD,QAAQ,CAAC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAC7C,QAAQ,CAAC,6BAA6B,CAAC,EAAE,MAAM,CAAC;IAChD,QAAQ,CAAC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IAC5C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC3D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,GAAG,eAAe,CAAC;QAC/D,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;KACrC,CAAC;IACF,QAAQ,CAAC,2BAA2B,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1E,QAAQ,CAAC,+BAA+B,CAAC,EAAE,MAAM,CAAC;IAClD,QAAQ,CAAC,oCAAoC,CAAC,EAAE,OAAO,CAAC;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE;QACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAAC;QAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;KACpC,CAAC;IACF,QAAQ,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC;IAC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;QACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;QAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACzD,CAAC;CACH,CAAC;AAqBF,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA6DxC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CA+FzC;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CA+NzC"}
+{"version":3,"file":"discovery-executors.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-executors.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/discovery-executors.js

@@ -3,8 +3,8 @@ import { executeIntentSearch, validateIntentSearchInput, } from "../../intent-se
 import { classifyActivation } from "../../operations/bootstrap/activation.js";
 import { rankEntities } from "../../search-ranking.js";
 import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
-import { branchStoreReason, inspectBranchStore, } from "../../utils/branch-store.js";
-import { loadEntities, paginateResults, validateEntityType, } from "./discovery-entities.js";
+import { branchStoreReason, inspectBranchStore, storeLockJournalReason, } from "../../utils/branch-store.js";
+import { loadEntities, loadSearchCandidates, paginateResults, validateEntityType, } from "./discovery-entities.js";
 import { buildActionsFromStatus, readMigrationConfigStatus, } from "./migration-plan.js";
 import { OperationJsonDecodeError, runOperationJsonQuery, } from "./prolog-json.js";
 import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
@@ -29,6 +29,7 @@ export async function executeQuery(input, context) {
     const { type, id, tags, sourceFile, limit = 100, offset = 0 } = input;
     try {
         const prolog = requireProlog(context);
+        const signal = context.signal;
         const indexedPage = prolog.queryEntities
             ? await prolog.queryEntities({
                 ...(type !== undefined ? { type } : {}),
@@ -37,7 +38,7 @@ export async function executeQuery(input, context) {
                 ...(sourceFile !== undefined ? { sourceFile } : {}),
                 limit,
                 offset,
-            })
+            }, signal)
             : null;
         if (indexedPage !== null) {
             const paginated = indexedPage.entities;
@@ -118,15 +119,13 @@ export async function executeSearch(input, context) {
             };
         }
         const indexedCandidates = prolog.searchEntities
-            ? await prolog.searchEntities({
+            ? await loadSearchCandidates(prolog, {
                 query: trimmedQuery,
                 ...(type !== undefined ? { type } : {}),
-                limit: 100_000,
-                offset: 0,
-            })
+            }, context.signal)
             : null;
         const entities = indexedCandidates
-            ? [...indexedCandidates.entities]
+            ? [...indexedCandidates]
             : await loadEntities(prolog, {
                 ...(type !== undefined ? { type } : {}),
             });
@@ -180,16 +179,22 @@ export async function executeStatus(_input, context) {
         }
         else
             try {
-                const prolog = context.prolog ??
-                    (() => {
-                        ownedEngine = new EngineClient({
-                            workspaceRoot: context.workspaceRoot,
-                            branch: attachment.kbBranch,
-                            timeout: 15_000,
-                        });
-                        return ownedEngine;
-                    })();
-                payload = await runOperationJsonQuery(prolog, "status.pl", "status:kb_status_json(JsonString)", "Status execution");
+                // Prefer an injected or session-backed engine so MCP status shares the
+                // same client as discovery tools. Only spawn an owned fallback when no
+                // host session is available (CLI status without a live runtime port).
+                let prolog = context.prolog;
+                if (!prolog && context.ensureProlog) {
+                    prolog = await context.ensureProlog();
+                }
+                if (!prolog) {
+                    ownedEngine = new EngineClient({
+                        workspaceRoot: context.workspaceRoot,
+                        branch: attachment.kbBranch,
+                        timeout: 15_000,
+                    });
+                    prolog = ownedEngine;
+                }
+                payload = await runOperationJsonQuery(prolog, "status.pl", "status:kb_status_json(JsonString)", "Status execution", context.signal);
                 if (!isStatusPayload(payload)) {
                     throw new Error("Status execution query returned an invalid payload");
                 }
@@ -226,6 +231,7 @@ export async function executeStatus(_input, context) {
         const snapshotEvidence = await readWorkspaceSnapshot(context);
         const existingReasons = payload.staleReasons ?? [];
         const storeReason = branchStoreReason(store);
+        const lockReason = storeLockJournalReason(store.path);
         const engineReason = engineStatus
             ? {
                 code: engineStatus.errorCode ?? "engine_status_unavailable",
@@ -242,6 +248,7 @@ export async function executeStatus(_input, context) {
         const staleReasons = [
             ...existingReasons,
             ...(storeReason ? [storeReason] : []),
+            ...(lockReason ? [lockReason] : []),
             ...(engineReason ? [engineReason] : []),
         ].sort((left, right) => String(left.path ?? "").localeCompare(String(right.path ?? "")));
         const enrichedPayload = {
@@ -252,20 +259,20 @@ export async function executeStatus(_input, context) {
             staleReasons,
             staleReasonCount: staleReasons.length,
             staleReasonsTruncated: false,
-            verificationSnapshot: snapshotEvidence.available
+            proofSnapshot: snapshotEvidence.available
                 ? snapshotEvidence.snapshot.hash
                 : "unknown",
-            verificationSnapshotAvailable: snapshotEvidence.available,
+            proofSnapshotAvailable: snapshotEvidence.available,
             ...(snapshotEvidence.available
                 ? {
-                    verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
-                    verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
-                    verificationSnapshotVersion: snapshotEvidence.snapshot.version,
-                    verificationSnapshotChanges: snapshotEvidence.snapshot.changes ?? [],
-                    verificationSnapshotChangeCount: snapshotEvidence.snapshot.changeCount ?? 0,
-                    verificationSnapshotChangesTruncated: snapshotEvidence.snapshot.changesTruncated ?? false,
+                    proofSnapshotDirty: snapshotEvidence.snapshot.dirty,
+                    proofSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
+                    proofSnapshotVersion: snapshotEvidence.snapshot.version,
+                    proofSnapshotChanges: snapshotEvidence.snapshot.changes ?? [],
+                    proofSnapshotChangeCount: snapshotEvidence.snapshot.changeCount ?? 0,
+                    proofSnapshotChangesTruncated: snapshotEvidence.snapshot.changesTruncated ?? false,
                 }
-                : { verificationSnapshotError: snapshotEvidence.error }),
+                : { proofSnapshotError: snapshotEvidence.error }),
         };
         const schemaStatus = readMigrationConfigStatus(context.workspaceRoot);
         const migrationPlan = buildActionsFromStatus({
@@ -273,9 +280,9 @@ export async function executeStatus(_input, context) {
             branchAttachment: attachment,
             branchStore: store,
             staleReasons,
-            verificationSnapshotAvailable: snapshotEvidence.available,
+            proofSnapshotAvailable: snapshotEvidence.available,
             ...(snapshotEvidence.available
-                ? { verificationSnapshotDirty: snapshotEvidence.snapshot.dirty }
+                ? { proofSnapshotDirty: snapshotEvidence.snapshot.dirty }
                 : {}),
             kbSnapshotId: payload.snapshotId,
             workspaceSnapshot: snapshotEvidence.available
@@ -283,7 +290,7 @@ export async function executeStatus(_input, context) {
                 : null,
             configStatus: schemaStatus,
         });
-        const bootstrapSourceFiles = context.fs?.glob
+        const listed = context.fs?.glob
             ? await context.fs.glob([
                 ".kb/requirements/**/*.md",
                 ".kb/scenarios/**/*.md",
@@ -295,6 +302,7 @@ export async function executeStatus(_input, context) {
                 ".kb/facts/**/*.md",
             ], { cwd: context.workspaceRoot })
             : [];
+        const bootstrapSourceFiles = Array.isArray(listed) ? listed : [];
         const bootstrapActivation = await classifyActivation(context, bootstrapSourceFiles);
         const statusWithPlan = {
             ...enrichedPayload,
@@ -341,7 +349,7 @@ export async function executeStatus(_input, context) {
             content: [
                 {
                     type: "text",
-                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, verificationSnapshot=${enrichedPayload.verificationSnapshot})`,
+                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, proofSnapshot=${enrichedPayload.proofSnapshot})`,
                 },
             ],
             structuredContent: statusWithPlan,