kibi-cli 0.19.0 → 2.0.0

package/dist/operations/planning/compile-intent.js

@@ -0,0 +1,618 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { dump as dumpYaml } from "js-yaml";
+import { executeIntentSearch, } from "../../intent-search.js";
+import { normalizeEntityId, parseTriples } from "../../prolog/codec.js";
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { executeStatus } from "../../public/operations/discovery-executors.js";
+import { configuredSourceTarget } from "../mutation/source-authoring.js";
+import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
+import { canonicalize } from "../semantic-advisor/shared.js";
+// implements REQ-kibi-change-to-proof-plan-compiler
+export const COMPILE_PLAN_VERSION = "kibi.compile-plan.v1";
+// implements REQ-kibi-change-to-proof-plan-compiler
+export function compilePlanHash(plan) {
+    const { planHash: _ignored, ...body } = plan;
+    return hash(body);
+}
+const AUTO_UPDATE_SCORE = 0.85;
+const AUTO_UPDATE_MARGIN = 0.15;
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function hash(value) {
+    return createHash("sha256").update(canonicalize(value)).digest("hex");
+}
+function shortHash(value, length = 8) {
+    return hash(value).slice(0, length);
+}
+function slug(value) {
+    const result = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 42);
+    return result || "intent";
+}
+function requiredIntent(args) {
+    const intent = text(args.intent);
+    if (!intent)
+        throw new Error("Compile intent failed: intent must be non-empty");
+    if (args.mode !== "create" && args.mode !== "update") {
+        throw new Error("Compile intent failed: mode must be create or update");
+    }
+    if (args.mode === "update" &&
+        args.requirementId !== undefined &&
+        !text(args.requirementId)) {
+        throw new Error("Compile intent failed: requirementId must be non-empty when supplied");
+    }
+    return intent;
+}
+function validateLocation(location) {
+    if (!text(location.path) ||
+        path.isAbsolute(location.path) ||
+        location.path.split(/[\\/]/).includes("..")) {
+        throw new Error("Compile intent failed: sourceLocations.path must be workspace-relative");
+    }
+}
+function mergeRelationships(rows) {
+    const seen = new Set();
+    return rows.filter((row) => {
+        const key = `${text(row.type)}\0${text(row.from)}\0${text(row.to)}`;
+        if (!key.replace(/\0/g, ""))
+            return false;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function mergeSteps(steps) {
+    const merged = new Map();
+    for (const raw of steps) {
+        const step = { ...raw };
+        const type = text(step.type);
+        const id = text(step.id);
+        if (!type || !id)
+            continue;
+        const key = `${type}:${id}`;
+        const previous = merged.get(key);
+        if (!previous) {
+            merged.set(key, {
+                ...step,
+                ...(Array.isArray(step.relationships)
+                    ? {
+                        relationships: mergeRelationships(step.relationships.filter(isRecord)),
+                    }
+                    : {}),
+            });
+            continue;
+        }
+        const properties = {
+            ...(isRecord(previous.properties) ? previous.properties : {}),
+            ...(isRecord(step.properties) ? step.properties : {}),
+        };
+        const relationships = mergeRelationships([
+            ...(Array.isArray(previous.relationships)
+                ? previous.relationships.filter(isRecord)
+                : []),
+            ...(Array.isArray(step.relationships)
+                ? step.relationships.filter(isRecord)
+                : []),
+        ]);
+        merged.set(key, { ...previous, ...step, properties, relationships });
+    }
+    return [...merged.values()].sort((left, right) => {
+        const leftType = text(left.type) === "req" ? 1 : 0;
+        const rightType = text(right.type) === "req" ? 1 : 0;
+        return leftType - rightType || text(left.id).localeCompare(text(right.id));
+    });
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function propositionStatus(proposition, suggestion) {
+    if (proposition.role === "rationale" ||
+        proposition.role === "example" ||
+        proposition.role === "subjective") {
+        return "nonlogical";
+    }
+    if (suggestion?.kind === "ambiguity_observation")
+        return "ambiguous";
+    if (suggestion?.kind === "ontology_gap")
+        return "ontology_gap";
+    if (suggestion?.kind === "strict_property" ||
+        suggestion?.kind === "predicate" ||
+        suggestion?.kind === "rule")
+        return "modeled";
+    if (proposition.status === "ambiguous")
+        return "ambiguous";
+    if (proposition.status === "ontology_gap" || proposition.status === "missing")
+        return "ontology_gap";
+    return proposition.status === "nonlogical" ? "nonlogical" : "modeled";
+}
+function propositionDisposition(proposition, suggestion) {
+    if (proposition.role === "rationale" ||
+        proposition.role === "example" ||
+        proposition.role === "subjective")
+        return "nonlogical";
+    if (suggestion?.kind === "strict_property")
+        return "strict_property";
+    if (suggestion?.kind === "predicate")
+        return "predicate";
+    if (suggestion?.kind === "rule")
+        return "rule";
+    return "observation";
+}
+function sourceFilesFor(locations) {
+    return Array.from(new Set((locations ?? []).map((location) => location.path.trim()).filter(Boolean))).sort();
+}
+async function sourceHashes(context, locations) {
+    const hashes = {};
+    for (const relative of sourceFilesFor(locations)) {
+        try {
+            const contents = context.fs
+                ? await context.fs.readFile(path.join(context.workspaceRoot, relative))
+                : null;
+            hashes[relative] =
+                contents === null
+                    ? null
+                    : createHash("sha256").update(contents).digest("hex");
+        }
+        catch {
+            hashes[relative] = null;
+        }
+    }
+    return hashes;
+}
+function sourceTarget(context, locations, existingSource) {
+    const explicit = locations?.[0]?.path?.trim();
+    if (explicit)
+        return explicit.replaceAll("\\", "/");
+    if (existingSource &&
+        !/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(existingSource) &&
+        /\.(?:md|mdx|ya?ml)$/i.test(existingSource))
+        return existingSource.replaceAll("\\", "/");
+    return configuredSourceTarget(context.workspaceRoot, "req");
+}
+async function sourceWritePlan(context, requirementId, title, intent, locations, existingSource, existingEntityExists) {
+    if (!context.fs)
+        return [];
+    if (existingEntityExists &&
+        (locations === undefined || locations.length === 0) &&
+        !existingSource.match(/\.(?:md|mdx|ya?ml|json)$/i)) {
+        return [];
+    }
+    const relative = sourceTarget(context, locations, existingSource);
+    if (!relative ||
+        path.isAbsolute(relative) ||
+        relative.split(/[\\/]/).includes("..")) {
+        return [];
+    }
+    const absolute = path.resolve(context.workspaceRoot, relative);
+    const root = path.resolve(context.workspaceRoot);
+    if (absolute !== root && !absolute.startsWith(`${root}${path.sep}`))
+        return [];
+    const workspaceRelative = path.relative(root, absolute);
+    if (workspaceRelative === ".kb" ||
+        workspaceRelative.startsWith(`.kb${path.sep}`))
+        return [];
+    let before;
+    try {
+        before = await context.fs.readFile(absolute);
+    }
+    catch {
+        before = undefined;
+    }
+    const frontmatter = `---\n${dumpYaml({ id: requirementId, title, type: "req", status: "open" }, { noRefs: true, lineWidth: -1 })}---\n`;
+    const body = `${frontmatter}${intent.trim()}\n`;
+    return [
+        {
+            path: relative,
+            mode: "write",
+            beforeHash: before === undefined
+                ? null
+                : createHash("sha256").update(before).digest("hex"),
+            afterHash: createHash("sha256").update(body).digest("hex"),
+            body,
+        },
+    ];
+}
+function generatedRequirementId(intent) {
+    return `REQ-${slug(intent)}-${shortHash(intent).toUpperCase()}`;
+}
+async function contradictionAnalysis(prolog, requirementId) {
+    const result = await prolog.query("findall([A,B,Reason], contradicting_reqs(A, B, Reason), Rows)");
+    if (!result.success)
+        return { outcome: "unresolved", witnesses: [] };
+    const rows = parseTriples(result.bindings.Rows ?? "[]");
+    const witnesses = rows
+        .map(([left, right, reason]) => ({
+        left: normalizeEntityId(left),
+        right: normalizeEntityId(right),
+        reason,
+    }))
+        .filter(({ left, right }) => left === requirementId || right === requirementId)
+        .map(({ left, right, reason }) => ({
+        requirements: [left, right],
+        reason,
+    }));
+    return {
+        outcome: witnesses.length > 0 ? "conflict" : "no_conflict",
+        witnesses,
+    };
+}
+function proposalFor(requirementId, match) {
+    const candidateId = text(match.entity.id);
+    const candidateType = text(match.entity.type);
+    if (!candidateId || candidateType === "req")
+        return null;
+    const relationship = candidateType === "scenario"
+        ? { from: requirementId, to: candidateId, type: "specified_by" }
+        : candidateType === "symbol"
+            ? { from: candidateId, to: requirementId, type: "implements" }
+            : candidateType === "test"
+                ? { from: candidateId, to: requirementId, type: "covered_by" }
+                : null;
+    if (!relationship)
+        return null;
+    const proposalId = `PROP-${shortHash({ candidateId, relationship })}`.toUpperCase();
+    return {
+        proposalId,
+        candidateId,
+        candidateType,
+        relationship,
+        confidence: match.score,
+        evidence: match.reasons,
+        decision: "pending",
+    };
+}
+function applyAcceptedProposals(steps, proposals) {
+    const accepted = proposals.filter((proposal) => proposal.decision === "accept");
+    if (accepted.length === 0)
+        return [...steps];
+    const byId = new Map(steps.map((step) => [text(step.id), { ...step }]));
+    for (const proposal of accepted) {
+        const targetId = proposal.relationship.from;
+        const existing = byId.get(targetId);
+        if (!existing)
+            continue;
+        const relationships = mergeRelationships([
+            ...(Array.isArray(existing.relationships)
+                ? existing.relationships.filter(isRecord)
+                : []),
+            proposal.relationship,
+        ]);
+        byId.set(targetId, { ...existing, relationships });
+    }
+    return mergeSteps([...byId.values()]);
+}
+function draftId(prefix, title, index) {
+    return `${prefix}-${slug(title)}-${shortHash(`${title}\0${index}`).toUpperCase()}`;
+}
+// implements REQ-kibi-change-to-proof-plan-compiler
+function draftSteps(requirementId, scenarios, tests) {
+    const diagnostics = [];
+    const steps = [];
+    const scenarioIds = [];
+    const linkedScenarioIds = new Set();
+    const duplicateScenarioIds = new Set();
+    const testIds = new Set();
+    scenarios.forEach((scenario, index) => {
+        const id = text(scenario.id) || draftId("SCEN", scenario.title, index);
+        if (scenarioIds.includes(id)) {
+            duplicateScenarioIds.add(id);
+            diagnostics.push(`unresolved duplicate scenario draft ID ${id}; scenario associations are ambiguous.`);
+        }
+        scenarioIds.push(id);
+        steps.push({
+            type: "scenario",
+            id,
+            properties: {
+                title: scenario.title.trim(),
+                status: "draft",
+                body: scenario.body.trim(),
+                source: "mcp://kibi/compile-intent",
+            },
+            relationships: [],
+        });
+    });
+    tests.forEach((test, index) => {
+        const id = text(test.id) || draftId("TEST", test.title, index);
+        if (testIds.has(id)) {
+            diagnostics.push(`unresolved duplicate test draft ID ${id}; test associations are ambiguous.`);
+        }
+        testIds.add(id);
+        const requestedScenarioIds = test.scenarioIds?.map(text) ?? null;
+        const soleScenarioId = scenarioIds.length === 1 ? scenarioIds[0] : undefined;
+        const associatedScenarioIds = requestedScenarioIds !== null
+            ? Array.from(new Set(requestedScenarioIds.filter(Boolean)))
+            : soleScenarioId !== undefined
+                ? [soleScenarioId]
+                : [];
+        if (scenarioIds.length === 0) {
+            diagnostics.push(`unresolved test draft ${id} has no scenario draft; proof-bearing tests require a scenario relationship.`);
+        }
+        else if (requestedScenarioIds === null && scenarioIds.length > 1) {
+            diagnostics.push(`unresolved test draft ${id} must declare scenarioIds when multiple scenario drafts exist; positional association is not supported.`);
+        }
+        else if (requestedScenarioIds !== null &&
+            associatedScenarioIds.length === 0) {
+            diagnostics.push(`unresolved test draft ${id} must reference at least one scenario ID in scenarioIds.`);
+        }
+        if (requestedScenarioIds !== null &&
+            (requestedScenarioIds.some((scenarioId) => !scenarioId) ||
+                requestedScenarioIds.filter(Boolean).length !==
+                    associatedScenarioIds.length)) {
+            diagnostics.push(`unresolved test draft ${id} repeats or omits scenario IDs; associations must be unique and non-empty.`);
+        }
+        const validScenarioIds = associatedScenarioIds.filter((scenarioId) => scenarioIds.includes(scenarioId) &&
+            !duplicateScenarioIds.has(scenarioId));
+        for (const scenarioId of associatedScenarioIds) {
+            if (!scenarioIds.includes(scenarioId)) {
+                diagnostics.push(`unresolved test draft ${id} references unknown scenario ID ${scenarioId}.`);
+            }
+        }
+        for (const scenarioId of validScenarioIds)
+            linkedScenarioIds.add(scenarioId);
+        steps.push({
+            type: "test",
+            id,
+            properties: {
+                title: test.title.trim(),
+                status: "draft",
+                body: test.body.trim(),
+                source: "mcp://kibi/compile-intent",
+                verification_scope: test.verificationScope ?? "integration",
+                verification_perspective: test.verificationPerspective ?? "internal",
+            },
+            relationships: validScenarioIds.map((scenarioId) => ({
+                type: "verified_by",
+                from: scenarioId,
+                to: id,
+            })),
+        });
+    });
+    for (const scenarioId of scenarioIds) {
+        if (!linkedScenarioIds.has(scenarioId)) {
+            diagnostics.push(`unresolved scenario draft ${scenarioId} has no test draft; add a test with scenarioIds to establish executable coverage.`);
+        }
+    }
+    if (scenarioIds.length > 0) {
+        steps.push({
+            type: "req",
+            id: requirementId,
+            properties: {},
+            relationships: scenarioIds.map((id) => ({
+                type: "specified_by",
+                from: requirementId,
+                to: id,
+            })),
+        });
+    }
+    return { steps, diagnostics };
+}
+// implements REQ-kibi-change-to-proof-plan-compiler
+export async function executeCompileIntent(args, context) {
+    const intent = requiredIntent(args);
+    const prolog = context.prolog;
+    if (!prolog)
+        throw new Error("Compile intent requires a Prolog runtime");
+    for (const location of args.sourceLocations ?? [])
+        validateLocation(location);
+    const statusResult = await executeStatus({}, context);
+    const status = statusResult.structuredContent;
+    if (!status)
+        throw new Error("Compile intent failed: status query returned no payload");
+    const snapshotEvidence = status?.proofSnapshot;
+    const workspaceSnapshot = snapshotEvidence
+        ? {
+            version: "kibi.workspace-snapshot.v2",
+            hash: snapshotEvidence,
+            dirty: status?.proofSnapshotDirty ?? false,
+            fileCount: status?.proofSnapshotFileCount ?? 0,
+        }
+        : {
+            version: "kibi.workspace-snapshot.v2",
+            hash: "unknown",
+            dirty: true,
+            fileCount: 0,
+        };
+    const search = await executeIntentSearch({
+        query: intent,
+        type: "req",
+        ...(args.semanticFacets ? { semanticFacets: args.semanticFacets } : {}),
+        ...(args.sourceLocations
+            ? { sourceLocations: args.sourceLocations }
+            : {}),
+        minScore: 0.05,
+    }, prolog, context.workspaceRoot);
+    const top = search.matches[0];
+    const margin = search.analysis.topTwoMargin ?? 1;
+    const explicitId = text(args.requirementId);
+    let requirementId = explicitId;
+    let selectionReason = explicitId
+        ? "Caller supplied requirementId."
+        : "Generated from intent content hash.";
+    const diagnostics = [];
+    if (args.mode === "update" && !explicitId) {
+        if (top && top.score >= AUTO_UPDATE_SCORE && margin >= AUTO_UPDATE_MARGIN) {
+            requirementId = text(top.entity.id);
+            selectionReason = `Selected top requirement because score ${top.score.toFixed(3)} >= ${AUTO_UPDATE_SCORE.toFixed(2)} and margin ${margin.toFixed(3)} >= ${AUTO_UPDATE_MARGIN.toFixed(2)}.`;
+        }
+        else {
+            requirementId = text(top?.entity.id) || "REQ-PENDING-RESOLUTION";
+            diagnostics.push("Update target is unresolved: supply requirementId or improve the top candidate score and margin.");
+        }
+    }
+    if (args.mode === "create")
+        requirementId = generatedRequirementId(intent);
+    if (!requirementId)
+        throw new Error("Compile intent failed: could not determine requirementId");
+    const existing = await loadEntities(prolog, {
+        id: requirementId,
+        type: "req",
+    });
+    if (args.mode === "create" && existing.length > 0) {
+        const existingText = text(existing[0]?.semantic_text) || text(existing[0]?.title);
+        if (existingText !== intent)
+            diagnostics.push(`Generated requirement ID ${requirementId} already exists with different content; create is blocked.`);
+    }
+    if (args.mode === "update" && !explicitId && diagnostics.length > 0) {
+        diagnostics.push("No mutation steps are emitted until the update target is explicitly resolved.");
+    }
+    if (args.mode === "update" && explicitId && existing.length === 0)
+        diagnostics.push(`Requirement ${requirementId} was not found in the current KB snapshot.`);
+    const existingEntity = existing[0] ?? {};
+    const title = text(args.title) ||
+        text(existingEntity.title) ||
+        intent.split(/[.!?]/, 1)[0] ||
+        intent;
+    const source = text(args.sourceLocations?.[0]?.path) ||
+        text(existingEntity.source) ||
+        "mcp://kibi/compile-intent";
+    const advisor = analyzeSemanticAdvisorInput({
+        payload: {
+            type: "req",
+            id: requirementId,
+            properties: {
+                title,
+                status: text(existingEntity.status) || "open",
+                source,
+                semantic_text: intent,
+                ...(Array.isArray(existingEntity.logic_claims)
+                    ? { logic_claims: existingEntity.logic_claims }
+                    : {}),
+            },
+        },
+        ...(args.clauses ? { clauses: args.clauses } : {}),
+        ...(args.interpretations ? { interpretations: args.interpretations } : {}),
+    });
+    diagnostics.push(...advisor.warnings);
+    const suggestionByClaim = new Map(advisor.receipt.suggestions.map((suggestion) => [
+        suggestion.claim_key,
+        suggestion,
+    ]));
+    const propositions = advisor.receipt.propositions.map((proposition) => {
+        const suggestion = suggestionByClaim.get(proposition.claim_key);
+        return {
+            claimKey: proposition.claim_key,
+            text: proposition.claim_text,
+            span: proposition.span,
+            disposition: propositionDisposition(proposition, suggestion),
+            status: propositionStatus(proposition, suggestion),
+            origin: args.interpretations?.some((interpretation) => interpretation.claim_key === proposition.claim_key)
+                ? "host"
+                : "deterministic",
+        };
+    });
+    const executableSuggestions = advisor.receipt.suggestions.filter((suggestion) => ["strict_property", "predicate", "rule"].includes(suggestion.kind));
+    const steps = mergeSteps([
+        {
+            type: "req",
+            id: requirementId,
+            properties: {
+                title,
+                status: text(existingEntity.status) || "open",
+                source,
+                semantic_text: intent,
+            },
+            relationships: [],
+        },
+        ...executableSuggestions.flatMap((suggestion) => [
+            ...suggestion.applyPlan,
+            ...(suggestion.kind === "predicate" || suggestion.kind === "rule"
+                ? suggestion.relationshipPlan?.relationship
+                    ? [
+                        {
+                            type: "req",
+                            id: requirementId,
+                            properties: {},
+                            relationships: [suggestion.relationshipPlan.relationship],
+                        },
+                    ]
+                    : []
+                : []),
+        ]),
+    ]);
+    const drafts = draftSteps(requirementId, args.scenarioDrafts ?? [], args.testDrafts ?? []);
+    diagnostics.push(...drafts.diagnostics);
+    const proposalDecisions = new Map((args.proposalDecisions ?? []).map((decision) => [
+        decision.proposalId,
+        decision.decision,
+    ]));
+    const proposals = search.matches
+        .slice(0, 10)
+        .flatMap((match) => {
+        const proposal = proposalFor(requirementId, match);
+        if (!proposal)
+            return [];
+        const decision = proposalDecisions.get(proposal.proposalId);
+        return [
+            {
+                ...proposal,
+                decision: decision === "accept" || decision === "reject"
+                    ? decision
+                    : "pending",
+            },
+        ];
+    });
+    const stepsWithAcceptedProposals = applyAcceptedProposals([...steps, ...drafts.steps], proposals);
+    const contradictions = await contradictionAnalysis(prolog, requirementId);
+    if (contradictions.outcome === "conflict")
+        diagnostics.push("Current requirement conflicts must be resolved with an explicit supersedes relationship before applying this plan.");
+    if (contradictions.outcome === "unresolved")
+        diagnostics.push("Contradiction analysis could not run against the attached KB snapshot.");
+    if (args.mode === "create" &&
+        existing.length > 0 &&
+        diagnostics.some((entry) => entry.includes("already exists with different content")))
+        diagnostics.push("Change mode to update and supply requirementId to revise an existing requirement.");
+    const unresolved = propositions.some((proposition) => proposition.status === "ambiguous" ||
+        proposition.status === "ontology_gap") ||
+        diagnostics.some((entry) => entry.includes("unresolved") ||
+            entry.includes("not found") ||
+            entry.includes("different content"));
+    const statusValue = contradictions.outcome === "conflict"
+        ? "blocked"
+        : unresolved
+            ? "needs_resolution"
+            : "ready";
+    const sourceHashMap = await sourceHashes(context, args.sourceLocations);
+    const sourceWrites = statusValue === "ready"
+        ? await sourceWritePlan(context, requirementId, title, intent, args.sourceLocations, source, existing.length > 0)
+        : [];
+    const planBody = {
+        version: COMPILE_PLAN_VERSION,
+        status: statusValue,
+        expected: {
+            branch: status.branch,
+            kbSnapshotId: status.snapshotId,
+            workspaceSnapshot: workspaceSnapshot.hash,
+            sourceHashes: sourceHashMap,
+        },
+        target: { mode: args.mode, requirementId, selectionReason },
+        discovery: {
+            candidates: search.matches,
+            abstained: search.analysis.abstained,
+        },
+        propositions,
+        contradictionAnalysis: contradictions,
+        proposals,
+        steps: stepsWithAcceptedProposals,
+        sourceWrites,
+        diagnostics,
+    };
+    const plan = {
+        ...planBody,
+        planHash: compilePlanHash(planBody),
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Compiled ${intent.length} characters into ${statusValue} plan ${plan.planHash.slice(0, 12)} with ${stepsWithAcceptedProposals.length} step(s).`,
+            },
+        ],
+        structuredContent: plan,
+    };
+}

package/dist/operations/proof/ingest-proof.d.ts

@@ -0,0 +1,34 @@
+import { type ProofGap } from "../../proof/evaluate.js";
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type ProofReceipt } from "../../public/proof-receipt.js";
+export type IngestProofArgs = Readonly<{
+    snapshot: string;
+    artifact: Readonly<Record<string, unknown>>;
+    testIds?: readonly string[];
+}>;
+export type IngestProofTestResult = Readonly<{
+    testId: string;
+    outcome: ProofReceipt["outcome"];
+    receiptId: string;
+    applied: boolean;
+    duplicate: boolean;
+    receiptCount: number;
+    gaps: readonly ProofGap[];
+}>;
+export type IngestProofResult = Readonly<{
+    artifactDigest: string;
+    environmentHash: string;
+    integration: string | null;
+    passed: number;
+    failed: number;
+    unchanged: number;
+    results: readonly IngestProofTestResult[];
+}>;
+export declare function executeIngestProof(args: IngestProofArgs, context: OperationContext): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: IngestProofResult;
+}>;
+//# sourceMappingURL=ingest-proof.d.ts.map

package/dist/operations/proof/ingest-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest-proof.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/ingest-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAOjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAkBjF,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,+BAA+B,CAAC;AAYvC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;CAC3B,CAAC,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAqFH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,iBAAiB,CAAC;CACtC,CAAC,CA2RD"}