kibi-cli 0.16.1 → 0.18.1

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

@@ -1,4 +1,8 @@
+import { VERIFICATION_RECEIPT_MAX_AGE_SECONDS } from "../../verification-receipt.js";
+import { buildLegacyMigrationPlanFromContext, } from "../legacy-migration-plan.js";
 import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../prolog-json.js";
+import { buildRepairPlan } from "../repair-plan.js";
+import { readWorkspaceSnapshot } from "../workspace-snapshot.js";
 const ENTITY_TYPES = [
     "req",
     "scenario",
@@ -68,17 +72,45 @@ export const findGapsSpec = {
 };
 export async function executeCoverage(input, context) {
     try {
-        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, JsonString)`, "Coverage execution");
-        const fullyCovered = Number(payload.summary?.fullyCovered ?? 0);
-        const total = Number(payload.summary?.total ?? 0);
+        const snapshotEvidence = await readWorkspaceSnapshot(context);
+        const codeSnapshot = snapshotEvidence.available
+            ? snapshotEvidence.snapshot.hash
+            : "unknown";
+        const checkedAt = context.clock().toISOString();
+        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, ${toPrologAtom(codeSnapshot)}, ${toPrologAtom(checkedAt)}, ${VERIFICATION_RECEIPT_MAX_AGE_SECONDS}, JsonString)`, "Coverage execution");
+        const repairPlan = buildRepairPlan(payload, input, codeSnapshot);
+        const legacyMigrationPlan = input.includeMigrationPreview === true && repairPlan !== undefined
+            ? await buildLegacyMigrationPlanFromContext(repairPlan, input, codeSnapshot, context)
+            : undefined;
+        const enrichedPayload = {
+            ...payload,
+            ...(repairPlan !== undefined ? { repairPlan } : {}),
+            ...(legacyMigrationPlan !== undefined ? { legacyMigrationPlan } : {}),
+            meta: {
+                ...(payload.meta ?? {}),
+                verificationReceiptMaxAgeSeconds: VERIFICATION_RECEIPT_MAX_AGE_SECONDS,
+                verificationSnapshot: codeSnapshot,
+                verificationSnapshotAvailable: snapshotEvidence.available,
+                ...(snapshotEvidence.available
+                    ? {
+                        verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
+                        verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
+                        verificationSnapshotVersion: snapshotEvidence.snapshot.version,
+                    }
+                    : { verificationSnapshotError: snapshotEvidence.error }),
+            },
+        };
+        const fullyCovered = Number(enrichedPayload.summary?.fullyCovered ?? 0);
+        const proofProven = Number(enrichedPayload.summary?.proofProven ?? 0);
+        const total = Number(enrichedPayload.summary?.total ?? 0);
         return {
             content: [
                 {
                     type: "text",
-                    text: `Coverage summary: ${fullyCovered} fully covered out of ${total}.`,
+                    text: `Coverage summary: ${fullyCovered} structurally covered and ${proofProven} proven out of ${total}.`,
                 },
             ],
-            structuredContent: payload,
+            structuredContent: enrichedPayload,
         };
     }
     catch (error) {
@@ -89,7 +121,7 @@ export async function executeCoverage(input, context) {
 export const coverageSpec = {
     name: "kb_coverage",
     cliName: "coverage",
-    description: "Generate curated coverage reports for requirements, symbols, or grouped types. Read-only reporting with no mutation side effects.",
+    description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Requirement reports include a deterministic, dependency-ordered, read-only repair plan; optional legacy migration previews reconstruct authored proposition inventories and rank exact schema candidates without producing executable writes. Paginated plans identify incomplete scope. Requirement rows keep coverageStatus separate from proofStatus and require fresh snapshot-bound E2E receipts before proof. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -99,6 +131,38 @@ export const coverageSpec = {
             includeTransitive: { type: "boolean", default: true },
             limit: { type: "integer", default: 100 },
             offset: { type: "integer", default: 0 },
+            includeMigrationPreview: {
+                type: "boolean",
+                default: false,
+                description: "Opt in to a deterministic, read-only kibi.legacy-migration-plan.v1 preview for ready semantic-inventory repair batches.",
+            },
+            migrationLimit: {
+                type: "integer",
+                minimum: 1,
+                maximum: 10,
+                default: 1,
+                description: "Maximum requirement migration batches to preview. Defaults to one review batch.",
+            },
+            migrationOffset: {
+                type: "integer",
+                minimum: 0,
+                default: 0,
+                description: "Zero-based offset into ready semantic-inventory batches.",
+            },
+            migrationPredicateLimit: {
+                type: "integer",
+                minimum: 1,
+                maximum: 20,
+                default: 5,
+                description: "Maximum exact predicate-schema candidates retained per assertive proposition.",
+            },
+            migrationPredicateMinScore: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                default: 0.35,
+                description: "Minimum deterministic predicate-schema rank score retained in migration previews.",
+            },
         },
     },
     requiresProlog: true,

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

@@ -21,11 +21,39 @@ export declare const semanticAdvisorSpec: {
                 };
                 readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
             };
+            readonly interpretations: {
+                readonly type: "array";
+                readonly maxItems: 3;
+                readonly description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["claim_key", "claim_text", "ir"];
+                    readonly properties: {
+                        readonly claim_key: {
+                            readonly type: "string";
+                        };
+                        readonly claim_text: {
+                            readonly type: "string";
+                        };
+                        readonly confidence: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                            readonly maximum: 1;
+                        };
+                        readonly span: {
+                            readonly type: "object";
+                        };
+                        readonly ir: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+            };
             readonly type: {
                 readonly type: "string";
-                readonly enum: readonly ["req"];
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
                 readonly default: "req";
-                readonly description: "Entity type context for analysis. Currently requirement prose is supported.";
+                readonly description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.";
             };
             readonly id: {
                 readonly type: "string";

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

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA2BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAuBzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDE,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA8BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}

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

@@ -24,10 +24,13 @@ export async function executeSemanticAdvisor(args, _context) {
                 title,
                 status: optionalString(args.status) ?? "open",
                 source,
-                text_ref: text,
+                semantic_text: text,
             },
         },
         ...(args.clauses !== undefined ? { clauses: args.clauses } : {}),
+        ...(args.interpretations !== undefined
+            ? { interpretations: args.interpretations }
+            : {}),
     });
     return {
         content: [
@@ -48,6 +51,9 @@ async function executeSemanticAdvisorInput(input, context) {
     const clauses = Array.isArray(input.clauses)
         ? input.clauses.filter((value) => typeof value === "string")
         : undefined;
+    const interpretations = Array.isArray(input.interpretations)
+        ? input.interpretations.filter((value) => typeof value === "object" && value !== null)
+        : undefined;
     return executeSemanticAdvisor({
         text: requiredText(input.text),
         ...(type ? { type } : {}),
@@ -56,6 +62,7 @@ async function executeSemanticAdvisorInput(input, context) {
         ...(source ? { source } : {}),
         ...(status ? { status } : {}),
         ...(clauses !== undefined ? { clauses } : {}),
+        ...(interpretations !== undefined ? { interpretations } : {}),
     }, context);
 }
 export const semanticAdvisorSpec = {
@@ -75,11 +82,36 @@ export const semanticAdvisorSpec = {
                 items: { type: "string" },
                 description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.",
             },
+            interpretations: {
+                type: "array",
+                maxItems: 3,
+                description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.",
+                items: {
+                    type: "object",
+                    required: ["claim_key", "claim_text", "ir"],
+                    properties: {
+                        claim_key: { type: "string" },
+                        claim_text: { type: "string" },
+                        confidence: { type: "number", minimum: 0, maximum: 1 },
+                        span: { type: "object" },
+                        ir: { type: "object" },
+                    },
+                },
+            },
             type: {
                 type: "string",
-                enum: ["req"],
+                enum: [
+                    "req",
+                    "scenario",
+                    "test",
+                    "adr",
+                    "flag",
+                    "event",
+                    "symbol",
+                    "fact",
+                ],
                 default: "req",
-                description: "Entity type context for analysis. Currently requirement prose is supported.",
+                description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.",
             },
             id: {
                 type: "string",

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

@@ -62,6 +62,10 @@ export declare const upsertSpec: {
                         readonly type: "string";
                         readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
                     };
+                    readonly semantic_text: {
+                        readonly type: "string";
+                        readonly description: "Requirement-only authored prose used for semantic inventory hashes and UTF-8 spans. Keep text_ref available for independent document or code evidence.";
+                    };
                     readonly logic_claims: {
                         readonly type: "array";
                         readonly minItems: 1;
@@ -72,6 +76,30 @@ export declare const upsertSpec: {
                         };
                         readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
                     };
+                    readonly semantic_clauses: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly description: "Optional complete atomic decomposition used by kb_semantic_advisor and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.";
+                    };
+                    readonly semantic_inventory_version: {
+                        readonly type: "string";
+                        readonly const: "kibi.semantic-inventory.v1";
+                        readonly description: "Requirement-only proposition ledger contract version returned by kb_semantic_advisor.";
+                    };
+                    readonly semantic_source_field: {
+                        readonly type: "string";
+                        readonly enum: readonly ["semantic_text", "text_ref", "title"];
+                        readonly description: "Requirement field whose exact UTF-8 bytes anchor semantic_inventory spans.";
+                    };
+                    readonly semantic_source_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                        readonly description: "SHA-256 of the exact semantic source text returned in the advisor inventory contract.";
+                    };
                     readonly sourceFile: {
                         readonly type: "string";
                         readonly description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.";
@@ -96,9 +124,69 @@ export declare const upsertSpec: {
                         readonly enum: readonly ["internal", "consumer"];
                         readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
                     };
+                    readonly verification_receipts: {
+                        readonly type: "array";
+                        readonly maxItems: 50;
+                        readonly items: {
+                            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"];
+                                };
+                                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 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 fact_kind: {
                         readonly type: "string";
-                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate"];
+                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate", "rule_schema", "rule"];
                         readonly description: "Optional fact lane kind for fact entities. Strict lane uses 'subject' and 'property_value'; context lane uses 'observation' or 'meta'; ontology lane uses 'predicate_schema' or 'predicate'. Use kb_model_requirement or kb_suggest_predicates when starting from prose.";
                     };
                     readonly subject_key: {
@@ -220,8 +308,50 @@ export declare const upsertSpec: {
                         };
                         readonly description: "Optional ground-term examples for a predicate schema.";
                     };
+                    readonly semantic_inventory: {
+                        readonly type: "array";
+                        readonly description: "Requirement proposition ledger returned by kb_semantic_advisor; preserve entries while modeling each assertive span.";
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                    readonly rule_ir: {
+                        readonly type: "object";
+                        readonly description: "Schema-validated kibi.logic.v1 rule IR. It is persisted as data and never executed as caller-supplied Prolog.";
+                    };
+                    readonly rule_hash: {
+                        readonly type: "string";
+                        readonly description: "Deterministic hash of canonical rule_ir.";
+                    };
+                    readonly rule_schema_id: {
+                        readonly type: "string";
+                        readonly description: "Rule schema fact ID used to validate this rule.";
+                    };
+                    readonly rule_name: {
+                        readonly type: "string";
+                        readonly description: "Stable rule schema name.";
+                    };
+                    readonly semantic_key: {
+                        readonly type: "string";
+                        readonly description: "Canonical semantic identity of the normalized logical model.";
+                    };
+                    readonly claim_span_start: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly claim_span_end: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
                 };
-                readonly allOf: readonly [Record<string, unknown>];
+                readonly allOf: readonly [Record<string, unknown>, {
+                    readonly if: {
+                        readonly required: readonly ["verification_receipts"];
+                    };
+                    readonly then: {
+                        readonly required: readonly ["verification_scope"];
+                    };
+                }];
                 readonly required: readonly ["title", "status"];
             };
             readonly relationships: {
@@ -233,7 +363,7 @@ export declare const upsertSpec: {
                     readonly properties: {
                         readonly type: {
                             readonly type: "string";
-                            readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+                            readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "relates_to"];
                             readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
                         };
                         readonly from: {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,CAAC"}

package/dist/public/operations/workspace-snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { OperationContext, WorkspaceSnapshot } from "./runtime-types.js";
+export type WorkspaceSnapshotEvidence = Readonly<{
+    available: true;
+    snapshot: WorkspaceSnapshot;
+}> | Readonly<{
+    available: false;
+    error: string;
+}>;
+export declare function readWorkspaceSnapshot(context: OperationContext): Promise<WorkspaceSnapshotEvidence>;
+//# sourceMappingURL=workspace-snapshot.d.ts.map

package/dist/public/operations/workspace-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-snapshot.d.ts","sourceRoot":"","sources":["../../../src/public/operations/workspace-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE9E,MAAM,MAAM,yBAAyB,GACjC,QAAQ,CAAC;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC,GAC1D,QAAQ,CAAC;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,yBAAyB,CAAC,CAmBpC"}

package/dist/public/operations/workspace-snapshot.js

@@ -0,0 +1,20 @@
+export async function readWorkspaceSnapshot(context) {
+    if (!context.git?.workspaceSnapshot) {
+        return {
+            available: false,
+            error: "The active operation runtime does not expose workspace snapshots.",
+        };
+    }
+    try {
+        return {
+            available: true,
+            snapshot: await context.git.workspaceSnapshot(context.workspaceRoot),
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/public/schemas/entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AA4FA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAsMzC,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwTA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CA6TzC,CAAC;AAEF,eAAe,YAAY,CAAC"}