@femtomc/mu-server 26.2.75 → 26.2.76

package/dist/api/session_turn.js

@@ -1,398 +1,58 @@
-import { createMuSession, DEFAULT_OPERATOR_SYSTEM_PROMPT, DEFAULT_ORCHESTRATOR_PROMPT, DEFAULT_REVIEWER_PROMPT, DEFAULT_WORKER_PROMPT, operatorExtensionPaths, orchestratorToolExtensionPaths, workerToolExtensionPaths, } from "@femtomc/mu-agent";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-export class SessionTurnError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-function nonEmptyString(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
+import { executeSessionTurn, parseSessionTurnRequest, SessionTurnError } from "@femtomc/mu-agent";
+import { timingSafeEqual } from "node:crypto";
+const NEOVIM_SHARED_SECRET_HEADER = "x-mu-neovim-secret";
 function asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
     }
     return value;
 }
-function normalizeSessionKind(value) {
-    if (!value) {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase().replaceAll("-", "_");
-    if (normalized === "cpoperator" || normalized === "control_plane_operator") {
-        return "cp_operator";
-    }
-    return normalized;
-}
-function normalizeExtensionProfile(value) {
-    if (!value) {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "operator" ||
-        normalized === "worker" ||
-        normalized === "orchestrator" ||
-        normalized === "reviewer" ||
-        normalized === "none") {
-        return normalized;
-    }
-    return null;
-}
-function sessionFileStem(sessionId) {
-    const normalized = sessionId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
-    const compact = normalized.replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
-    return compact.length > 0 ? compact : "session";
-}
-function resolveRepoPath(repoRoot, candidate) {
-    return isAbsolute(candidate) ? resolve(candidate) : resolve(repoRoot, candidate);
-}
-function defaultSessionDirForKind(repoRoot, sessionKind) {
-    switch (sessionKind) {
-        case "operator":
-            return join(repoRoot, ".mu", "operator", "sessions");
-        case "cp_operator":
-            return join(repoRoot, ".mu", "control-plane", "operator-sessions");
-        case "orchestrator":
-            return join(repoRoot, ".mu", "orchestrator", "sessions");
-        case "worker":
-            return join(repoRoot, ".mu", "worker", "sessions");
-        case "reviewer":
-            return join(repoRoot, ".mu", "reviewer", "sessions");
-        default:
-            return join(repoRoot, ".mu", "control-plane", "operator-sessions");
-    }
-}
-async function pathExists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch {
+function secureSecretEqual(expected, provided) {
+    const expectedBuf = Buffer.from(expected, "utf8");
+    const providedBuf = Buffer.from(provided, "utf8");
+    if (expectedBuf.length !== providedBuf.length) {
         return false;
     }
+    return timingSafeEqual(expectedBuf, providedBuf);
 }
-async function directoryExists(path) {
-    try {
-        const info = await stat(path);
-        return info.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function readSessionHeaderId(sessionFile) {
-    let raw;
-    try {
-        raw = await readFile(sessionFile, "utf8");
-    }
-    catch {
-        return null;
-    }
-    const firstLine = raw
-        .split("\n")
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
-    if (!firstLine) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(firstLine);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            return null;
-        }
-        const header = parsed;
-        if (header.type !== "session") {
-            return null;
-        }
-        return nonEmptyString(header.id);
-    }
-    catch {
-        return null;
-    }
-}
-async function resolveSessionFileById(opts) {
-    const direct = join(opts.sessionDir, `${sessionFileStem(opts.sessionId)}.jsonl`);
-    if (await pathExists(direct)) {
-        const headerId = await readSessionHeaderId(direct);
-        if (headerId === opts.sessionId) {
-            return direct;
-        }
-    }
-    const entries = await readdir(opts.sessionDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
-            continue;
-        }
-        const filePath = join(opts.sessionDir, entry.name);
-        if (filePath === direct) {
-            continue;
-        }
-        const headerId = await readSessionHeaderId(filePath);
-        if (headerId === opts.sessionId) {
-            return filePath;
-        }
-    }
-    return null;
-}
-function extensionPathsForTurn(opts) {
-    if (opts.extensionProfile === "none") {
-        return [];
-    }
-    if (opts.extensionProfile === "operator") {
-        return [...operatorExtensionPaths];
-    }
-    if (opts.extensionProfile === "orchestrator") {
-        return [...orchestratorToolExtensionPaths];
-    }
-    if (opts.extensionProfile === "worker" || opts.extensionProfile === "reviewer") {
-        return [...workerToolExtensionPaths];
-    }
-    if (opts.sessionKind === "operator" || opts.sessionKind === "cp_operator") {
-        return [...operatorExtensionPaths];
-    }
-    if (opts.sessionKind === "orchestrator") {
-        return [...orchestratorToolExtensionPaths];
-    }
-    if (opts.sessionKind === "worker" || opts.sessionKind === "reviewer") {
-        return [...workerToolExtensionPaths];
-    }
-    return [...operatorExtensionPaths];
-}
-function systemPromptForTurn(opts) {
-    const role = opts.extensionProfile ?? opts.sessionKind;
-    if (role === "operator" || role === "cp_operator") {
-        return DEFAULT_OPERATOR_SYSTEM_PROMPT;
-    }
-    if (role === "orchestrator") {
-        return DEFAULT_ORCHESTRATOR_PROMPT;
-    }
-    if (role === "reviewer") {
-        return DEFAULT_REVIEWER_PROMPT;
-    }
-    if (role === "worker") {
-        return DEFAULT_WORKER_PROMPT;
-    }
-    return undefined;
-}
-function extractAssistantText(message) {
-    if (!message || typeof message !== "object") {
-        return "";
-    }
-    const record = message;
-    if (typeof record.text === "string") {
-        return record.text;
-    }
-    if (typeof record.content === "string") {
-        return record.content;
-    }
-    if (Array.isArray(record.content)) {
-        const parts = [];
-        for (const item of record.content) {
-            if (typeof item === "string") {
-                if (item.trim().length > 0) {
-                    parts.push(item);
-                }
-                continue;
-            }
-            if (!item || typeof item !== "object") {
-                continue;
-            }
-            const text = nonEmptyString(item.text);
-            if (text) {
-                parts.push(text);
-            }
-        }
-        return parts.join("\n");
-    }
-    return "";
-}
-function safeLeafId(session) {
-    const manager = session.sessionManager;
-    if (!manager || typeof manager.getLeafId !== "function") {
-        return null;
-    }
-    const value = manager.getLeafId();
-    return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-function safeSessionId(session) {
-    const value = session.sessionId;
-    return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-function safeSessionFile(session) {
-    const value = session.sessionFile;
-    return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-async function resolveSessionTarget(opts) {
-    const sessionDir = opts.request.session_dir
-        ? resolveRepoPath(opts.repoRoot, opts.request.session_dir)
-        : defaultSessionDirForKind(opts.repoRoot, opts.normalizedSessionKind);
-    if (opts.request.session_file) {
-        const sessionFile = resolveRepoPath(opts.repoRoot, opts.request.session_file);
-        if (!(await pathExists(sessionFile))) {
-            throw new SessionTurnError(404, `session_file not found: ${sessionFile}`);
-        }
-        const headerId = await readSessionHeaderId(sessionFile);
-        if (!headerId) {
-            throw new SessionTurnError(400, `session_file is missing a valid session header: ${sessionFile}`);
-        }
-        if (headerId !== opts.request.session_id) {
-            throw new SessionTurnError(409, `session_file header id mismatch (expected ${opts.request.session_id}, found ${headerId})`);
-        }
+async function verifySessionTurnAuth(request, deps) {
+    const config = await deps.loadConfigFromDisk();
+    const expected = config.control_plane.adapters.neovim.shared_secret?.trim() ?? "";
+    if (expected.length === 0) {
         return {
-            sessionFile,
-            sessionDir: opts.request.session_dir ? sessionDir : dirname(sessionFile),
+            ok: false,
+            status: 503,
+            error: "neovim shared secret is not configured",
         };
     }
-    if (!(await directoryExists(sessionDir))) {
-        throw new SessionTurnError(404, `session directory not found: ${sessionDir}`);
-    }
-    const sessionFile = await resolveSessionFileById({
-        sessionDir,
-        sessionId: opts.request.session_id,
-    });
-    if (!sessionFile) {
-        throw new SessionTurnError(404, `session_id not found in ${sessionDir}: ${opts.request.session_id}`);
-    }
-    return { sessionFile, sessionDir };
-}
-export function parseSessionTurnRequest(body) {
-    const sessionId = nonEmptyString(body.session_id);
-    if (!sessionId) {
-        return { request: null, error: "session_id is required" };
-    }
-    const messageBody = nonEmptyString(body.body) ?? nonEmptyString(body.message) ?? nonEmptyString(body.prompt);
-    if (!messageBody) {
-        return { request: null, error: "body (or message/prompt) is required" };
-    }
-    const extensionProfileRaw = nonEmptyString(body.extension_profile);
-    if (extensionProfileRaw && !normalizeExtensionProfile(extensionProfileRaw)) {
+    const provided = request.headers.get(NEOVIM_SHARED_SECRET_HEADER)?.trim() ?? "";
+    if (provided.length === 0) {
         return {
-            request: null,
-            error: "extension_profile must be one of operator|worker|orchestrator|reviewer|none",
+            ok: false,
+            status: 401,
+            error: `missing ${NEOVIM_SHARED_SECRET_HEADER} header`,
         };
     }
-    return {
-        request: {
-            session_id: sessionId,
-            session_kind: nonEmptyString(body.session_kind),
-            body: messageBody,
-            source: nonEmptyString(body.source),
-            provider: nonEmptyString(body.provider),
-            model: nonEmptyString(body.model),
-            thinking: nonEmptyString(body.thinking),
-            session_file: nonEmptyString(body.session_file),
-            session_dir: nonEmptyString(body.session_dir),
-            extension_profile: extensionProfileRaw,
-        },
-        error: null,
-    };
-}
-export async function executeSessionTurn(opts) {
-    const normalizedSessionKind = normalizeSessionKind(opts.request.session_kind);
-    const extensionProfile = normalizeExtensionProfile(opts.request.extension_profile);
-    const target = await resolveSessionTarget({
-        repoRoot: opts.repoRoot,
-        request: opts.request,
-        normalizedSessionKind,
-    });
-    const sessionFactory = opts.sessionFactory ?? createMuSession;
-    const session = await sessionFactory({
-        cwd: opts.repoRoot,
-        systemPrompt: systemPromptForTurn({
-            sessionKind: normalizedSessionKind,
-            extensionProfile,
-        }),
-        provider: opts.request.provider ?? undefined,
-        model: opts.request.model ?? undefined,
-        thinking: opts.request.thinking ?? undefined,
-        extensionPaths: extensionPathsForTurn({
-            sessionKind: normalizedSessionKind,
-            extensionProfile,
-        }),
-        session: {
-            mode: "open",
-            sessionDir: target.sessionDir,
-            sessionFile: target.sessionFile,
-        },
-    });
-    let assistantText = "";
-    let contextEntryId = null;
-    let resolvedSessionId = null;
-    let resolvedSessionFile = null;
-    const nowMs = opts.nowMs ?? Date.now;
-    try {
-        await session.bindExtensions({
-            commandContextActions: {
-                waitForIdle: () => session.agent.waitForIdle(),
-                newSession: async () => ({ cancelled: true }),
-                fork: async () => ({ cancelled: true }),
-                navigateTree: async () => ({ cancelled: true }),
-                switchSession: async () => ({ cancelled: true }),
-                reload: async () => { },
-            },
-            onError: () => { },
-        });
-        const unsubscribe = session.subscribe((event) => {
-            const rec = asRecord(event);
-            if (!rec || rec.type !== "message_end") {
-                return;
-            }
-            const message = asRecord(rec.message);
-            if (!message || message.role !== "assistant") {
-                return;
-            }
-            const text = extractAssistantText(message);
-            if (text.trim().length > 0) {
-                assistantText = text;
-            }
-        });
-        try {
-            await session.prompt(opts.request.body, { expandPromptTemplates: false });
-            await session.agent.waitForIdle();
-        }
-        finally {
-            unsubscribe();
-        }
-        contextEntryId = safeLeafId(session);
-        resolvedSessionId = safeSessionId(session) ?? opts.request.session_id;
-        resolvedSessionFile = safeSessionFile(session) ?? target.sessionFile;
-    }
-    finally {
-        try {
-            session.dispose();
-        }
-        catch {
-            // Best effort cleanup.
-        }
-    }
-    const reply = assistantText.trim();
-    if (reply.length === 0) {
-        throw new SessionTurnError(502, "session turn completed without an assistant reply");
+    if (!secureSecretEqual(expected, provided)) {
+        return {
+            ok: false,
+            status: 401,
+            error: `invalid ${NEOVIM_SHARED_SECRET_HEADER}`,
+        };
     }
-    return {
-        session_id: resolvedSessionId ?? opts.request.session_id,
-        session_kind: normalizedSessionKind,
-        session_file: resolvedSessionFile ?? target.sessionFile,
-        context_entry_id: contextEntryId,
-        reply,
-        source: opts.request.source ?? null,
-        completed_at_ms: Math.trunc(nowMs()),
-    };
+    return { ok: true };
 }
 export async function sessionTurnRoutes(request, url, deps, headers) {
-    if (url.pathname !== "/api/session-turn") {
+    if (url.pathname !== "/api/control-plane/turn") {
         return Response.json({ error: "Not Found" }, { status: 404, headers });
     }
     if (request.method !== "POST") {
         return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
     }
+    const auth = await verifySessionTurnAuth(request, deps);
+    if (!auth.ok) {
+        return Response.json({ error: auth.error }, { status: auth.status, headers });
+    }
     let body;
     try {
         const parsed = (await request.json());

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { findRepoRoot } from "@femtomc/mu-core/node";
+import { findRepoRoot, getStorePaths } from "@femtomc/mu-core/node";
 import { composeServerRuntime, createServerFromRuntime } from "./server.js";
 // Parse CLI flags: --port N, --repo-root PATH
 function parseArgs(argv) {
@@ -30,11 +30,11 @@ try {
     repoRoot = args.repoRoot ?? findRepoRoot();
 }
 catch {
-    console.error("Error: Could not find .mu directory. Run 'mu serve' or 'mu run' once to initialize it.");
+    console.error("Error: Could not resolve a repository root for mu server startup.");
     process.exit(1);
 }
 const port = args.port;
-const discoveryPath = join(repoRoot, ".mu", "control-plane", "server.json");
+const discoveryPath = join(getStorePaths(repoRoot).storeDir, "control-plane", "server.json");
 console.log(`Starting mu-server on port ${port}...`);
 console.log(`Repository root: ${repoRoot}`);
 const runtime = await composeServerRuntime({ repoRoot });
@@ -86,7 +86,7 @@ if (runtime.controlPlane && runtime.controlPlane.activeAdapters.length > 0) {
 }
 else {
     console.log(`Health check: http://localhost:${port}/healthz`);
-    console.log(`API Status: http://localhost:${port}/api/status`);
+    console.log(`API Status: http://localhost:${port}/api/control-plane/status`);
 }
 const cleanup = async () => {
     try {

package/dist/config.d.ts

@@ -22,6 +22,11 @@ export type MuConfig = {
             run_triggers_enabled: boolean;
             provider: string | null;
             model: string | null;
+            thinking: string | null;
+        };
+        memory_index: {
+            enabled: boolean;
+            every_ms: number;
         };
     };
 };
@@ -48,6 +53,11 @@ export type MuConfigPatch = {
             run_triggers_enabled?: boolean;
             provider?: string | null;
             model?: string | null;
+            thinking?: string | null;
+        };
+        memory_index?: {
+            enabled?: boolean;
+            every_ms?: number;
         };
     };
 };
@@ -74,6 +84,11 @@ export type MuConfigPresence = {
             run_triggers_enabled: boolean;
             provider: boolean;
             model: boolean;
+            thinking: boolean;
+        };
+        memory_index: {
+            enabled: boolean;
+            every_ms: number;
         };
     };
 };

package/dist/config.js

@@ -1,3 +1,4 @@
+import { getStorePaths } from "@femtomc/mu-core/node";
 import { chmod, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 export const DEFAULT_MU_CONFIG = {
@@ -24,6 +25,11 @@ export const DEFAULT_MU_CONFIG = {
             run_triggers_enabled: true,
             provider: null,
             model: null,
+            thinking: null,
+        },
+        memory_index: {
+            enabled: true,
+            every_ms: 300_000,
         },
     },
 };
@@ -56,6 +62,21 @@ function normalizeBoolean(value, fallback) {
     }
     return fallback;
 }
+function normalizeInteger(value, fallback, opts = {}) {
+    const min = opts.min ?? Number.NEGATIVE_INFINITY;
+    const max = opts.max ?? Number.POSITIVE_INFINITY;
+    const clamp = (next) => Math.min(max, Math.max(min, Math.trunc(next)));
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return clamp(value);
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed)) {
+            return clamp(parsed);
+        }
+    }
+    return clamp(fallback);
+}
 export function normalizeMuConfig(input) {
     const next = cloneDefault();
     const root = asRecord(input);
@@ -105,6 +126,18 @@ export function normalizeMuConfig(input) {
         if ("model" in operator) {
             next.control_plane.operator.model = normalizeNullableString(operator.model);
         }
+        if ("thinking" in operator) {
+            next.control_plane.operator.thinking = normalizeNullableString(operator.thinking);
+        }
+    }
+    const memoryIndex = asRecord(controlPlane.memory_index);
+    if (memoryIndex) {
+        if ("enabled" in memoryIndex) {
+            next.control_plane.memory_index.enabled = normalizeBoolean(memoryIndex.enabled, next.control_plane.memory_index.enabled);
+        }
+        if ("every_ms" in memoryIndex) {
+            next.control_plane.memory_index.every_ms = normalizeInteger(memoryIndex.every_ms, next.control_plane.memory_index.every_ms, { min: 1_000, max: 86_400_000 });
+        }
     }
     return next;
 }
@@ -174,10 +207,29 @@ function normalizeMuConfigPatch(input) {
         if ("model" in operator) {
             patch.control_plane.operator.model = normalizeNullableString(operator.model);
         }
+        if ("thinking" in operator) {
+            patch.control_plane.operator.thinking = normalizeNullableString(operator.thinking);
+        }
         if (Object.keys(patch.control_plane.operator).length === 0) {
             delete patch.control_plane.operator;
         }
     }
+    const memoryIndex = asRecord(controlPlane.memory_index);
+    if (memoryIndex) {
+        const memoryIndexPatch = {};
+        if ("enabled" in memoryIndex) {
+            memoryIndexPatch.enabled = normalizeBoolean(memoryIndex.enabled, DEFAULT_MU_CONFIG.control_plane.memory_index.enabled);
+        }
+        if ("every_ms" in memoryIndex) {
+            memoryIndexPatch.every_ms = normalizeInteger(memoryIndex.every_ms, DEFAULT_MU_CONFIG.control_plane.memory_index.every_ms, {
+                min: 1_000,
+                max: 86_400_000,
+            });
+        }
+        if (Object.keys(memoryIndexPatch).length > 0) {
+            patch.control_plane.memory_index = memoryIndexPatch;
+        }
+    }
     if (patch.control_plane.adapters && Object.keys(patch.control_plane.adapters).length === 0) {
         delete patch.control_plane.adapters;
     }
@@ -229,11 +281,23 @@ export function applyMuConfigPatch(base, patchInput) {
         if ("model" in operator) {
             next.control_plane.operator.model = operator.model ?? null;
         }
+        if ("thinking" in operator) {
+            next.control_plane.operator.thinking = operator.thinking ?? null;
+        }
+    }
+    const memoryIndex = patch.control_plane.memory_index;
+    if (memoryIndex) {
+        if ("enabled" in memoryIndex && typeof memoryIndex.enabled === "boolean") {
+            next.control_plane.memory_index.enabled = memoryIndex.enabled;
+        }
+        if ("every_ms" in memoryIndex && typeof memoryIndex.every_ms === "number" && Number.isFinite(memoryIndex.every_ms)) {
+            next.control_plane.memory_index.every_ms = normalizeInteger(memoryIndex.every_ms, next.control_plane.memory_index.every_ms, { min: 1_000, max: 86_400_000 });
+        }
     }
     return next;
 }
 export function getMuConfigPath(repoRoot) {
-    return join(repoRoot, ".mu", "config.json");
+    return join(getStorePaths(repoRoot).storeDir, "config.json");
 }
 export async function readMuConfigFile(repoRoot) {
     const path = getMuConfigPath(repoRoot);
@@ -303,6 +367,11 @@ export function muConfigPresence(config) {
                 run_triggers_enabled: config.control_plane.operator.run_triggers_enabled,
                 provider: isPresent(config.control_plane.operator.provider),
                 model: isPresent(config.control_plane.operator.model),
+                thinking: isPresent(config.control_plane.operator.thinking),
+            },
+            memory_index: {
+                enabled: config.control_plane.memory_index.enabled,
+                every_ms: config.control_plane.memory_index.every_ms,
             },
         },
     };

package/dist/control_plane.js

@@ -421,7 +421,7 @@ export async function bootstrapControlPlane(opts) {
                 deliver: async (record) => {
                     const telegramBotToken = telegramManager.activeBotToken();
                     if (!telegramBotToken) {
-                        return { kind: "retry", error: "telegram bot token not configured in .mu/config.json" };
+                        return { kind: "retry", error: "telegram bot token not configured in mu workspace config" };
                     }
                     const richPayload = buildTelegramSendMessagePayload({
                         chatId: record.envelope.channel_conversation_id,

package/dist/control_plane_bootstrap_helpers.js

@@ -1,6 +1,6 @@
 import { ApprovedCommandBroker, CommandContextResolver, JsonFileConversationSessionStore, MessagingOperatorRuntime, operatorExtensionPaths, PiMessagingOperatorBackend, } from "@femtomc/mu-agent";
+import { ControlPlaneOutboxDispatcher, getControlPlanePaths, } from "@femtomc/mu-control-plane";
 import { join } from "node:path";
-import { ControlPlaneOutboxDispatcher, } from "@femtomc/mu-control-plane";
 const OUTBOX_DRAIN_INTERVAL_MS = 500;
 export function buildMessagingOperatorRuntime(opts) {
     if (!opts.config.operator.enabled) {
@@ -10,9 +10,10 @@ export function buildMessagingOperatorRuntime(opts) {
         new PiMessagingOperatorBackend({
             provider: opts.config.operator.provider ?? undefined,
             model: opts.config.operator.model ?? undefined,
+            thinking: opts.config.operator.thinking ?? undefined,
             extensionPaths: operatorExtensionPaths,
         });
-    const conversationSessionStore = new JsonFileConversationSessionStore(join(opts.repoRoot, ".mu", "control-plane", "operator_conversations.json"));
+    const conversationSessionStore = new JsonFileConversationSessionStore(join(getControlPlanePaths(opts.repoRoot).controlPlaneDir, "operator_conversations.json"));
     return new MessagingOperatorRuntime({
         backend,
         broker: new ApprovedCommandBroker({

package/dist/control_plane_contract.d.ts

@@ -136,7 +136,7 @@ export type ControlPlaneHandle = {
     getRun?(idOrRoot: string): Promise<ControlPlaneRunSnapshot | null>;
     /**
      * Run lifecycle boundary: accepts start intent into the default queue/reconcile path.
-     * Compatibility adapters may dispatch immediately after enqueue, but must preserve queue invariants.
+     * Queue coordinators may dispatch immediately after enqueue, but must preserve queue invariants.
      */
     startRun?(opts: {
         prompt: string;

package/dist/cron_programs.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { FsJsonlStore } from "@femtomc/mu-core/node";
+import { FsJsonlStore, getStorePaths } from "@femtomc/mu-core/node";
 import { computeNextScheduleRunAtMs, normalizeCronSchedule } from "./cron_schedule.js";
 import { CronTimerRegistry } from "./cron_timer.js";
 const CRON_PROGRAMS_FILENAME = "cron.jsonl";
@@ -86,7 +86,8 @@ export class CronProgramRegistry {
         this.#nowMs = opts.nowMs ?? defaultNowMs;
         this.#timer = opts.timer ?? new CronTimerRegistry({ nowMs: this.#nowMs });
         this.#store =
-            opts.store ?? new FsJsonlStore(join(opts.repoRoot, ".mu", CRON_PROGRAMS_FILENAME));
+            opts.store ??
+                new FsJsonlStore(join(getStorePaths(opts.repoRoot).storeDir, CRON_PROGRAMS_FILENAME));
         void this.#ensureLoaded().catch(() => {
             // Best effort eager load for startup re-arming.
         });