kibi-cli 0.17.0 → 0.18.1

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

@@ -0,0 +1,184 @@
+export declare const REPAIR_PLAN_VERSION: "kibi.repair-plan.v1";
+type RepairPhaseDefinition = {
+    readonly order: number;
+    readonly objective: string;
+    readonly workflowSteps: readonly string[];
+    readonly validationRules: readonly string[];
+    readonly writePolicy: "analysis_then_sequential_upsert" | "review_then_sequential_upsert" | "sequential_upsert" | "execute_then_append_receipt" | "refresh_then_sync" | "runtime_recovery";
+};
+declare const REPAIR_PHASES: {
+    readonly requirement_source: {
+        readonly order: 5;
+        readonly objective: "Bind the requirement to its current authored source before semantic analysis.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["required-fields", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly semantic_inventory: {
+        readonly order: 10;
+        readonly objective: "Produce and persist a complete source-bound proposition inventory.";
+        readonly workflowSteps: readonly ["kb_semantic_advisor", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["semantic-completeness", "logic-coverage"];
+        readonly writePolicy: "analysis_then_sequential_upsert";
+    };
+    readonly semantic_resolution: {
+        readonly order: 20;
+        readonly objective: "Resolve ambiguity or ontology gaps without treating unresolved prose as modeled.";
+        readonly workflowSteps: readonly ["kb_semantic_advisor", "kb_suggest_predicates", "kb_model_requirement", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["semantic-completeness", "logic-coverage", "predicate-verifiability", "rule-safety", "rule-verifiability"];
+        readonly writePolicy: "review_then_sequential_upsert";
+    };
+    readonly ground_endpoints: {
+        readonly order: 30;
+        readonly objective: "Create or repair exactly one validated logical endpoint for each modeled proposition.";
+        readonly workflowSteps: readonly ["kb_suggest_predicates", "kb_model_requirement", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["strict-fact-shape", "predicate-verifiability", "rule-safety", "rule-verifiability", "logic-coverage"];
+        readonly writePolicy: "review_then_sequential_upsert";
+    };
+    readonly manifest_links: {
+        readonly order: 40;
+        readonly objective: "Persist the exact claim manifest and link it one-to-one to existing logical endpoints.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["semantic-completeness", "logic-coverage", "predicate-verifiability", "rule-safety", "rule-verifiability", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly contradiction_resolution: {
+        readonly order: 50;
+        readonly objective: "Inspect exact contradiction witnesses and supersede or reconcile conflicting requirements.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["domain-contradictions", "logic-coverage"];
+        readonly writePolicy: "review_then_sequential_upsert";
+    };
+    readonly scenario_endpoints: {
+        readonly order: 60;
+        readonly objective: "Create a scenario endpoint and link the requirement through specified_by.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["must-priority-coverage", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly scenario_tests: {
+        readonly order: 70;
+        readonly objective: "Create or select a test endpoint and link it through the requirement scenario.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["must-priority-coverage", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly snapshot_runtime: {
+        readonly order: 75;
+        readonly objective: "Use a runtime that exposes a deterministic workspace verification snapshot.";
+        readonly workflowSteps: readonly ["kb_status", "kb_coverage"];
+        readonly validationRules: readonly [];
+        readonly writePolicy: "runtime_recovery";
+    };
+    readonly verification_evidence: {
+        readonly order: 80;
+        readonly objective: "Run the scenario-backed E2E test and append a fresh snapshot-bound passing receipt.";
+        readonly workflowSteps: readonly ["kb_status", "execute_e2e", "kb_validate_upsert", "kb_upsert", "kb_coverage"];
+        readonly validationRules: readonly ["required-fields", "no-dangling-refs"];
+        readonly writePolicy: "execute_then_append_receipt";
+    };
+    readonly executable_symbols: {
+        readonly order: 90;
+        readonly objective: "Link executable test symbols to every qualifying E2E test through executable_for.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["symbol-traceability", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly production_ownership: {
+        readonly order: 100;
+        readonly objective: "Link production symbols to the requirement through implements.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["symbol-traceability", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly production_coverage: {
+        readonly order: 110;
+        readonly objective: "Link every implementing production symbol to a qualifying E2E test through covered_by.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["symbol-coverage", "symbol-traceability", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly source_coordinates: {
+        readonly order: 120;
+        readonly objective: "Refresh symbol extraction and persist exact current source coordinates.";
+        readonly workflowSteps: readonly ["kibi sync --refresh-symbol-coordinates", "kibi sync", "kb_check", "kb_coverage"];
+        readonly validationRules: readonly ["symbol-coverage", "symbol-traceability"];
+        readonly writePolicy: "refresh_then_sync";
+    };
+    readonly manual_review: {
+        readonly order: 900;
+        readonly objective: "Review the unclassified proof gap and choose a conservative repair workflow.";
+        readonly workflowSteps: readonly ["kb_query", "kb_check", "kb_coverage"];
+        readonly validationRules: readonly [];
+        readonly writePolicy: "review_then_sequential_upsert";
+    };
+};
+type RepairPhase = keyof typeof REPAIR_PHASES;
+export type RepairPlanRepair = {
+    readonly requirementId: string;
+    readonly gap: string;
+    readonly proofPriority: number;
+    readonly proofStage: string;
+    readonly action: string;
+    readonly evidence: Readonly<Record<string, unknown>>;
+};
+export type RepairPlanBatch = {
+    readonly id: string;
+    readonly order: number;
+    readonly phase: RepairPhase;
+    readonly requirementId: string;
+    readonly state: "ready" | "blocked";
+    readonly dependsOn: readonly string[];
+    readonly objective: string;
+    readonly workflowSteps: readonly string[];
+    readonly validationRules: readonly string[];
+    readonly writePolicy: RepairPhaseDefinition["writePolicy"];
+    readonly autoApplicable: false;
+    readonly repairs: readonly RepairPlanRepair[];
+};
+export type RepairPlan = {
+    readonly version: typeof REPAIR_PLAN_VERSION;
+    readonly planId: string;
+    readonly readOnly: true;
+    readonly status: "no_repairs" | "ready" | "partial";
+    readonly codeSnapshot: string;
+    readonly scope: {
+        readonly by: string;
+        readonly tags: readonly string[];
+        readonly offset: number;
+        readonly limit: number;
+        readonly complete: boolean;
+        readonly actionableRequirements: number;
+        readonly returnedActionableRequirements: number;
+        readonly excludedByPagination: number;
+    };
+    readonly applicationPolicy: {
+        readonly queryBeforeMutation: true;
+        readonly createEndpointsBeforeRelationships: true;
+        readonly validateBeforeEachWrite: true;
+        readonly sequentialUpsertsOnly: true;
+        readonly recheckCoverageAfterEachBatch: true;
+    };
+    readonly summary: {
+        readonly requirementCount: number;
+        readonly repairCount: number;
+        readonly batchCount: number;
+        readonly readyBatchCount: number;
+        readonly blockedBatchCount: number;
+    };
+    readonly batches: readonly RepairPlanBatch[];
+    readonly diagnostics: readonly string[];
+};
+export type RepairPlanInput = {
+    readonly by?: "req" | "symbol" | "type";
+    readonly tags?: readonly string[];
+    readonly limit?: number;
+    readonly offset?: number;
+};
+type CoverageForRepairPlan = {
+    readonly summary?: Readonly<Record<string, number>>;
+    readonly rows?: readonly Readonly<Record<string, unknown>>[];
+};
+export declare function buildRepairPlan(payload: CoverageForRepairPlan, input: RepairPlanInput, codeSnapshot: string): RepairPlan | undefined;
+export {};
+//# sourceMappingURL=repair-plan.d.ts.map

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

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

package/dist/public/operations/repair-plan.js

@@ -0,0 +1,397 @@
+import { createHash } from "node:crypto";
+export const REPAIR_PLAN_VERSION = "kibi.repair-plan.v1";
+const REPAIR_PHASES = {
+    requirement_source: {
+        order: 5,
+        objective: "Bind the requirement to its current authored source before semantic analysis.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["required-fields", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    semantic_inventory: {
+        order: 10,
+        objective: "Produce and persist a complete source-bound proposition inventory.",
+        workflowSteps: [
+            "kb_semantic_advisor",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_check",
+        ],
+        validationRules: ["semantic-completeness", "logic-coverage"],
+        writePolicy: "analysis_then_sequential_upsert",
+    },
+    semantic_resolution: {
+        order: 20,
+        objective: "Resolve ambiguity or ontology gaps without treating unresolved prose as modeled.",
+        workflowSteps: [
+            "kb_semantic_advisor",
+            "kb_suggest_predicates",
+            "kb_model_requirement",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_check",
+        ],
+        validationRules: [
+            "semantic-completeness",
+            "logic-coverage",
+            "predicate-verifiability",
+            "rule-safety",
+            "rule-verifiability",
+        ],
+        writePolicy: "review_then_sequential_upsert",
+    },
+    ground_endpoints: {
+        order: 30,
+        objective: "Create or repair exactly one validated logical endpoint for each modeled proposition.",
+        workflowSteps: [
+            "kb_suggest_predicates",
+            "kb_model_requirement",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_check",
+        ],
+        validationRules: [
+            "strict-fact-shape",
+            "predicate-verifiability",
+            "rule-safety",
+            "rule-verifiability",
+            "logic-coverage",
+        ],
+        writePolicy: "review_then_sequential_upsert",
+    },
+    manifest_links: {
+        order: 40,
+        objective: "Persist the exact claim manifest and link it one-to-one to existing logical endpoints.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: [
+            "semantic-completeness",
+            "logic-coverage",
+            "predicate-verifiability",
+            "rule-safety",
+            "rule-verifiability",
+            "no-dangling-refs",
+        ],
+        writePolicy: "sequential_upsert",
+    },
+    contradiction_resolution: {
+        order: 50,
+        objective: "Inspect exact contradiction witnesses and supersede or reconcile conflicting requirements.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["domain-contradictions", "logic-coverage"],
+        writePolicy: "review_then_sequential_upsert",
+    },
+    scenario_endpoints: {
+        order: 60,
+        objective: "Create a scenario endpoint and link the requirement through specified_by.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["must-priority-coverage", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    scenario_tests: {
+        order: 70,
+        objective: "Create or select a test endpoint and link it through the requirement scenario.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["must-priority-coverage", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    snapshot_runtime: {
+        order: 75,
+        objective: "Use a runtime that exposes a deterministic workspace verification snapshot.",
+        workflowSteps: ["kb_status", "kb_coverage"],
+        validationRules: [],
+        writePolicy: "runtime_recovery",
+    },
+    verification_evidence: {
+        order: 80,
+        objective: "Run the scenario-backed E2E test and append a fresh snapshot-bound passing receipt.",
+        workflowSteps: [
+            "kb_status",
+            "execute_e2e",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_coverage",
+        ],
+        validationRules: ["required-fields", "no-dangling-refs"],
+        writePolicy: "execute_then_append_receipt",
+    },
+    executable_symbols: {
+        order: 90,
+        objective: "Link executable test symbols to every qualifying E2E test through executable_for.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["symbol-traceability", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    production_ownership: {
+        order: 100,
+        objective: "Link production symbols to the requirement through implements.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["symbol-traceability", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    production_coverage: {
+        order: 110,
+        objective: "Link every implementing production symbol to a qualifying E2E test through covered_by.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: [
+            "symbol-coverage",
+            "symbol-traceability",
+            "no-dangling-refs",
+        ],
+        writePolicy: "sequential_upsert",
+    },
+    source_coordinates: {
+        order: 120,
+        objective: "Refresh symbol extraction and persist exact current source coordinates.",
+        workflowSteps: [
+            "kibi sync --refresh-symbol-coordinates",
+            "kibi sync",
+            "kb_check",
+            "kb_coverage",
+        ],
+        validationRules: ["symbol-coverage", "symbol-traceability"],
+        writePolicy: "refresh_then_sync",
+    },
+    manual_review: {
+        order: 900,
+        objective: "Review the unclassified proof gap and choose a conservative repair workflow.",
+        workflowSteps: ["kb_query", "kb_check", "kb_coverage"],
+        validationRules: [],
+        writePolicy: "review_then_sequential_upsert",
+    },
+};
+const GAP_PHASE = {
+    missing_requirement_source: "requirement_source",
+    missing_semantic_inventory: "semantic_inventory",
+    incomplete_semantic_inventory: "semantic_inventory",
+    malformed_semantic_inventory: "semantic_inventory",
+    unresolved_semantic_proposition: "semantic_resolution",
+    missing_logic_grounding: "ground_endpoints",
+    ambiguous_logic_grounding: "ground_endpoints",
+    contradiction_check_incomplete: "ground_endpoints",
+    missing_logic_claims: "manifest_links",
+    logic_manifest_mismatch: "manifest_links",
+    blocking_contradiction: "contradiction_resolution",
+    missing_scenario: "scenario_endpoints",
+    missing_scenario_test: "scenario_tests",
+    verification_snapshot_unavailable: "snapshot_runtime",
+    missing_passing_e2e: "verification_evidence",
+    missing_verification_receipt: "verification_evidence",
+    stale_verification_receipt: "verification_evidence",
+    failed_verification_receipt: "verification_evidence",
+    invalid_verification_receipt: "verification_evidence",
+    missing_executable_test_symbol: "executable_symbols",
+    missing_production_symbol: "production_ownership",
+    missing_production_symbol_coverage: "production_coverage",
+    missing_symbol_coordinates: "source_coordinates",
+};
+const GAP_STAGE = {
+    missing_requirement_source: "source_coordinates",
+    missing_semantic_inventory: "semantic_inventory",
+    incomplete_semantic_inventory: "semantic_inventory",
+    malformed_semantic_inventory: "semantic_inventory",
+    unresolved_semantic_proposition: "semantic_inventory",
+    missing_logic_claims: "logic_grounding",
+    logic_manifest_mismatch: "logic_grounding",
+    missing_logic_grounding: "logic_grounding",
+    ambiguous_logic_grounding: "logic_grounding",
+    blocking_contradiction: "contradictions",
+    contradiction_check_incomplete: "contradictions",
+    missing_scenario: "scenarios",
+    missing_scenario_test: "scenario_tests",
+    missing_passing_e2e: "passing_e2e",
+    missing_verification_receipt: "passing_e2e",
+    stale_verification_receipt: "passing_e2e",
+    failed_verification_receipt: "passing_e2e",
+    invalid_verification_receipt: "passing_e2e",
+    verification_snapshot_unavailable: "passing_e2e",
+    missing_executable_test_symbol: "executable_symbols",
+    missing_production_symbol: "production_symbols",
+    missing_production_symbol_coverage: "production_symbols",
+    missing_symbol_coordinates: "source_coordinates",
+};
+const PROOF_STAGE_KEY = {
+    semantic_inventory: "semanticInventory",
+    logic_grounding: "logicGrounding",
+    contradictions: "contradictions",
+    scenarios: "scenarios",
+    scenario_tests: "scenarioTests",
+    passing_e2e: "passingE2e",
+    executable_symbols: "executableSymbols",
+    production_symbols: "productionSymbols",
+    source_coordinates: "sourceCoordinates",
+};
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== "checkedAt" && key !== "ageSeconds")
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, stableValue(item)]));
+}
+function stableStringify(value) {
+    return JSON.stringify(stableValue(value));
+}
+function numberField(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function actionForRepair(repair, phase) {
+    return typeof repair?.action === "string"
+        ? repair.action
+        : REPAIR_PHASES[phase].objective;
+}
+function stageEvidence(row, proofStage) {
+    const stages = isRecord(row.proofStages) ? row.proofStages : {};
+    const key = PROOF_STAGE_KEY[proofStage];
+    const evidence = key === undefined ? undefined : stages[key];
+    const stable = stableValue(evidence);
+    return isRecord(stable) ? stable : {};
+}
+function batchId(requirementId, phase) {
+    const order = String(REPAIR_PHASES[phase].order).padStart(3, "0");
+    const safeRequirementId = requirementId.replace(/[^A-Za-z0-9_-]/g, "-");
+    return `repair-${order}-${safeRequirementId}-${phase}`;
+}
+function buildRequirementBatches(row) {
+    const requirementId = typeof row.id === "string" ? row.id : "unknown-requirement";
+    const gaps = [...new Set(stringList(row.proofGaps))].sort();
+    const repairs = Array.isArray(row.proofRepairs)
+        ? row.proofRepairs.filter(isRecord)
+        : [];
+    const repairByGap = new Map(repairs.flatMap((repair) => typeof repair.gap === "string" ? [[repair.gap, repair]] : []));
+    const byPhase = new Map();
+    for (const gap of gaps) {
+        const phase = GAP_PHASE[gap] ?? "manual_review";
+        const sourceRepair = repairByGap.get(gap);
+        const proofStage = typeof sourceRepair?.stage === "string"
+            ? sourceRepair.stage
+            : (GAP_STAGE[gap] ?? "manual_review");
+        const repair = {
+            requirementId,
+            gap,
+            proofPriority: numberField(sourceRepair?.priority, REPAIR_PHASES[phase].order),
+            proofStage,
+            action: actionForRepair(sourceRepair, phase),
+            evidence: stageEvidence(row, proofStage),
+        };
+        const phaseRepairs = byPhase.get(phase) ?? [];
+        phaseRepairs.push(repair);
+        byPhase.set(phase, phaseRepairs);
+    }
+    const phases = [...byPhase.keys()].sort((left, right) => REPAIR_PHASES[left].order - REPAIR_PHASES[right].order ||
+        left.localeCompare(right));
+    const priorBatchIds = [];
+    return phases.map((phase) => {
+        const definition = REPAIR_PHASES[phase];
+        const id = batchId(requirementId, phase);
+        const batch = {
+            id,
+            order: definition.order,
+            phase,
+            requirementId,
+            state: priorBatchIds.length === 0 ? "ready" : "blocked",
+            dependsOn: [...priorBatchIds],
+            objective: definition.objective,
+            workflowSteps: definition.workflowSteps,
+            validationRules: definition.validationRules,
+            writePolicy: definition.writePolicy,
+            autoApplicable: false,
+            repairs: (byPhase.get(phase) ?? []).sort((left, right) => left.proofPriority - right.proofPriority ||
+                left.gap.localeCompare(right.gap)),
+        };
+        priorBatchIds.push(id);
+        return batch;
+    });
+}
+function actionableRequirementTotal(summary, fallback) {
+    const missing = summary.proofMissing;
+    const unresolved = summary.proofUnresolved;
+    if (typeof missing === "number" && typeof unresolved === "number") {
+        return Math.max(0, missing + unresolved);
+    }
+    return fallback;
+}
+export function buildRepairPlan(payload, input, codeSnapshot) {
+    const by = input.by ?? "req";
+    if (by !== "req")
+        return undefined;
+    const rows = payload.rows ?? [];
+    const requirementRows = rows.filter((row) => typeof row.id === "string" && stringList(row.proofGaps).length > 0);
+    const batches = requirementRows
+        .flatMap(buildRequirementBatches)
+        .sort((left, right) => left.order - right.order ||
+        left.requirementId.localeCompare(right.requirementId) ||
+        left.id.localeCompare(right.id));
+    const requirementCount = new Set(batches.map((batch) => batch.requirementId))
+        .size;
+    const summary = payload.summary ?? {};
+    const actionableRequirements = actionableRequirementTotal(summary, requirementCount);
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? 100;
+    const complete = offset === 0 && requirementCount >= actionableRequirements;
+    const excludedByPagination = Math.max(0, actionableRequirements - requirementCount);
+    const repairCount = batches.reduce((count, batch) => count + batch.repairs.length, 0);
+    const readyBatchCount = batches.filter((batch) => batch.state === "ready").length;
+    const blockedBatchCount = batches.length - readyBatchCount;
+    const diagnostics = complete
+        ? []
+        : [
+            `Repair plan is partial: ${excludedByPagination} actionable requirement(s) were excluded by coverage pagination; rerun with offset 0 and a larger limit.`,
+        ];
+    const planCore = {
+        version: REPAIR_PLAN_VERSION,
+        codeSnapshot,
+        scope: {
+            by,
+            tags: [...(input.tags ?? [])].sort(),
+            offset,
+            limit,
+            complete,
+            actionableRequirements,
+            returnedActionableRequirements: requirementCount,
+            excludedByPagination,
+        },
+        batches,
+    };
+    const planId = `repair-plan-${createHash("sha256")
+        .update(stableStringify(planCore))
+        .digest("hex")
+        .slice(0, 24)}`;
+    return {
+        version: REPAIR_PLAN_VERSION,
+        planId,
+        readOnly: true,
+        status: repairCount === 0 && complete
+            ? "no_repairs"
+            : complete
+                ? "ready"
+                : "partial",
+        codeSnapshot,
+        scope: planCore.scope,
+        applicationPolicy: {
+            queryBeforeMutation: true,
+            createEndpointsBeforeRelationships: true,
+            validateBeforeEachWrite: true,
+            sequentialUpsertsOnly: true,
+            recheckCoverageAfterEachBatch: true,
+        },
+        summary: {
+            requirementCount,
+            repairCount,
+            batchCount: batches.length,
+            readyBatchCount,
+            blockedBatchCount,
+        },
+        batches,
+        diagnostics,
+    };
+}

package/dist/public/operations/runtime-types.d.ts

@@ -24,7 +24,14 @@ export interface FilesystemPort {
 export interface GitPort {
     revParse(...args: readonly string[]): Promise<string>;
     showToplevel(): Promise<string>;
+    workspaceSnapshot?(workspaceRoot: string): Promise<WorkspaceSnapshot>;
 }
+export type WorkspaceSnapshot = Readonly<{
+    version: "kibi.workspace-snapshot.v1";
+    hash: string;
+    dirty: boolean;
+    fileCount: number;
+}>;
 export interface NetworkPort {
     fetch(input: string | URL, init?: RequestInit): Promise<Response>;
 }

package/dist/public/operations/runtime-types.d.ts.map

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

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

@@ -2,7 +2,7 @@ import { executeCheck } from "../check-executor.js";
 export declare const checkSpec: {
     readonly name: "kb_check";
     readonly cliName: "check";
-    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.";
+    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -12,7 +12,7 @@ export declare const checkSpec: {
                     readonly type: "string";
                     readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

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

@@ -2,7 +2,7 @@ import { executeCheck } from "../check-executor.js";
 export const checkSpec = {
     name: "kb_check",
     cliName: "check",
-    description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.",
+    description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -29,7 +29,7 @@ export const checkSpec = {
                         "query-plan-safety",
                     ],
                 },
-                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
             },
             sourceFiles: {
                 type: "array",