kibi-cli 1.0.1 → 2.1.0

package/dist/public/operations/specs/semantic.js

@@ -1,5 +1,6 @@
 import { InputError } from "../../../cli-errors.js";
-import { analyzeSemanticAdvisorInput } from "../../../operations/semantic-advisor/analyze-prose.js";
+import { analyzeSemanticAdvisorInputWithPlugins } from "../../../operations/semantic-advisor/plugin-orchestration.js";
+import { publicCapabilityStamp } from "../../../plugins/compose-semantic-classifier.js";
 function requiredText(value) {
     const text = typeof value === "string" ? value.trim() : "";
     if (!text) {
@@ -11,12 +12,12 @@ function optionalString(value) {
     const text = typeof value === "string" ? value.trim() : "";
     return text || undefined;
 }
-export async function executeSemanticAdvisor(args, _context) {
+export async function executeSemanticAdvisor(args, context) {
     const text = requiredText(args.text);
     const id = optionalString(args.id) ?? "REQ-SEMANTIC-ADVISOR-PREVIEW";
     const title = optionalString(args.title) ?? text.split(/[.!?]/, 1)[0] ?? text;
     const source = optionalString(args.source) ?? "mcp://kibi/semantic-advisor";
-    const result = analyzeSemanticAdvisorInput({
+    const orchestrated = await analyzeSemanticAdvisorInputWithPlugins({
         payload: {
             type: optionalString(args.type) ?? "req",
             id,
@@ -31,7 +32,52 @@ export async function executeSemanticAdvisor(args, _context) {
         ...(args.interpretations !== undefined
             ? { interpretations: args.interpretations }
             : {}),
+    }, {
+        operationName: "kb_semantic_advisor",
+        ...(context?.ensurePlugins
+            ? { ensurePlugins: context.ensurePlugins }
+            : {}),
     });
+    const result = orchestrated.analysis;
+    const pluginWarnings = orchestrated.stamps.length > 0
+        ? [
+            `Capability plugins consulted: ${orchestrated.stamps
+                .map((stamp) => `${stamp.pluginId}/${stamp.capability}`)
+                .join(", ")}.`,
+        ]
+        : [];
+    const capabilityPlugins = orchestrated.stamps.length > 0 ||
+        (orchestrated.classification?.shadowComparisons.length ?? 0) > 0 ||
+        orchestrated.ontologyShadowMatches.length > 0
+        ? {
+            stamps: orchestrated.stamps.map((stamp) => publicCapabilityStamp(stamp)),
+            classification: orchestrated.classification
+                ? {
+                    fallbackUsed: orchestrated.classification.fallbackUsed,
+                    decisions: orchestrated.classification.decisions,
+                    shadowComparisons: orchestrated.classification.shadowComparisons.map((comparison) => ({
+                        ...publicCapabilityStamp(comparison.stamp),
+                        decisions: comparison.decisions.map((decision) => ({
+                            claimKey: decision.claimKey,
+                            lane: decision.lane,
+                            confidence: decision.confidence,
+                        })),
+                    })),
+                }
+                : null,
+            ontology: {
+                replaced: orchestrated.ontologyCatalog?.replaced ?? false,
+                matchCount: orchestrated.ontologyMatches.length,
+                shadowMatchCount: orchestrated.ontologyShadowMatches.length,
+                shadowMatches: orchestrated.ontologyShadowMatches.map((candidate) => ({
+                    packId: candidate.packId,
+                    schemaId: candidate.schemaId,
+                    predicateName: candidate.predicateName,
+                    confidence: candidate.confidence,
+                })),
+            },
+        }
+        : undefined;
     return {
         content: [
             {
@@ -39,7 +85,11 @@ export async function executeSemanticAdvisor(args, _context) {
                 text: `kb_semantic_advisor: ${result.receipt.summary} Suggestions: ${result.receipt.suggestions.map(({ kind }) => kind).join(", ") || "none"}.`,
             },
         ],
-        structuredContent: { receipt: result.receipt, warnings: result.warnings },
+        structuredContent: {
+            receipt: result.receipt,
+            warnings: [...result.warnings, ...pluginWarnings],
+            ...(capabilityPlugins ? { capabilityPlugins } : {}),
+        },
     };
 }
 async function executeSemanticAdvisorInput(input, context) {

package/dist/public/operations/specs/upsert.d.ts

@@ -124,208 +124,302 @@ export declare const upsertSpec: {
                         readonly enum: readonly ["internal", "consumer"];
                         readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
                     };
-                    readonly verification_contract: {
+                    readonly proof_contract: {
+                        readonly description: "Semantic proof contract binding this test to explicit proof obligations executed by one configured integration.";
                         readonly type: "object";
-                        readonly required: readonly ["version", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+                        readonly required: readonly ["version", "integration", "required_proofs", "success_policy"];
                         readonly properties: {
                             readonly version: {
                                 readonly type: "string";
-                                readonly const: "kibi.verification-contract.v1";
+                                readonly const: "kibi.proof-contract.v1";
                             };
-                            readonly runner: {
+                            readonly integration: {
                                 readonly type: "string";
                                 readonly minLength: 1;
                             };
-                            readonly command_argv: {
+                            readonly required_proofs: {
                                 readonly type: "array";
                                 readonly minItems: 1;
+                                readonly maxItems: 1000;
                                 readonly items: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["symbol_id", "target"];
+                                    readonly properties: {
+                                        readonly symbol_id: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly target: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                    };
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                            readonly success_policy: {
+                                readonly type: "string";
+                                readonly enum: readonly ["all_required_first_attempt"];
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly proof_bindings: {
+                        readonly description: "Optional native-runner bindings (native ids, aliases, source coordinates) for proof obligations. Bindings are provenance metadata and never replace the semantic contract.";
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id", "target"];
+                            readonly properties: {
+                                readonly symbol_id: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                            };
-                            readonly required_case_symbols: {
-                                readonly type: "array";
-                                readonly items: {
+                                readonly target: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly uniqueItems: true;
-                            };
-                            readonly required_projects: {
-                                readonly type: "array";
-                                readonly items: {
+                                readonly native_id: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly uniqueItems: true;
-                            };
-                            readonly success_policy: {
-                                readonly type: "string";
-                                readonly const: "all_required_cases_first_attempt";
+                                readonly aliases: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                                readonly source_file: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly line: {
+                                    readonly type: "integer";
+                                    readonly minimum: 1;
+                                };
                             };
+                            readonly additionalProperties: false;
                         };
-                        readonly additionalProperties: false;
                     };
-                    readonly verification_receipts: {
+                    readonly proof_receipts: {
                         readonly type: "array";
                         readonly maxItems: 50;
                         readonly items: {
-                            readonly oneOf: readonly [{
-                                readonly type: "object";
-                                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
-                                readonly properties: {
-                                    readonly version: {
-                                        readonly type: "string";
-                                        readonly const: "kibi.verification-receipt.v1";
-                                    };
-                                    readonly receipt_id: {
-                                        readonly type: "string";
-                                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                                    };
-                                    readonly test_id: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly runner: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly command: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly scope: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["unit", "integration", "end_to_end"];
-                                    };
-                                    readonly outcome: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
-                                    };
-                                    readonly code_snapshot: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
-                                    readonly environment_hash: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
-                                    readonly started_at: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly finished_at: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly artifact_digest: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
+                            readonly type: "object";
+                            readonly description: "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.";
+                            readonly required: readonly ["version", "receipt_id", "test_id", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "contract_hash", "fingerprint", "fingerprint_components", "integration_id", "producer", "command_argv", "run_outcome", "proof_results"];
+                            readonly properties: {
+                                readonly version: {
+                                    readonly type: "string";
+                                    readonly const: "kibi.proof-receipt.v1";
                                 };
-                                readonly additionalProperties: false;
-                            }, {
-                                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "command_argv", "contract_hash", "case_results"];
-                                readonly properties: {
-                                    readonly version: {
-                                        readonly type: "string";
-                                        readonly const: "kibi.verification-receipt.v2";
+                                readonly receipt_id: {
+                                    readonly type: "string";
+                                    readonly pattern: "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                                };
+                                readonly test_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly scope: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["unit", "integration", "end_to_end"];
+                                };
+                                readonly outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                                };
+                                readonly code_snapshot: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly environment_hash: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly started_at: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly finished_at: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly artifact_digest: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly contract_hash: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly binding_hash: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly fingerprint: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly fingerprint_components: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["contract", "integration", "command", "bindings", "producer"];
+                                    readonly additionalProperties: false;
+                                    readonly properties: {
+                                        readonly contract: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-f0-9]{64}$";
+                                        };
+                                        readonly integration: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-f0-9]{64}$";
+                                        };
+                                        readonly command: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-f0-9]{64}$";
+                                        };
+                                        readonly bindings: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-f0-9]{64}$";
+                                        };
+                                        readonly producer: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-f0-9]{64}$";
+                                        };
                                     };
-                                    readonly command_argv: {
-                                        readonly type: "array";
-                                        readonly minItems: 1;
-                                        readonly items: {
+                                };
+                                readonly integration_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly producer: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["name"];
+                                    readonly properties: {
+                                        readonly name: {
                                             readonly type: "string";
                                             readonly minLength: 1;
                                         };
-                                    };
-                                    readonly contract_hash: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
-                                    readonly case_results: {
-                                        readonly type: "array";
-                                        readonly minItems: 1;
-                                        readonly maxItems: 1000;
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly required: readonly ["symbol_id", "project", "outcome", "retries", "duration_ms"];
-                                            readonly properties: {
-                                                readonly symbol_id: {
-                                                    readonly type: "string";
-                                                    readonly minLength: 1;
-                                                };
-                                                readonly project: {
-                                                    readonly type: "string";
-                                                    readonly minLength: 1;
-                                                };
-                                                readonly outcome: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted"];
-                                                };
-                                                readonly retries: {
-                                                    readonly type: "integer";
-                                                    readonly minimum: 0;
-                                                };
-                                                readonly duration_ms: {
-                                                    readonly type: "integer";
-                                                    readonly minimum: 0;
-                                                };
-                                            };
-                                            readonly additionalProperties: false;
+                                        readonly version: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
                                         };
                                     };
-                                    readonly receipt_id: {
-                                        readonly type: "string";
-                                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                                    };
-                                    readonly test_id: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly runner: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly command: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly scope: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["unit", "integration", "end_to_end"];
-                                    };
-                                    readonly outcome: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
-                                    };
-                                    readonly code_snapshot: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
-                                    readonly environment_hash: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
-                                    };
-                                    readonly started_at: {
+                                    readonly additionalProperties: false;
+                                };
+                                readonly command_argv: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly items: {
                                         readonly type: "string";
                                         readonly minLength: 1;
                                     };
-                                    readonly finished_at: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                                };
+                                readonly run_outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                                };
+                                readonly proof_results: {
+                                    readonly type: "array";
+                                    readonly minItems: 0;
+                                    readonly maxItems: 1000;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                                        readonly properties: {
+                                            readonly symbol_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly target: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly outcome: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                            };
+                                            readonly binding: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["native_case", "aggregate_run"];
+                                            };
+                                            readonly native_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly attempts: {
+                                                readonly oneOf: readonly [{
+                                                    readonly type: "object";
+                                                    readonly required: readonly ["status", "entries"];
+                                                    readonly properties: {
+                                                        readonly status: {
+                                                            readonly type: "string";
+                                                            readonly const: "complete";
+                                                        };
+                                                        readonly entries: {
+                                                            readonly type: "array";
+                                                            readonly minItems: 1;
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly required: readonly ["outcome"];
+                                                                readonly properties: {
+                                                                    readonly outcome: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                                                    };
+                                                                    readonly duration_ms: {
+                                                                        readonly type: "number";
+                                                                        readonly minimum: 0;
+                                                                    };
+                                                                };
+                                                                readonly additionalProperties: false;
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly additionalProperties: false;
+                                                }, {
+                                                    readonly type: "object";
+                                                    readonly required: readonly ["status"];
+                                                    readonly properties: {
+                                                        readonly status: {
+                                                            readonly type: "string";
+                                                            readonly const: "unavailable";
+                                                        };
+                                                    };
+                                                    readonly additionalProperties: false;
+                                                }];
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
                                     };
-                                    readonly artifact_digest: {
-                                        readonly type: "string";
-                                        readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly gaps: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["symbol_id", "target", "reason"];
+                                        readonly properties: {
+                                            readonly symbol_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly target: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly reason: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
                                     };
                                 };
-                                readonly type: "object";
-                                readonly additionalProperties: false;
-                            }];
+                            };
+                            readonly additionalProperties: false;
                         };
-                        readonly description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.";
+                        readonly description: "Append-only proof evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot, current contract hash, and effective execution fingerprint within the seven-day freshness window. Ingest rotates the oldest entries at the cap.";
                     };
                     readonly fact_kind: {
                         readonly type: "string";
@@ -489,7 +583,7 @@ export declare const upsertSpec: {
                 };
                 readonly allOf: readonly [Record<string, unknown>, {
                     readonly if: {
-                        readonly required: readonly ["verification_receipts"];
+                        readonly required: readonly ["proof_receipts"];
                     };
                     readonly then: {
                         readonly required: readonly ["verification_scope"];

package/dist/public/operations/specs/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCuC,CAAC"}

package/dist/public/operations/symbol-repair-plan.d.ts

@@ -6,6 +6,17 @@ export type SymbolRepairPlan = Readonly<{
     autoApplicable: false;
     repairs: readonly Readonly<Record<string, unknown>>[];
 }>;
+export type CoordinateRepairEvidence = Readonly<{
+    symbolId: string;
+    sourceFile: string | null;
+    refreshable: boolean;
+    reason: "extractable" | "coarse_anchor" | "extractor_miss" | "source_unavailable";
+    suggestion: string;
+}>;
+/** Preview the same extraction and explicit coarse fallback used by refresh. */
+export declare function inspectCoordinateRepairs(symbols: readonly Readonly<Record<string, unknown>>[], workspaceRoot: string): Promise<Map<string, CoordinateRepairEvidence>>;
+/** Attach current extraction evidence before constructing requirement repairs. */
+export declare function addCoordinateRepairEvidence(rows: readonly Readonly<Record<string, unknown>>[], context: OperationContext): Promise<readonly Readonly<Record<string, unknown>>[]>;
 /** Build review-only, evidence-backed symbol recovery suggestions. */
 export declare function buildSymbolRepairPlan(rows: readonly Readonly<Record<string, unknown>>[], context: OperationContext): Promise<SymbolRepairPlan | undefined>;
 //# sourceMappingURL=symbol-repair-plan.d.ts.map

package/dist/public/operations/symbol-repair-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-repair-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/symbol-repair-plan.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,eAAO,MAAM,0BAA0B,EAAG,4BAAqC,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,OAAO,0BAA0B,CAAC;IAC3C,QAAQ,EAAE,IAAI,CAAC;IACf,cAAc,EAAE,KAAK,CAAC;IACtB,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACvD,CAAC,CAAC;AA0DH,sEAAsE;AACtE,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EAClD,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAwFvC"}
+{"version":3,"file":"symbol-repair-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/symbol-repair-plan.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,eAAO,MAAM,0BAA0B,EAAG,4BAAqC,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,OAAO,0BAA0B,CAAC;IAC3C,QAAQ,EAAE,IAAI,CAAC;IACf,cAAc,EAAE,KAAK,CAAC;IACtB,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACvD,CAAC,CAAC;AAoBH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EACF,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,oBAAoB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AAEH,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EACrD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CA2DhD;AAED,kFAAkF;AAClF,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EAClD,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CA+DvD;AAwCD,sEAAsE;AACtE,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EAClD,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CA+FvC"}