kibi-mcp 0.22.0 → 2.0.0

package/dist/server/session.js

@@ -18,9 +18,9 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import process from "node:process";
-import { EngineClient } from "kibi-cli/engine";
-import { PrologProcess } from "kibi-cli/prolog";
-import { copyCleanSnapshot, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, } from "kibi-cli/public/branch-resolver";
+import { EngineClient } from "kibi-runtime";
+import { PrologProcess } from "kibi-runtime";
+import { copyCleanSnapshot, ensureBranchStoreManifest, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, resolveBranchAttachment, } from "kibi-runtime";
 import { getBranchOverride, isMcpDebugEnabled } from "../env.js";
 import { resolveKbPath, resolveWorkspaceRoot } from "../workspace.js";
 import { KbRefreshError, describeBranchKbStamp, readBranchKbStamp, sameBranchKbStamp, } from "./kb-freshness.js";
@@ -32,39 +32,58 @@ const defaultSessionDeps = {
     getBranchDiagnostic,
     isValidBranchName,
     resolveActiveBranch,
+    resolveBranchAttachment,
     resolveKbPath,
     resolveWorkspaceRoot,
 };
 let sessionDeps = { ...defaultSessionDeps };
-export let prologProcess = null;
-let isInitialized = false;
-export let activeBranchName = "develop";
-let ensurePrologTail = Promise.resolve();
-let prologResetGeneration = 0;
-export let attachedBranchKbPath = null;
-let attachedBranchStamp = null;
+const state = {
+    prologProcess: null,
+    isInitialized: false,
+    activeBranchName: "develop",
+    ensurePrologTail: Promise.resolve(),
+    prologResetGeneration: 0,
+    attachedBranchKbPath: null,
+    attachedBranchStamp: null,
+    isShuttingDown: false,
+    shutdownTimeout: null,
+};
+// implements REQ-008
+export function getPrologProcess() {
+    return state.prologProcess;
+}
+// implements REQ-mcp-kb-freshness
+export function getActiveBranchName() {
+    return state.activeBranchName;
+}
+// implements REQ-008
+export function getAttachedBranchKbPath() {
+    return state.attachedBranchKbPath;
+}
+// implements REQ-008
+export function getIsShuttingDown() {
+    return state.isShuttingDown;
+}
+export const inFlightRequests = new Map();
 // implements REQ-mcp-kb-freshness
 // covered_by TEST-mcp-kb-freshness
 export function updateAttachedBranchStamp(stamp) {
-    attachedBranchStamp = stamp;
+    state.attachedBranchStamp = stamp;
 }
-export let isShuttingDown = false;
-let shutdownTimeout = null;
-export const inFlightRequests = new Map();
 // implements REQ-008
 export function resetSessionStateForTests() {
-    prologProcess = null;
-    isInitialized = false;
-    activeBranchName = "develop";
-    ensurePrologTail = Promise.resolve();
-    prologResetGeneration = 0;
-    attachedBranchKbPath = null;
-    attachedBranchStamp = null;
-    isShuttingDown = false;
+    state.prologProcess = null;
+    state.isInitialized = false;
+    state.activeBranchName = "develop";
+    state.ensurePrologTail = Promise.resolve();
+    state.prologResetGeneration = 0;
+    state.attachedBranchKbPath = null;
+    state.attachedBranchStamp = null;
+    state.isShuttingDown = false;
     inFlightRequests.clear();
-    if (shutdownTimeout) {
-        clearTimeout(shutdownTimeout);
-        shutdownTimeout = null;
+    if (state.shutdownTimeout) {
+        clearTimeout(state.shutdownTimeout);
+        state.shutdownTimeout = null;
     }
 }
 export function _setSessionDepsForTests(
@@ -76,6 +95,10 @@ export function _resetSessionDepsForTests() {
     // implements REQ-008
     sessionDeps = { ...defaultSessionDeps };
 }
+// implements REQ-008
+export function _setPrologProcessForTests(process) {
+    state.prologProcess = process;
+}
 function debugLog(...args) {
     if (isMcpDebugEnabled()) {
         console.error(...args);
@@ -90,30 +113,30 @@ export function ensureBranchKbExists(workspaceRoot, branch) {
     if (sessionDeps.fs.existsSync(branchPath)) {
         return false;
     }
-    // Try to copy from the previously active branch if available
-    const previousBranch = activeBranchName;
-    const previousBranchPath = sessionDeps.resolveKbPath(workspaceRoot, previousBranch);
-    if (previousBranch !== branch &&
-        previousBranch !== "develop" &&
-        sessionDeps.fs.existsSync(previousBranchPath)) {
-        // Copy from previous branch for continuity
-        sessionDeps.copyCleanSnapshot(previousBranchPath, branchPath);
-        debugLog(`[KIBI-MCP] Created branch KB for '${branch}' from '${previousBranch}'`);
-        return false;
+    // Branch initialization is intentionally empty. The compiled store is
+    // materialized from the current checkout's authored sources by sync; it is
+    // never copied from another branch.
+    // Unit/integration hosts can provide a virtual filesystem through the
+    // existing session dependency seam.  Only the real Node filesystem needs
+    // the identity manifest writer; virtual hosts already model the resolved
+    // branch path and should not be forced to create that path on the host.
+    if (sessionDeps.fs === fs) {
+        ensureBranchStoreManifest(workspaceRoot, branch);
+    }
+    else {
+        sessionDeps.fs.mkdirSync(branchPath, { recursive: true });
     }
-    // No previous branch available - create empty KB
-    sessionDeps.fs.mkdirSync(branchPath, { recursive: true });
     debugLog(`[KIBI-MCP] Created empty branch KB for '${branch}'`);
     return true;
 }
 export async function initiateGracefulShutdown(exitCode = 0) {
-    if (isShuttingDown) {
+    if (state.isShuttingDown) {
         return;
     }
-    isShuttingDown = true;
+    state.isShuttingDown = true;
     debugLog(`[KIBI-MCP] Initiating graceful shutdown (exit code: ${exitCode})`);
-    const currentProlog = prologProcess;
-    prologProcess = null;
+    const currentProlog = state.prologProcess;
+    state.prologProcess = null;
     if (currentProlog?.isRunning()) {
         debugLog("[KIBI-MCP] Cancelling active Prolog work...");
         try {
@@ -128,7 +151,7 @@ export async function initiateGracefulShutdown(exitCode = 0) {
     if (inFlightRequests.size > 0) {
         debugLog(`[KIBI-MCP] Waiting for ${inFlightRequests.size} in-flight requests to complete...`);
         const timeoutPromise = new Promise((_, reject) => {
-            shutdownTimeout = setTimeout(() => {
+            state.shutdownTimeout = setTimeout(() => {
                 reject(new Error("Shutdown timeout"));
             }, 10000); // 10 second timeout
         });
@@ -143,9 +166,9 @@ export async function initiateGracefulShutdown(exitCode = 0) {
             console.error("[KIBI-MCP] Shutdown timeout reached, forcing exit");
         }
         finally {
-            if (shutdownTimeout) {
-                clearTimeout(shutdownTimeout);
-                shutdownTimeout = null;
+            if (state.shutdownTimeout) {
+                clearTimeout(state.shutdownTimeout);
+                state.shutdownTimeout = null;
             }
         }
     }
@@ -155,12 +178,12 @@ export async function initiateGracefulShutdown(exitCode = 0) {
 // implements REQ-008
 export async function resetProlog(reason) {
     debugLog(`[KIBI-MCP] Resetting Prolog worker: ${reason}`);
-    prologResetGeneration += 1;
-    const current = prologProcess;
-    prologProcess = null;
-    isInitialized = false;
-    attachedBranchKbPath = null;
-    attachedBranchStamp = null;
+    state.prologResetGeneration += 1;
+    const current = state.prologProcess;
+    state.prologProcess = null;
+    state.isInitialized = false;
+    state.attachedBranchKbPath = null;
+    state.attachedBranchStamp = null;
     if (current) {
         try {
             await current.terminate();
@@ -201,14 +224,14 @@ function usesBranchKbPath(kbPath) {
 }
 // implements REQ-008
 async function ensurePrologUnsafe() {
-    const generationAtStart = prologResetGeneration;
+    const generationAtStart = state.prologResetGeneration;
     const workspaceRoot = sessionDeps.resolveWorkspaceRoot();
     const useEngine = sessionDeps.PrologProcess === defaultSessionDeps.PrologProcess;
     const assertGeneration = async () => {
-        if (generationAtStart !== prologResetGeneration) {
-            const current = prologProcess;
-            prologProcess = null;
-            isInitialized = false;
+        if (generationAtStart !== state.prologResetGeneration) {
+            const current = state.prologProcess;
+            state.prologProcess = null;
+            state.isInitialized = false;
             if (current) {
                 await current.terminate().catch((error) => {
                     console.error("[KIBI-MCP] Error terminating stale Prolog after reset generation change:", error);
@@ -228,32 +251,33 @@ async function ensurePrologUnsafe() {
         targetBranch = envBranch;
     }
     else {
-        // No override - resolve active branch from git (may change between requests)
-        const branchResult = sessionDeps.resolveActiveBranch(workspaceRoot);
+        // No override - resolve the exact Git branch, with read-compatible legacy
+        // literal-path storage detection for bridge-release repositories.
+        const branchResult = sessionDeps.resolveBranchAttachment(workspaceRoot);
         if ("error" in branchResult) {
             const diagnostic = sessionDeps.getBranchDiagnostic(undefined, branchResult.error);
             console.error(`[KIBI-MCP] ${diagnostic}`);
             throw new Error(`Failed to resolve active branch: ${branchResult.error}`);
         }
-        targetBranch = branchResult.branch;
+        targetBranch = branchResult.kbBranch;
     }
     // Check if we need to switch branches
-    if (isInitialized && useEngine && prologProcess?.isRunning()) {
+    if (state.isInitialized && useEngine && state.prologProcess?.isRunning()) {
         const kbPath = sessionDeps.resolveKbPath(workspaceRoot, targetBranch);
-        if (targetBranch === activeBranchName) {
-            attachedBranchKbPath = kbPath;
-            attachedBranchStamp = await readBranchKbStamp(kbPath);
-            return prologProcess;
+        if (targetBranch === state.activeBranchName) {
+            state.attachedBranchKbPath = kbPath;
+            state.attachedBranchStamp = await readBranchKbStamp(kbPath);
+            return state.prologProcess;
         }
-        await prologProcess.terminate();
-        prologProcess = null;
-        isInitialized = false;
-        attachedBranchKbPath = null;
-        attachedBranchStamp = null;
+        await state.prologProcess.terminate();
+        state.prologProcess = null;
+        state.isInitialized = false;
+        state.attachedBranchKbPath = null;
+        state.attachedBranchStamp = null;
     }
-    if (isInitialized && prologProcess?.isRunning()) {
+    if (state.isInitialized && state.prologProcess?.isRunning()) {
         const kbPath = sessionDeps.resolveKbPath(workspaceRoot, targetBranch);
-        if (targetBranch === activeBranchName) {
+        if (targetBranch === state.activeBranchName) {
             const currentStamp = await readBranchKbStamp(kbPath);
             if (usesBranchKbPath(kbPath) &&
                 (currentStamp.rdfMissing ||
@@ -261,29 +285,29 @@ async function ensurePrologUnsafe() {
                     currentStamp.errorMessage !== null)) {
                 throw new KbRefreshError(`KB refresh failed: branch KB snapshot is unstable: ${describeBranchKbStamp(currentStamp)}`);
             }
-            const shouldRefresh = attachedBranchKbPath === kbPath &&
-                attachedBranchStamp !== null &&
+            const shouldRefresh = state.attachedBranchKbPath === kbPath &&
+                state.attachedBranchStamp !== null &&
                 usesBranchKbPath(kbPath) &&
-                !sameBranchKbStamp(currentStamp, attachedBranchStamp);
+                !sameBranchKbStamp(currentStamp, state.attachedBranchStamp);
             if (shouldRefresh) {
-                attachedBranchStamp = await refreshAttachedBranchKbWithRetry(prologProcess, kbPath, currentStamp, assertGeneration);
+                state.attachedBranchStamp = await refreshAttachedBranchKbWithRetry(state.prologProcess, kbPath, currentStamp, assertGeneration);
             }
             else {
-                attachedBranchKbPath = kbPath;
-                attachedBranchStamp = currentStamp;
+                state.attachedBranchKbPath = kbPath;
+                state.attachedBranchStamp = currentStamp;
             }
-            attachedBranchKbPath = kbPath;
-            return prologProcess;
+            state.attachedBranchKbPath = kbPath;
+            return state.prologProcess;
         }
         // Branch changed - need to detach and re-attach
-        debugLog(`[KIBI-MCP] Branch changed: ${activeBranchName} -> ${targetBranch}`);
+        debugLog(`[KIBI-MCP] Branch changed: ${state.activeBranchName} -> ${targetBranch}`);
         // Persist and detach from old KB
-        const saveResult = await prologProcess.query("kb_save");
+        const saveResult = await state.prologProcess.query("kb_save");
         await assertGeneration();
         if (!saveResult.success) {
             throw new Error(`Failed to save old KB before detach: ${saveResult.error || "Unknown error"}`);
         }
-        const detachResult = await prologProcess.query("kb_detach");
+        const detachResult = await state.prologProcess.query("kb_detach");
         await assertGeneration();
         if (!detachResult.success) {
             debugLog(`[KIBI-MCP] Warning: failed to detach from old KB: ${detachResult.error || "Unknown error"}`);
@@ -292,100 +316,72 @@ async function ensurePrologUnsafe() {
         // Ensure new branch KB exists
         const createdEmptyBranch = ensureBranchKbExists(workspaceRoot, targetBranch);
         // Attach to new branch KB
-        const attachResult = await prologProcess.query(`kb_attach('${kbPath}')`);
+        const attachResult = await state.prologProcess.query(`kb_attach('${kbPath}')`);
         await assertGeneration();
         if (!attachResult.success) {
             throw new Error(`Failed to attach to new branch KB: ${attachResult.error || "Unknown error"}`);
         }
         if (createdEmptyBranch) {
-            const initialSaveResult = await prologProcess.query("kb_save");
+            const initialSaveResult = await state.prologProcess.query("kb_save");
             await assertGeneration();
             if (!initialSaveResult.success) {
                 throw new Error(`Failed to initialize empty branch KB: ${initialSaveResult.error || "Unknown error"}`);
             }
         }
-        activeBranchName = targetBranch;
-        attachedBranchKbPath = kbPath;
-        attachedBranchStamp = await readBranchKbStamp(kbPath);
+        state.activeBranchName = targetBranch;
+        state.attachedBranchKbPath = kbPath;
+        state.attachedBranchStamp = await readBranchKbStamp(kbPath);
         debugLog(`[KIBI-MCP] Re-attached to branch: ${targetBranch}`);
         debugLog(`[KIBI-MCP] KB path: ${kbPath}`);
-        return prologProcess;
+        return state.prologProcess;
     }
     // First initialization
     debugLog("[KIBI-MCP] Initializing Prolog process...");
-    prologProcess = useEngine
+    state.prologProcess = useEngine
         ? new EngineClient({
             workspaceRoot,
             branch: targetBranch,
             timeout: 120000,
         })
         : new sessionDeps.PrologProcess({ timeout: 120000 });
-    await prologProcess.start();
+    await state.prologProcess.start();
     await assertGeneration();
-    // Startup debug: resolve which kibi-cli is being used and its version (best-effort).
-    // Gate all output under KIBI_MCP_DEBUG and write only to stderr via debugLog.
-    if (isMcpDebugEnabled()) {
-        try {
-            const req = sessionDeps.createRequire(import.meta.url);
-            try {
-                const resolved = req.resolve("kibi-cli/prolog");
-                debugLog(`[KIBI-MCP] require.resolve('kibi-cli/prolog') -> ${resolved}`);
-            }
-            catch (resolveErr) {
-                debugLog("[KIBI-MCP] require.resolve('kibi-cli/prolog') failed:", resolveErr.message);
-            }
-            // Try to read package.json for kibi-cli to get version. This may fail if
-            // the package uses exports blocking package.json access — log explicit failure.
-            try {
-                // prefer direct package.json require; createRequire makes this ESM-friendly
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const pkg = req("kibi-cli/package.json");
-                if (pkg && typeof pkg.version === "string") {
-                    debugLog(`[KIBI-MCP] kibi-cli version: ${pkg.version}`);
-                }
-                else {
-                    debugLog("[KIBI-MCP] kibi-cli package.json read but no version field");
-                }
-            }
-            catch (pkgErr) {
-                debugLog("[KIBI-MCP] Failed to read kibi-cli package.json (exports may restrict access):", pkgErr.message);
-            }
-        }
-        catch (err) {
-            debugLog("[KIBI-MCP] Failed to create require() for debug lookup:", err.message);
-        }
-    }
+    // Adapters report the package that owns runtime execution. Do not resolve
+    // CLI implementation paths from the MCP process; the runtime package is
+    // the sole first-party execution boundary.
+    if (isMcpDebugEnabled())
+        debugLog("[KIBI-MCP] Runtime boundary: kibi-runtime");
     debugLog("[KIBI-MCP] Branch selection:");
     debugLog(`[KIBI-MCP]   KIBI_BRANCH env: ${envBranch || "not set"}`);
     debugLog(`[KIBI-MCP]   Resolved branch: ${targetBranch}`);
-    activeBranchName = targetBranch;
+    state.activeBranchName = targetBranch;
     const createdEmptyBranch = ensureBranchKbExists(workspaceRoot, targetBranch);
     const kbPath = sessionDeps.resolveKbPath(workspaceRoot, targetBranch);
     if (!useEngine) {
-        const attachResult = await prologProcess.query(`kb_attach('${kbPath}')`);
+        const attachResult = await state.prologProcess.query(`kb_attach('${kbPath}')`);
         await assertGeneration();
         if (!attachResult.success) {
             throw new Error(`Failed to attach KB: ${attachResult.error || "Unknown error"}`);
         }
         if (createdEmptyBranch) {
-            const initialSaveResult = await prologProcess.query("kb_save");
+            const initialSaveResult = await state.prologProcess.query("kb_save");
             await assertGeneration();
             if (!initialSaveResult.success) {
                 throw new Error(`Failed to initialize empty branch KB: ${initialSaveResult.error || "Unknown error"}`);
             }
         }
     }
-    attachedBranchKbPath = kbPath;
-    attachedBranchStamp = await readBranchKbStamp(kbPath);
-    isInitialized = true;
-    debugLog(`[KIBI-MCP] Prolog process started (PID: ${prologProcess.getPid()})`);
+    state.attachedBranchKbPath = kbPath;
+    state.attachedBranchStamp = await readBranchKbStamp(kbPath);
+    state.isInitialized = true;
+    debugLog(`[KIBI-MCP] Prolog process started (PID: ${state.prologProcess.getPid()})`);
     debugLog(`[KIBI-MCP] KB attached: ${kbPath}`);
-    return prologProcess;
+    return state.prologProcess;
 }
 export async function ensureProlog() {
-    const previous = ensurePrologTail;
+    const previous = state.ensurePrologTail;
     let release;
-    ensurePrologTail = new Promise((resolve) => {
+    state.ensurePrologTail = new Promise((resolve) => {
         release = resolve;
     });
     await previous;

package/dist/server/tool-registration.js

@@ -1,4 +1,6 @@
-import { getSpec } from "kibi-cli/operations";
+import { getSpec, statusSpec } from "kibi-runtime";
+import { executeApplyPlan, executeCompileIntent, executeDelete, executeIngestProof, executeUpsert, validateUpsertSpec, } from "kibi-runtime";
+import { startJob } from "./jobs.js";
 // implements REQ-002, REQ-013
 export function registerConfiguredTools(server, runtime, registerTool) {
     const toolDef = (name) => {
@@ -14,6 +16,10 @@ export function registerConfiguredTools(server, runtime, registerTool) {
         }
         return prolog;
     };
+    const withSessionProlog = (context) => ({
+        ...context,
+        prolog: prologFor(context),
+    });
     const register = ({ name, execute }) => {
         const definition = toolDef(name);
         const publicSpec = getSpec(name);
@@ -23,7 +29,7 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             requiresProlog: publicSpec.requiresProlog,
             execute: (args, context) => execute(context, args),
         };
-        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations);
+        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations, definition.outputSchema);
     };
     // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
     // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
@@ -39,7 +45,11 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_status",
-        execute: async (context, args) => runtime.handleKbStatus(prologFor(context), args, context),
+        execute: async (context, args) => 
+        // Status owns its non-mutating fallback. Do not require the session engine
+        // here: an absent or unreadable branch store is exactly the condition it
+        // must be able to describe.
+        statusSpec.execute(args, context),
     });
     register({
         name: "kb_skills_list",
@@ -75,19 +85,28 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_upsert",
-        execute: async (context, args) => runtime.handleKbUpsert(prologFor(context), args),
+        execute: async (context, args) => executeUpsert(args, withSessionProlog(context)),
     });
     register({
         name: "kb_validate_upsert",
-        execute: async (context, args) => runtime.handleKbValidateUpsert(prologFor(context), args),
+        execute: async (context, args) => validateUpsertSpec.execute(args, withSessionProlog(context)),
     });
     register({
         name: "kb_delete",
-        execute: async (context, args) => runtime.handleKbDelete(prologFor(context), args),
+        execute: async (context, args) => executeDelete(args, withSessionProlog(context)),
     });
     register({
         name: "kb_check",
-        execute: async (context, args) => runtime.handleKbCheck(prologFor(context), args),
+        execute: async (context, args) => {
+            const { async: asyncMode, ...checkArgs } = args;
+            if (asyncMode !== true) {
+                return runtime.handleKbCheck(prologFor(context), args);
+            }
+            // Long-KB full checks can exceed the tool timeout. Detach into a job
+            // and return the kibi.job.v1 receipt immediately; the agent polls
+            // kb_job_status for the terminal state and full result.
+            return startJob("kb_check", () => runtime.handleKbCheck(prologFor(context), checkArgs));
+        },
     });
     register({
         name: "kb_model_requirement",
@@ -98,7 +117,25 @@ export function registerConfiguredTools(server, runtime, registerTool) {
         execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args),
     });
     register({
-        name: "kb_autopilot_generate",
-        execute: async (context, args) => runtime.handleKbAutopilotGenerate(args, context),
+        name: "kb_plan_bootstrap",
+        execute: async (context, args) => runtime.handleKbPlanBootstrap(args, context),
+    });
+    register({
+        name: "kb_compile_intent",
+        execute: async (context, args) => runtime.handleKbCompileIntent
+            ? runtime.handleKbCompileIntent(args, context)
+            : executeCompileIntent(args, context),
+    });
+    register({
+        name: "kb_apply_plan",
+        execute: async (context, args) => runtime.handleKbApplyPlan
+            ? runtime.handleKbApplyPlan(args, context)
+            : executeApplyPlan(args, context),
+    });
+    register({
+        name: "kb_ingest_proof",
+        execute: async (context, args) => runtime.handleKbIngestProof
+            ? runtime.handleKbIngestProof(args, context)
+            : executeIngestProof(args, context),
     });
 }

package/dist/server/tools-runtime.js

@@ -1,16 +1,15 @@
-import { getSpec } from "kibi-cli/operations";
-import { nodeGit } from "kibi-cli/operations/node-ports";
+import { getSpec, nodeFilesystem, nodeGit } from "kibi-runtime";
 import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
 import { isMcpDebugEnabled } from "../env.js";
 import { createMcpRuntime } from "../runtime/mcp-runtime.js";
 import { TOOLS } from "../tools-config.js";
-import { handleKbAutopilotGenerate } from "../tools/autopilot-generate.js";
 import { handleKbCheck } from "../tools/check.js";
 import { handleKbCoverage } from "../tools/coverage.js";
 import { handleKbDelete } from "../tools/delete.js";
 import { handleKbFindGaps } from "../tools/find-gaps.js";
 import { handleKbGraph } from "../tools/graph.js";
 import { handleKbModelRequirement } from "../tools/model-requirement.js";
+import { handleKbPlanBootstrap } from "../tools/plan-bootstrap.js";
 import { handleKbQuery } from "../tools/query.js";
 import { handleKbSearch } from "../tools/search.js";
 import { handleKbSemanticAdvisor } from "../tools/semantic-advisor.js";
@@ -92,15 +91,16 @@ function adaptProlog(prolog) {
 }
 const operationRuntime = createMcpRuntime({
     workspaceRoot: resolveWorkspaceRoot(),
-    activeBranchName: async () => (await getSessionModule()).activeBranchName,
-    attachedBranchKbPath: async () => (await getSessionModule()).attachedBranchKbPath,
+    activeBranchName: async () => (await getSessionModule()).getActiveBranchName(),
+    attachedBranchKbPath: async () => (await getSessionModule()).getAttachedBranchKbPath(),
     ensureProlog: async () => (await getSessionModule()).ensureProlog(),
     adaptProlog,
+    fs: nodeFilesystem,
     git: nodeGit,
     net: { fetch: (input, init) => globalThis.fetch(input, init) },
     refreshAttachedBranchStamp: async () => {
         const session = await getSessionModule();
-        const kbPath = session.attachedBranchKbPath;
+        const kbPath = session.getAttachedBranchKbPath();
         if (kbPath) {
             try {
                 session.updateAttachedBranchStamp(await readBranchKbStamp(kbPath));
@@ -124,12 +124,12 @@ export const DEFAULT_TOOLS_RUNTIME = {
     // runtime interface with looser Record<string, unknown> inputSchema. The cast is safe
     // because the tool definitions are statically authored and validated at startup.
     tools: TOOLS,
-    activeBranchName: async () => (await getSessionModule()).activeBranchName,
+    activeBranchName: async () => (await getSessionModule()).getActiveBranchName(),
     ensureProlog: async () => (await getSessionModule()).ensureProlog(),
     resetProlog: async (reason) => (await getSessionModule()).resetProlog(reason),
     inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
-    isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
-    prologProcess: async () => (await getSessionModule()).prologProcess,
+    isShuttingDown: async () => (await getSessionModule()).getIsShuttingDown(),
+    prologProcess: async () => (await getSessionModule()).getPrologProcess(),
     operationRuntime,
     handleKbCheck,
     handleKbCoverage,
@@ -148,5 +148,5 @@ export const DEFAULT_TOOLS_RUNTIME = {
     handleKbValidateUpsert,
     handleKbModelRequirement,
     handleKbSuggestPredicates,
-    handleKbAutopilotGenerate,
+    handleKbPlanBootstrap,
 };