kibi-cli 0.19.0 → 1.0.1

package/dist/public/operations/contracts.js

@@ -0,0 +1,325 @@
+const anyValue = {};
+const recordValue = {
+    type: "object",
+    additionalProperties: true,
+};
+const recordArray = {
+    type: "array",
+    items: recordValue,
+};
+const valueArray = {
+    type: "array",
+    items: anyValue,
+};
+function objectData(properties, required = []) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        ...(required.length > 0 ? { required } : {}),
+        properties,
+    };
+}
+const stringValue = { type: "string" };
+const integerValue = { type: "integer" };
+const numberValue = { type: "number" };
+const booleanValue = { type: "boolean" };
+const stringArray = {
+    type: "array",
+    items: stringValue,
+};
+/** Preserve JSON Schema's nullable scalar/object representation in every
+ * generated consumer contract.  Using a `type` union keeps the catalog
+ * readable and lets the MCP bridge round-trip the same wire schema. */
+function nullable(schema) {
+    const type = schema.type;
+    if (typeof type === "string") {
+        return { ...schema, type: [type, "null"] };
+    }
+    return { anyOf: [schema, { type: "null" }] };
+}
+/**
+ * The data contract is deliberately maintained separately from the operation
+ * implementations.  Every catalog entry therefore has a concrete payload
+ * shape, while nested domain records can still evolve independently.
+ */
+export const OPERATION_DATA_SCHEMAS = {
+    kb_skills_list: objectData({ skills: valueArray }, ["skills"]),
+    kb_skills_load: objectData({
+        metadata: recordValue,
+        body: stringValue,
+        resources: valueArray,
+        contentHash: stringValue,
+        sourceType: stringValue,
+    }),
+    kb_skills_read: objectData({ content: stringValue }, ["content"]),
+    kb_query: objectData({ entities: recordArray, count: integerValue }, [
+        "entities",
+        "count",
+    ]),
+    kb_search: objectData({ results: valueArray, count: integerValue, queryAnalysis: recordValue }, ["results", "count"]),
+    kb_status: objectData({
+        branch: stringValue,
+        snapshotId: stringValue,
+        syncedAt: { type: ["string", "null"] },
+        dirty: booleanValue,
+        syncState: stringValue,
+        kbPath: stringValue,
+        lastSyncSource: stringValue,
+        verificationSnapshot: stringValue,
+        verificationSnapshotAvailable: booleanValue,
+        verificationSnapshotDirty: booleanValue,
+        verificationSnapshotFileCount: integerValue,
+        verificationSnapshotVersion: stringValue,
+        verificationSnapshotError: stringValue,
+        staleReasons: recordArray,
+        staleReasonCount: integerValue,
+        staleReasonsTruncated: booleanValue,
+        branchAttachment: recordValue,
+        verificationSnapshotChanges: recordArray,
+        verificationSnapshotChangeCount: integerValue,
+        verificationSnapshotChangesTruncated: booleanValue,
+        branchStore: recordValue,
+        engineStatus: recordValue,
+        schemaStatus: recordValue,
+        migrationPlan: recordValue,
+        bootstrap: recordValue,
+    }),
+    kb_find_gaps: objectData({
+        rows: recordArray,
+        count: integerValue,
+        meta: recordValue,
+    }),
+    kb_coverage: objectData({
+        summary: recordValue,
+        rows: recordArray,
+        repairPlan: recordValue,
+        legacyMigrationPlan: recordValue,
+        symbolRepairPlan: recordValue,
+        migrationPlan: recordValue,
+        meta: recordValue,
+    }),
+    kb_graph: objectData({
+        nodes: recordArray,
+        edges: recordArray,
+        truncated: booleanValue,
+        meta: recordValue,
+    }),
+    kb_sparql_remote: objectData({ rows: valueArray }, ["rows"]),
+    kb_semantic_advisor: objectData({
+        receipt: recordValue,
+        warnings: stringArray,
+    }),
+    kb_model_requirement: objectData({
+        statement: stringValue,
+        claimKey: stringValue,
+        logicClaims: stringArray,
+        source: stringValue,
+        sourceFiles: stringArray,
+        claim: recordValue,
+        writeSet: recordValue,
+        applyPlan: recordArray,
+        isStrict: booleanValue,
+        confidence: numberValue,
+        extractionMode: stringValue,
+        extractionWarnings: stringArray,
+        warnings: recordArray,
+        migrationWarning: { type: ["string", "null"] },
+        logic: recordValue,
+    }),
+    kb_suggest_predicates: objectData({
+        text: stringValue,
+        claimKey: stringValue,
+        logicClaims: stringArray,
+        source: { type: ["string", "null"] },
+        requirementId: { type: ["string", "null"] },
+        subject: stringValue,
+        candidates: recordArray,
+        recommendedAction: {
+            type: "string",
+            enum: [
+                "apply_requires_predicate",
+                "provide_argument_bindings",
+                "resolve_schema_reference",
+                "record_ontology_gap",
+            ],
+        },
+        recommendedPredicateSchema: { type: ["object", "null"] },
+        applyPlan: recordArray,
+        relationshipPlan: { type: ["object", "null"] },
+        warnings: stringArray,
+    }),
+    kb_plan_bootstrap: objectData({
+        plan: recordValue,
+        version: stringValue,
+        planHash: stringValue,
+        status: stringValue,
+        expected: recordValue,
+        activation: recordValue,
+        contextQuestions: stringArray,
+        activationState: stringValue,
+        activationMode: stringValue,
+        bootstrapMode: stringValue,
+        activationReason: stringValue,
+        applyBlocked: booleanValue,
+        migrationWarning: { type: ["string", "null"] },
+        handoffMessage: stringValue,
+        confidence: recordValue,
+        tldr: stringValue,
+        promptBlock: stringValue,
+        recommendedActions: recordArray,
+        declaredContext: recordValue,
+        discoverySummary: recordValue,
+        candidates: recordArray,
+        actions: recordArray,
+        sourceWrites: recordArray,
+        suppressedCandidates: recordArray,
+        payoffSummary: recordValue,
+        diagnostics: stringArray,
+    }, ["plan", "diagnostics"]),
+    kb_validate_upsert: objectData({
+        valid: booleanValue,
+        errors: valueArray,
+        warnings: valueArray,
+        semanticAdvisor: nullable(recordValue),
+        normalizedPreview: nullable(recordValue),
+    }),
+    kb_upsert: objectData({
+        created: integerValue,
+        updated: integerValue,
+        relationships_created: integerValue,
+        warnings: valueArray,
+        semanticAdvisor: recordValue,
+        status: stringValue,
+        effectFailures: recordArray,
+        nextActions: recordArray,
+        sourceWrites: recordArray,
+        contradictionCheck: recordValue,
+    }),
+    kb_delete: objectData({
+        deleted: integerValue,
+        relationships_deleted: integerValue,
+        skipped: integerValue,
+        errors: valueArray,
+        error_codes: valueArray,
+        relationship_results: recordArray,
+        sync_required: booleanValue,
+        sourceWrites: recordArray,
+        deletionPlan: recordValue,
+        supersessionPlan: recordValue,
+        status: stringValue,
+        effectFailures: recordArray,
+        nextActions: recordArray,
+    }),
+    kb_check: objectData({
+        violations: valueArray,
+        count: integerValue,
+        diagnostics: recordArray,
+        qualityDiagnostics: recordArray,
+        impactDiagnostics: recordArray,
+        sourceFiles: stringArray,
+        extractedSymbols: recordArray,
+        linkedEntities: recordArray,
+        nextActions: valueArray,
+        migrationPlan: recordValue,
+    }),
+    kb_compile_intent: objectData({
+        version: stringValue,
+        planHash: stringValue,
+        status: stringValue,
+        expected: recordValue,
+        target: recordValue,
+        discovery: recordValue,
+        propositions: valueArray,
+        contradictionAnalysis: recordValue,
+        proposals: valueArray,
+        steps: valueArray,
+        sourceWrites: recordArray,
+        diagnostics: stringArray,
+    }),
+    kb_apply_plan: objectData({
+        version: stringValue,
+        outcome: stringValue,
+        planHash: stringValue,
+        changedEntities: integerValue,
+        changedRelationships: integerValue,
+        changedPaths: stringArray,
+        finalSnapshots: recordValue,
+        validationSummary: recordValue,
+        recoveryJournalId: { type: ["string", "null"] },
+        deleted: integerValue,
+        sourcePaths: stringArray,
+        actionResults: recordArray,
+        notes: stringArray,
+        remainingPlan: recordValue,
+        closeout: recordValue,
+        status: stringValue,
+        effectFailures: recordArray,
+        nextActions: recordArray,
+    }),
+    kb_ingest_verification: objectData({
+        receipt: recordValue,
+        testId: stringValue,
+        proofOutcome: stringValue,
+        receiptCount: integerValue,
+        upsert: recordValue,
+        status: stringValue,
+        effectFailures: recordArray,
+        nextActions: recordArray,
+    }),
+};
+const EFFECT_OVERRIDES = {
+    kb_skills_list: {},
+    kb_skills_load: {},
+    kb_skills_read: {},
+    kb_query: {},
+    kb_search: {},
+    kb_status: {},
+    kb_find_gaps: {},
+    kb_coverage: {},
+    kb_graph: {},
+    kb_sparql_remote: { "network-read": { openWorld: true } },
+    kb_semantic_advisor: {},
+    kb_model_requirement: {},
+    kb_suggest_predicates: {},
+    kb_plan_bootstrap: {},
+    kb_validate_upsert: {},
+    kb_upsert: {
+        "kb-write": { destructive: true, retrySafety: "unsafe" },
+        "workspace-write": { destructive: true, retrySafety: "unsafe" },
+    },
+    kb_delete: {
+        "kb-write": { destructive: true, retrySafety: "unsafe" },
+        "workspace-write": { destructive: true, retrySafety: "unsafe" },
+    },
+    kb_check: {},
+    kb_compile_intent: {},
+    kb_apply_plan: {
+        "kb-write": { destructive: true, retrySafety: "unsafe" },
+        "workspace-write": { destructive: true, retrySafety: "unsafe" },
+    },
+    kb_ingest_verification: {
+        "kb-write": { destructive: true, retrySafety: "unsafe" },
+    },
+};
+export function declaredEffects(operation, effects) {
+    const overrides = EFFECT_OVERRIDES[operation];
+    if (!overrides)
+        throw new Error(`Missing effect contract for ${operation}`);
+    const expected = new Set(effects);
+    const declarations = effects.map((kind) => {
+        const override = overrides[kind] ?? {};
+        return {
+            kind,
+            mutability: kind === "kb-write" || kind === "workspace-write"
+                ? "write"
+                : "read",
+            destructive: override.destructive === true,
+            retrySafety: override.retrySafety ?? (override.destructive ? "unsafe" : "safe"),
+            openWorld: override.openWorld === true,
+        };
+    });
+    if (new Set(declarations.map(({ kind }) => kind)).size !== expected.size) {
+        throw new Error(`Duplicate effect contract for ${operation}`);
+    }
+    return declarations;
+}

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

@@ -1,4 +1,7 @@
+import { type IntentSearchAnalysis, type IntentSearchFacets, type IntentSearchMatch, type SourceLocation } from "../../intent-search.js";
 import type { SearchMatch } from "../../search-ranking.js";
+import { type BranchStoreInspection } from "../../utils/branch-store.js";
+import { type MigrationConfigStatus, type MigrationPlan } from "./migration-plan.js";
 import type { OperationContext } from "./runtime-types.js";
 import type { OperationResult } from "./types.js";
 export type QueryInput = {
@@ -18,10 +21,15 @@ export type SearchInput = {
     readonly type?: string;
     readonly limit?: number;
     readonly offset?: number;
+    readonly rankingMode?: "legacy" | "intent-v1";
+    readonly semanticFacets?: IntentSearchFacets;
+    readonly sourceLocations?: readonly SourceLocation[];
+    readonly minScore?: number;
 };
 export type SearchPayload = {
-    readonly results: readonly SearchMatch[];
+    readonly results: readonly (SearchMatch | IntentSearchMatch)[];
     readonly count: number;
+    readonly queryAnalysis?: IntentSearchAnalysis;
 };
 export type StatusInput = Readonly<Record<string, never>>;
 export type StatusPayload = {
@@ -38,6 +46,34 @@ export type StatusPayload = {
     readonly verificationSnapshotFileCount?: number;
     readonly verificationSnapshotVersion?: string;
     readonly verificationSnapshotError?: string;
+    readonly staleReasons?: readonly Record<string, unknown>[];
+    readonly staleReasonCount?: number;
+    readonly staleReasonsTruncated?: boolean;
+    readonly branchAttachment?: {
+        readonly gitBranch: string;
+        readonly kbBranch: string;
+        readonly kind: "exact" | "explicit_override" | "legacy_compat";
+        readonly migrationRequired: boolean;
+    };
+    readonly verificationSnapshotChanges?: readonly Record<string, unknown>[];
+    readonly verificationSnapshotChangeCount?: number;
+    readonly verificationSnapshotChangesTruncated?: boolean;
+    readonly branchStore?: BranchStoreInspection;
+    readonly engineStatus?: {
+        readonly state: "healthy" | "unavailable";
+        readonly errorCode?: string;
+        readonly detail?: string;
+        readonly recoveryRequired: boolean;
+    };
+    readonly schemaStatus?: MigrationConfigStatus;
+    readonly migrationPlan?: MigrationPlan;
+    readonly bootstrap?: {
+        readonly activationState: string;
+        readonly activationMode: string;
+        readonly planEligible: boolean;
+        readonly reason: string;
+        readonly nextAction?: Readonly<Record<string, unknown>>;
+    };
 };
 export declare function executeQuery(input: QueryInput, context: OperationContext): Promise<OperationResult<QueryPayload>>;
 export declare function executeSearch(input: SearchInput, context: OperationContext): Promise<OperationResult<SearchPayload>>;

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

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

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

@@ -1,6 +1,12 @@
+import { EngineClient } from "../../engine.js";
+import { executeIntentSearch, validateIntentSearchInput, } from "../../intent-search.js";
+import { classifyActivation } from "../../operations/bootstrap/activation.js";
 import { rankEntities } from "../../search-ranking.js";
+import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
+import { branchStoreReason, inspectBranchStore, } from "../../utils/branch-store.js";
 import { loadEntities, paginateResults, validateEntityType, } from "./discovery-entities.js";
-import { runOperationJsonQuery } from "./prolog-json.js";
+import { buildActionsFromStatus, readMigrationConfigStatus, } from "./migration-plan.js";
+import { OperationJsonDecodeError, runOperationJsonQuery, } from "./prolog-json.js";
 import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
 function requireProlog(context) {
     if (!context.prolog) {
@@ -75,7 +81,7 @@ export async function executeQuery(input, context) {
 }
 export async function executeSearch(input, context) {
     // implements REQ-kibi-operation-interface-parity, REQ-mcp-search-discovery
-    const { query, type, limit = 20, offset = 0 } = input;
+    const { query, type, limit = 20, offset = 0, rankingMode = "legacy", semanticFacets, sourceLocations, minScore, } = input;
     const trimmedQuery = query.trim();
     if (!trimmedQuery) {
         throw new Error("Search execution failed: query must be a non-empty string");
@@ -83,6 +89,34 @@ export async function executeSearch(input, context) {
     validateEntityType(type);
     try {
         const prolog = requireProlog(context);
+        const intentMode = rankingMode === "intent-v1" ||
+            semanticFacets !== undefined ||
+            sourceLocations !== undefined;
+        if (intentMode) {
+            const intentInput = {
+                query: trimmedQuery,
+                ...(type !== undefined ? { type } : {}),
+                ...(semanticFacets !== undefined ? { semanticFacets } : {}),
+                ...(sourceLocations !== undefined ? { sourceLocations } : {}),
+                ...(minScore !== undefined ? { minScore } : {}),
+            };
+            validateIntentSearchInput(intentInput);
+            const intentResult = await executeIntentSearch(intentInput, prolog, context.workspaceRoot);
+            const paginated = paginateResults(intentResult.matches, limit, offset);
+            const text = intentResult.matches.length === 0
+                ? `No intent search results for '${trimmedQuery}' (abstained).`
+                : `Found ${intentResult.matches.length} intent search results for '${trimmedQuery}'. Showing ${paginated.length} (offset ${offset}, limit ${limit}): ${paginated
+                    .map((match) => `${String(match.entity.id ?? "")} [${match.reasons.join(", ")}]`)
+                    .join(", ")}`;
+            return {
+                content: [{ type: "text", text }],
+                structuredContent: {
+                    results: paginated,
+                    count: intentResult.matches.length,
+                    queryAnalysis: intentResult.analysis,
+                },
+            };
+        }
         const indexedCandidates = prolog.searchEntities
             ? await prolog.searchEntities({
                 query: trimmedQuery,
@@ -118,13 +152,106 @@ export async function executeSearch(input, context) {
 export async function executeStatus(_input, context) {
     // implements REQ-kibi-operation-interface-parity, REQ-cli-status-pre-first-sync
     try {
-        const payload = await runOperationJsonQuery(requireProlog(context), "status.pl", "status:kb_status_json(JsonString)", "Status execution");
-        if (!isStatusPayload(payload)) {
-            throw new Error("Status execution query returned an invalid payload");
+        const attachment = context.branchAttachment ??
+            resolveBranchAttachment(context.workspaceRoot);
+        if ("error" in attachment) {
+            throw new Error(`Failed to resolve active branch: ${attachment.error}`);
         }
+        let payload;
+        const store = inspectBranchStore(context.workspaceRoot, attachment.kbBranch);
+        let engineStatus;
+        let ownedEngine;
+        if (store.state !== "healthy") {
+            // Status is deliberately safe before first sync and during recovery. Starting
+            // EngineClient would initialise (or attempt to repair) the store, which turns
+            // a diagnostic read into an accidental mutation.
+            payload = {
+                branch: attachment.kbBranch,
+                snapshotId: store.state === "missing" ? "missing" : "unavailable",
+                syncedAt: null,
+                dirty: true,
+                syncState: "unknown",
+                kbPath: store.path,
+                lastSyncSource: "unavailable",
+                staleReasons: [],
+                staleReasonCount: 0,
+                staleReasonsTruncated: false,
+            };
+        }
+        else
+            try {
+                const prolog = context.prolog ??
+                    (() => {
+                        ownedEngine = new EngineClient({
+                            workspaceRoot: context.workspaceRoot,
+                            branch: attachment.kbBranch,
+                            timeout: 15_000,
+                        });
+                        return ownedEngine;
+                    })();
+                payload = await runOperationJsonQuery(prolog, "status.pl", "status:kb_status_json(JsonString)", "Status execution");
+                if (!isStatusPayload(payload)) {
+                    throw new Error("Status execution query returned an invalid payload");
+                }
+                // The Prolog status module sees the compiled directory key. The public
+                // contract exposes the exact Git branch identity instead.
+                payload = { ...payload, branch: attachment.kbBranch };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                engineStatus = {
+                    state: "unavailable",
+                    errorCode: error instanceof OperationJsonDecodeError
+                        ? error.code
+                        : "engine_status_unavailable",
+                    detail: message,
+                    recoveryRequired: false,
+                };
+                payload = {
+                    branch: attachment.kbBranch,
+                    snapshotId: "unavailable",
+                    syncedAt: null,
+                    dirty: true,
+                    syncState: "unknown",
+                    kbPath: store.path,
+                    lastSyncSource: "unavailable",
+                    staleReasons: [],
+                    staleReasonCount: 0,
+                    staleReasonsTruncated: false,
+                };
+            }
+            finally {
+                await ownedEngine?.terminate();
+            }
         const snapshotEvidence = await readWorkspaceSnapshot(context);
+        const existingReasons = payload.staleReasons ?? [];
+        const storeReason = branchStoreReason(store);
+        const engineReason = engineStatus
+            ? {
+                code: engineStatus.errorCode ?? "engine_status_unavailable",
+                path: store.path,
+                entityIds: [],
+                detail: engineStatus.detail ??
+                    "The branch store is structurally readable but the engine status response is unavailable.",
+                remediation: {
+                    command_argv: ["kibi", "engine", "stop"],
+                    applyRequired: false,
+                },
+            }
+            : null;
+        const staleReasons = [
+            ...existingReasons,
+            ...(storeReason ? [storeReason] : []),
+            ...(engineReason ? [engineReason] : []),
+        ].sort((left, right) => String(left.path ?? "").localeCompare(String(right.path ?? "")));
         const enrichedPayload = {
             ...payload,
+            branchAttachment: attachment,
+            branchStore: store,
+            ...(engineStatus ? { engineStatus } : {}),
+            staleReasons,
+            staleReasonCount: staleReasons.length,
+            staleReasonsTruncated: false,
             verificationSnapshot: snapshotEvidence.available
                 ? snapshotEvidence.snapshot.hash
                 : "unknown",
@@ -134,9 +261,82 @@ export async function executeStatus(_input, context) {
                     verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
                     verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
                     verificationSnapshotVersion: snapshotEvidence.snapshot.version,
+                    verificationSnapshotChanges: snapshotEvidence.snapshot.changes ?? [],
+                    verificationSnapshotChangeCount: snapshotEvidence.snapshot.changeCount ?? 0,
+                    verificationSnapshotChangesTruncated: snapshotEvidence.snapshot.changesTruncated ?? false,
                 }
                 : { verificationSnapshotError: snapshotEvidence.error }),
         };
+        const schemaStatus = readMigrationConfigStatus(context.workspaceRoot);
+        const migrationPlan = buildActionsFromStatus({
+            workspaceRoot: context.workspaceRoot,
+            branchAttachment: attachment,
+            branchStore: store,
+            staleReasons,
+            verificationSnapshotAvailable: snapshotEvidence.available,
+            ...(snapshotEvidence.available
+                ? { verificationSnapshotDirty: snapshotEvidence.snapshot.dirty }
+                : {}),
+            kbSnapshotId: payload.snapshotId,
+            workspaceSnapshot: snapshotEvidence.available
+                ? snapshotEvidence.snapshot.hash
+                : null,
+            configStatus: schemaStatus,
+        });
+        const bootstrapSourceFiles = context.fs?.glob
+            ? await context.fs.glob([
+                ".kb/requirements/**/*.md",
+                ".kb/scenarios/**/*.md",
+                ".kb/tests/**/*.md",
+                ".kb/adrs/**/*.md",
+                ".kb/adr/**/*.md",
+                ".kb/flags/**/*.md",
+                ".kb/events/**/*.md",
+                ".kb/facts/**/*.md",
+            ], { cwd: context.workspaceRoot })
+            : [];
+        const bootstrapActivation = await classifyActivation(context, bootstrapSourceFiles);
+        const statusWithPlan = {
+            ...enrichedPayload,
+            schemaStatus,
+            migrationPlan,
+            bootstrap: {
+                activationState: bootstrapActivation.activationState,
+                activationMode: bootstrapActivation.activationMode,
+                planEligible: bootstrapActivation.activationState === "root_active_thin" &&
+                    !bootstrapActivation.applyBlocked,
+                reason: bootstrapActivation.reason,
+                nextAction: bootstrapActivation.activationState === "root_uninitialized"
+                    ? {
+                        operation: "kibi init",
+                        reason: bootstrapActivation.reason,
+                        required: true,
+                    }
+                    : bootstrapActivation.activationState === "root_partial"
+                        ? {
+                            operation: "kibi doctor",
+                            reason: bootstrapActivation.reason,
+                            required: true,
+                        }
+                        : bootstrapActivation.activationState === "vendored_only"
+                            ? {
+                                operation: "move-to-project-root",
+                                reason: bootstrapActivation.reason,
+                                required: true,
+                            }
+                            : bootstrapActivation.activationState === "root_active_thin"
+                                ? {
+                                    operation: "kb_plan_bootstrap",
+                                    reason: bootstrapActivation.reason,
+                                    required: true,
+                                }
+                                : {
+                                    operation: "continue-kibi-workflow",
+                                    reason: bootstrapActivation.reason,
+                                    required: false,
+                                },
+            },
+        };
         return {
             content: [
                 {
@@ -144,7 +344,7 @@ export async function executeStatus(_input, context) {
                     text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, verificationSnapshot=${enrichedPayload.verificationSnapshot})`,
                 },
             ],
-            structuredContent: enrichedPayload,
+            structuredContent: statusWithPlan,
         };
     }
     catch (error) {