@femtomc/mu-agent 26.2.72 → 26.2.74

package/dist/operator.js

@@ -1,5 +1,6 @@
-import { appendJsonl } from "@femtomc/mu-core/node";
-import { join } from "node:path";
+import { appendJsonl, readJsonl } from "@femtomc/mu-core/node";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { z } from "zod";
 import { CommandContextResolver } from "./command_context.js";
 import { createMuSession } from "./session_factory.js";
@@ -182,6 +183,179 @@ function buildOperatorFailureFallbackMessage(code) {
 function conversationKey(inbound, binding) {
     return `${inbound.channel}:${inbound.channel_tenant_id}:${inbound.channel_conversation_id}:${binding.binding_id}`;
 }
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function finiteInt(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    return Math.trunc(value);
+}
+function stringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        const parsed = nonEmptyString(item);
+        if (parsed) {
+            out.push(parsed);
+        }
+    }
+    return out;
+}
+function sessionFlashPath(repoRoot) {
+    return join(repoRoot, ".mu", "control-plane", "session_flash.jsonl");
+}
+async function loadPendingSessionFlashes(opts) {
+    const rows = await readJsonl(sessionFlashPath(opts.repoRoot));
+    const created = new Map();
+    const delivered = new Set();
+    for (const row of rows) {
+        const rec = asRecord(row);
+        if (!rec) {
+            continue;
+        }
+        const kind = nonEmptyString(rec.kind);
+        if (kind === "session_flash.create") {
+            const tsMs = finiteInt(rec.ts_ms) ?? Date.now();
+            const flashId = nonEmptyString(rec.flash_id);
+            const sessionId = nonEmptyString(rec.session_id);
+            const body = nonEmptyString(rec.body);
+            if (!flashId || !sessionId || !body || sessionId !== opts.sessionId) {
+                continue;
+            }
+            created.set(flashId, {
+                flash_id: flashId,
+                created_at_ms: tsMs,
+                session_id: sessionId,
+                session_kind: nonEmptyString(rec.session_kind),
+                body,
+                context_ids: stringList(rec.context_ids),
+                source: nonEmptyString(rec.source),
+                metadata: asRecord(rec.metadata) ?? {},
+            });
+            continue;
+        }
+        if (kind === "session_flash.delivery") {
+            const flashId = nonEmptyString(rec.flash_id);
+            const sessionId = nonEmptyString(rec.session_id);
+            if (!flashId || !sessionId || sessionId !== opts.sessionId) {
+                continue;
+            }
+            delivered.add(flashId);
+        }
+    }
+    const pending = [...created.values()]
+        .filter((row) => !delivered.has(row.flash_id))
+        .sort((a, b) => a.created_at_ms - b.created_at_ms);
+    const limit = Math.max(1, Math.trunc(opts.limit ?? 16));
+    if (pending.length <= limit) {
+        return pending;
+    }
+    return pending.slice(pending.length - limit);
+}
+async function markSessionFlashesDelivered(opts) {
+    if (opts.flashIds.length === 0) {
+        return;
+    }
+    const deduped = [...new Set(opts.flashIds.filter((id) => id.trim().length > 0))];
+    for (const flashId of deduped) {
+        const row = {
+            kind: "session_flash.delivery",
+            ts_ms: opts.nowMs,
+            flash_id: flashId,
+            session_id: opts.sessionId,
+            delivered_by: "messaging_operator_runtime",
+            note: null,
+        };
+        await appendJsonl(sessionFlashPath(opts.repoRoot), row);
+    }
+}
+export class JsonFileConversationSessionStore {
+    #path;
+    #loaded = false;
+    #bindings = new Map();
+    #persistQueue = Promise.resolve();
+    constructor(path) {
+        this.#path = path;
+    }
+    async #load() {
+        if (this.#loaded) {
+            return;
+        }
+        this.#loaded = true;
+        let raw = "";
+        try {
+            raw = await readFile(this.#path, "utf8");
+        }
+        catch {
+            return;
+        }
+        if (!raw.trim()) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            const bindings = parsed?.bindings;
+            if (!bindings || typeof bindings !== "object" || Array.isArray(bindings)) {
+                return;
+            }
+            for (const [key, value] of Object.entries(bindings)) {
+                if (typeof key === "string" && key.length > 0 && typeof value === "string" && value.length > 0) {
+                    this.#bindings.set(key, value);
+                }
+            }
+        }
+        catch {
+            // Ignore malformed persistence snapshots.
+        }
+    }
+    async #persist() {
+        const snapshot = {
+            version: 1,
+            bindings: Object.fromEntries([...this.#bindings.entries()].sort(([a], [b]) => a.localeCompare(b))),
+        };
+        await mkdir(dirname(this.#path), { recursive: true });
+        const tempPath = `${this.#path}.tmp-${process.pid}-${crypto.randomUUID()}`;
+        await writeFile(tempPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+        await rename(tempPath, this.#path);
+    }
+    async #persistSoon() {
+        const runPersist = async () => {
+            await this.#persist();
+        };
+        this.#persistQueue = this.#persistQueue.then(runPersist, runPersist);
+        await this.#persistQueue;
+    }
+    async getSessionId(conversationKey) {
+        await this.#load();
+        return this.#bindings.get(conversationKey) ?? null;
+    }
+    async setSessionId(conversationKey, sessionId) {
+        await this.#load();
+        const current = this.#bindings.get(conversationKey);
+        if (current === sessionId) {
+            return;
+        }
+        this.#bindings.set(conversationKey, sessionId);
+        await this.#persistSoon();
+    }
+    async stop() {
+        await this.#persistQueue;
+    }
+}
 export class MessagingOperatorRuntime {
     #backend;
     #broker;
@@ -189,6 +363,7 @@ export class MessagingOperatorRuntime {
     #enabledChannels;
     #sessionIdFactory;
     #turnIdFactory;
+    #conversationSessionStore;
     #sessionByConversation = new Map();
     constructor(opts) {
         this.#backend = opts.backend;
@@ -197,19 +372,40 @@ export class MessagingOperatorRuntime {
         this.#enabledChannels = opts.enabledChannels ? new Set(opts.enabledChannels.map((v) => v.toLowerCase())) : null;
         this.#sessionIdFactory = opts.sessionIdFactory ?? defaultSessionId;
         this.#turnIdFactory = opts.turnIdFactory ?? defaultTurnId;
+        this.#conversationSessionStore = opts.conversationSessionStore ?? null;
     }
-    #resolveSessionId(inbound, binding) {
+    async #resolveSessionId(inbound, binding) {
         const key = conversationKey(inbound, binding);
         const existing = this.#sessionByConversation.get(key);
         if (existing) {
             return existing;
         }
+        if (this.#conversationSessionStore) {
+            try {
+                const persisted = await this.#conversationSessionStore.getSessionId(key);
+                if (persisted && persisted.length > 0) {
+                    this.#sessionByConversation.set(key, persisted);
+                    return persisted;
+                }
+            }
+            catch {
+                // Non-fatal persistence lookup failure.
+            }
+        }
         const created = this.#sessionIdFactory();
         this.#sessionByConversation.set(key, created);
+        if (this.#conversationSessionStore) {
+            try {
+                await this.#conversationSessionStore.setSessionId(key, created);
+            }
+            catch {
+                // Non-fatal persistence write failure.
+            }
+        }
         return created;
     }
     async handleInbound(opts) {
-        const sessionId = this.#resolveSessionId(opts.inbound, opts.binding);
+        const sessionId = await this.#resolveSessionId(opts.inbound, opts.binding);
         const turnId = this.#turnIdFactory();
         if (!this.#enabled) {
             return {
@@ -227,14 +423,46 @@ export class MessagingOperatorRuntime {
                 operatorTurnId: turnId,
             };
         }
+        let pendingFlashes = [];
+        try {
+            pendingFlashes = await loadPendingSessionFlashes({
+                repoRoot: opts.inbound.repo_root,
+                sessionId,
+            });
+        }
+        catch {
+            pendingFlashes = [];
+        }
+        const inboundForBackend = pendingFlashes.length > 0
+            ? {
+                ...opts.inbound,
+                metadata: {
+                    ...opts.inbound.metadata,
+                    session_flash_messages: pendingFlashes,
+                },
+            }
+            : opts.inbound;
         let backendResult;
         try {
             backendResult = OperatorBackendTurnResultSchema.parse(await this.#backend.runTurn({
                 sessionId,
                 turnId,
-                inbound: opts.inbound,
+                inbound: inboundForBackend,
                 binding: opts.binding,
             }));
+            if (pendingFlashes.length > 0) {
+                try {
+                    await markSessionFlashesDelivered({
+                        repoRoot: opts.inbound.repo_root,
+                        sessionId,
+                        flashIds: pendingFlashes.map((row) => row.flash_id),
+                        nowMs: Date.now(),
+                    });
+                }
+                catch {
+                    // Best-effort delivery bookkeeping; do not fail the operator turn.
+                }
+            }
         }
         catch (err) {
             return {
@@ -284,19 +512,125 @@ export class MessagingOperatorRuntime {
     async stop() {
         this.#sessionByConversation.clear();
         await this.#backend.dispose?.();
+        await this.#conversationSessionStore?.stop?.();
     }
 }
 export { DEFAULT_OPERATOR_SYSTEM_PROMPT };
-const MU_COMMAND_TOOL_NAME = "mu_command";
+const COMMAND_TOOL_NAME = "command";
+const OPERATOR_PROMPT_CONTEXT_MAX_CHARS = 2_500;
+function compactJsonPreview(value, maxChars = OPERATOR_PROMPT_CONTEXT_MAX_CHARS) {
+    let raw = "";
+    if (typeof value === "string") {
+        raw = value;
+    }
+    else {
+        try {
+            raw = JSON.stringify(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    const compact = raw.replace(/\s+/g, " ").trim();
+    if (compact.length === 0) {
+        return null;
+    }
+    if (compact.length <= maxChars) {
+        return compact;
+    }
+    const keep = Math.max(1, maxChars - 1);
+    return `${compact.slice(0, keep)}…`;
+}
+function extractPromptContext(metadata) {
+    for (const key of ["client_context", "context", "editor_context"]) {
+        if (!(key in metadata)) {
+            continue;
+        }
+        const value = metadata[key];
+        if (value == null) {
+            continue;
+        }
+        if (typeof value === "object" || typeof value === "string") {
+            return value;
+        }
+    }
+    return null;
+}
+function buildOperatorPromptContextBlock(metadata) {
+    const context = extractPromptContext(metadata);
+    if (!context) {
+        return [];
+    }
+    const preview = compactJsonPreview(context);
+    if (!preview) {
+        return [];
+    }
+    return ["", "Client context (structured preview):", preview];
+}
+function extractSessionFlashPromptMessages(metadata) {
+    const raw = metadata.session_flash_messages;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const out = [];
+    for (const value of raw) {
+        const rec = asRecord(value);
+        if (!rec) {
+            continue;
+        }
+        const flashId = nonEmptyString(rec.flash_id);
+        const body = nonEmptyString(rec.body);
+        const sessionId = nonEmptyString(rec.session_id);
+        if (!flashId || !body || !sessionId) {
+            continue;
+        }
+        out.push({
+            flash_id: flashId,
+            created_at_ms: finiteInt(rec.created_at_ms) ?? 0,
+            session_id: sessionId,
+            session_kind: nonEmptyString(rec.session_kind),
+            body,
+            context_ids: stringList(rec.context_ids),
+            source: nonEmptyString(rec.source),
+            metadata: asRecord(rec.metadata) ?? {},
+        });
+    }
+    out.sort((a, b) => a.created_at_ms - b.created_at_ms);
+    return out;
+}
+function buildOperatorPromptFlashBlock(metadata) {
+    const flashes = extractSessionFlashPromptMessages(metadata);
+    if (flashes.length === 0) {
+        return [];
+    }
+    const lines = ["", `Session flash messages (${flashes.length}):`];
+    for (const flash of flashes) {
+        const source = flash.source ?? "unknown";
+        const contextIds = flash.context_ids.length > 0 ? ` | context_ids=${flash.context_ids.join(",")}` : "";
+        const bodyPreview = compactJsonPreview(flash.body, 400) ?? flash.body;
+        lines.push(`- [${flash.flash_id}] source=${source}${contextIds}`);
+        lines.push(`  ${bodyPreview}`);
+    }
+    lines.push("Treat these as high-priority user-provided context for this session.");
+    return lines;
+}
 function buildOperatorPrompt(input) {
-    return [
+    const lines = [
         `[Messaging context]`,
         `channel: ${input.inbound.channel}`,
         `request_id: ${input.inbound.request_id}`,
         `repo_root: ${input.inbound.repo_root}`,
         ``,
         `User message: ${input.inbound.command_text}`,
-    ].join("\n");
+        ...buildOperatorPromptContextBlock(input.inbound.metadata),
+        ...buildOperatorPromptFlashBlock(input.inbound.metadata),
+    ];
+    return lines.join("\n");
+}
+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 : `operator-${crypto.randomUUID()}`;
 }
 export class PiMessagingOperatorBackend {
     #provider;
@@ -310,6 +644,8 @@ export class PiMessagingOperatorBackend {
     #sessionIdleTtlMs;
     #maxSessions;
     #auditTurns;
+    #persistSessions;
+    #sessionDirForRepoRoot;
     #sessions = new Map();
     constructor(opts = {}) {
         this.#provider = opts.provider;
@@ -323,7 +659,10 @@ export class PiMessagingOperatorBackend {
         this.#sessionIdleTtlMs = Math.max(60_000, Math.trunc(opts.sessionIdleTtlMs ?? 30 * 60 * 1_000));
         this.#maxSessions = Math.max(1, Math.trunc(opts.maxSessions ?? 32));
         this.#auditTurns = opts.auditTurns ?? true;
-        // Command execution routes through the server command pipeline via mu_command.
+        this.#persistSessions = opts.persistSessions ?? true;
+        this.#sessionDirForRepoRoot =
+            opts.sessionDirForRepoRoot ?? ((repoRoot) => join(repoRoot, ".mu", "control-plane", "operator-sessions"));
+        // Operator turns can emit structured command proposals captured from tool events.
     }
     #disposeSession(sessionId) {
         const entry = this.#sessions.get(sessionId);
@@ -353,7 +692,19 @@ export class PiMessagingOperatorBackend {
             this.#disposeSession(sessionId);
         }
     }
-    async #createSession(repoRoot, nowMs) {
+    #sessionPersistence(repoRoot, sessionId) {
+        if (!this.#persistSessions) {
+            return undefined;
+        }
+        const sessionDir = this.#sessionDirForRepoRoot(repoRoot);
+        const sessionFile = join(sessionDir, `${sessionFileStem(sessionId)}.jsonl`);
+        return {
+            mode: "open",
+            sessionDir,
+            sessionFile,
+        };
+    }
+    async #createSession(repoRoot, sessionId, nowMs) {
         const session = await this.#sessionFactory({
             cwd: repoRoot,
             systemPrompt: this.#systemPrompt,
@@ -361,6 +712,7 @@ export class PiMessagingOperatorBackend {
             model: this.#model,
             thinking: this.#thinking,
             extensionPaths: this.#extensionPaths,
+            session: this.#sessionPersistence(repoRoot, sessionId),
         });
         await session.bindExtensions({
             commandContextActions: {
@@ -391,7 +743,7 @@ export class PiMessagingOperatorBackend {
         if (existing && existing.repoRoot !== repoRoot) {
             this.#disposeSession(sessionId);
         }
-        const created = await this.#createSession(repoRoot, nowMs);
+        const created = await this.#createSession(repoRoot, sessionId, nowMs);
         this.#sessions.set(sessionId, created);
         this.#pruneSessions(nowMs);
         return created;
@@ -447,8 +799,8 @@ export class PiMessagingOperatorBackend {
                         assistantText = parts.join("\n");
                 }
             }
-            // Capture mu_command tool calls — structured command proposals.
-            if (event?.type === "tool_execution_start" && event?.toolName === MU_COMMAND_TOOL_NAME) {
+            // Capture command tool calls — structured command proposals.
+            if (event?.type === "tool_execution_start" && event?.toolName === COMMAND_TOOL_NAME) {
                 const parsed = OperatorApprovedCommandSchema.safeParse(event.args);
                 if (parsed.success) {
                     capturedCommand = parsed.data;
@@ -476,7 +828,7 @@ export class PiMessagingOperatorBackend {
             unsub();
             sessionRecord.lastUsedAtMs = Math.trunc(this.#nowMs());
         }
-        // If the operator called mu_command, use the captured structured command.
+        // If the operator called command, use the captured structured command.
         if (capturedCommand) {
             await this.#auditTurn(input, {
                 outcome: "command",

package/dist/session_factory.d.ts

@@ -1,3 +1,9 @@
+export type MuSessionPersistenceMode = "in-memory" | "continue-recent" | "new" | "open";
+export type MuSessionPersistenceOpts = {
+    mode?: MuSessionPersistenceMode;
+    sessionDir?: string;
+    sessionFile?: string;
+};
 export type CreateMuSessionOpts = {
     cwd: string;
     systemPrompt?: string;
@@ -5,6 +11,7 @@ export type CreateMuSessionOpts = {
     model?: string;
     thinking?: string;
     extensionPaths?: string[];
+    session?: MuSessionPersistenceOpts;
 };
 export type MuSession = {
     subscribe: (listener: (event: any) => void) => () => void;
@@ -16,6 +23,11 @@ export type MuSession = {
     agent: {
         waitForIdle: () => Promise<void>;
     };
+    sessionId?: string;
+    sessionFile?: string;
+    sessionManager?: {
+        getLeafId?: () => string | null;
+    };
 };
 export declare function createMuSession(opts: CreateMuSessionOpts): Promise<MuSession>;
 //# sourceMappingURL=session_factory.d.ts.map

package/dist/session_factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session_factory.d.ts","sourceRoot":"","sources":["../src/session_factory.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,mBAAmB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC1D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,qBAAqB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvF,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;CAC5C,CAAC;AAEF,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC,CA2CnF"}
+{"version":3,"file":"session_factory.d.ts","sourceRoot":"","sources":["../src/session_factory.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,iBAAiB,GAAG,KAAK,GAAG,MAAM,CAAC;AAExF,MAAM,MAAM,wBAAwB,GAAG;IACtC,IAAI,CAAC,EAAE,wBAAwB,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC1D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,qBAAqB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvF,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE;QAChB,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;KAChC,CAAC;CACF,CAAC;AAkCF,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC,CA2CnF"}

package/dist/session_factory.js

@@ -1,6 +1,25 @@
-import { createBashTool, createEditTool, createReadTool, createWriteTool, } from "@mariozechner/pi-coding-agent";
+import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@mariozechner/pi-coding-agent";
 import { createMuResourceLoader, resolveModel } from "./backend.js";
 import { MU_DEFAULT_THEME_NAME, MU_DEFAULT_THEME_PATH } from "./ui_defaults.js";
+function createSessionManager(SessionManager, cwd, sessionOpts) {
+    const mode = sessionOpts?.mode ?? (sessionOpts?.sessionFile ? "open" : "continue-recent");
+    const sessionDir = sessionOpts?.sessionDir;
+    switch (mode) {
+        case "continue-recent":
+            return SessionManager.continueRecent(cwd, sessionDir);
+        case "new":
+            return SessionManager.create(cwd, sessionDir);
+        case "open": {
+            const sessionFile = sessionOpts?.sessionFile?.trim();
+            if (!sessionFile) {
+                throw new Error("session.mode=open requires session.sessionFile");
+            }
+            return SessionManager.open(sessionFile, sessionDir);
+        }
+        default:
+            return SessionManager.inMemory(cwd);
+    }
+}
 export async function createMuSession(opts) {
     const { AuthStorage, createAgentSession, SessionManager, SettingsManager } = await import("@mariozechner/pi-coding-agent");
     const authStorage = AuthStorage.create();
@@ -31,7 +50,7 @@ export async function createMuSession(opts) {
         model,
         tools,
         thinkingLevel: (opts.thinking ?? "minimal"),
-        sessionManager: SessionManager.inMemory(opts.cwd),
+        sessionManager: createSessionManager(SessionManager, opts.cwd, opts.session),
         settingsManager,
         resourceLoader,
         authStorage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-agent",
-  "version": "26.2.72",
+  "version": "26.2.74",
   "description": "Shared agent runtime for mu chat, orchestration roles, and serve extensions.",
   "keywords": [
     "mu",
@@ -24,11 +24,10 @@
     "themes/**"
   ],
   "dependencies": {
-    "@femtomc/mu-core": "26.2.72",
+    "@femtomc/mu-core": "26.2.74",
     "@mariozechner/pi-agent-core": "^0.53.0",
     "@mariozechner/pi-ai": "^0.53.0",
     "@mariozechner/pi-coding-agent": "^0.53.0",
-    "@sinclair/typebox": "^0.34.0",
     "zod": "^4.1.9"
   }
 }

package/prompts/roles/operator.md

@@ -5,57 +5,34 @@ Mission:
 - Help users with any coding tasks they ask you to handle directly.
 - Help users inspect repository/control-plane state.
 - Help users choose safe next actions.
-- When needed, propose approved commands using the mu_command tool.
+- Execute reads and mutations through direct `mu` CLI invocation when managing mu state.
 
 Available tools:
 - read: Read file contents
-- bash: Execute bash commands
+- bash: Execute shell commands (primary path for `mu` CLI)
 - edit: Make surgical edits to files
 - write: Create or overwrite files
 
-You also have access to specialized read/diagnostic tools:
-- `mu_status`
-- `mu_control_plane`
-- `mu_issues`
-- `mu_forum`
-- `mu_events`
-- `mu_runs`
-- `mu_activities`
-- `mu_heartbeats`
-- `mu_cron`
-- `mu_messaging_setup`
-
-Hard Constraints:
-- Never perform mutations directly through read/write tools.
-- Mutating actions must flow through the `mu_command` tool.
-- Use the `mu_command` tool to propose commands. It accepts structured parameters — do NOT emit raw JSON directives in your text output.
-
-mu_command tool usage:
-- Call `mu_command` with `kind` set to the command type and relevant parameters.
-- Example: `mu_command({ kind: "run_start", prompt: "ship release" })`
-- Example: `mu_command({ kind: "status" })`
-- Example: `mu_command({ kind: "issue_get", issue_id: "mu-abc123" })`
-
-Allowed command kinds:
-- `status`
-- `ready`
-- `issue_list`
-- `issue_get`
-- `forum_read`
-- `run_list`
-- `run_status`
-- `run_start`
-- `run_resume`
-- `run_interrupt`
-
-Efficiency:
-- Do NOT pre-fetch status, issues, control-plane, events, or runs at the start of a conversation. Only call diagnostic tools when the user's request specifically requires that information.
-- Respond directly to what the user asks. Avoid speculative tool calls.
-
-Context hygiene for `mu_*` query tools:
-- Prefer narrow discovery first (`limit` + filters like `contains`, `status`, `tag`, `source`).
-- Then do targeted retrieval by ID (`get`/`status`) with `fields` when available.
-- Avoid broad repeated scans when a precise lookup would answer the question.
+CLI-first workflow:
+- Use `bash` + `mu ...` for issue/forum/run/control-plane state operations.
+- Prefer `--pretty` (or `--json` + targeted parsing) for clear, auditable output.
+- Do not use bespoke query/command wrappers; call the CLI surface directly.
+
+Example invocation patterns:
+- `bash("mu status --pretty")`
+- `bash("mu issues list --status open --limit 20 --pretty")`
+- `bash("mu forum read issue:mu-abc123 --limit 20 --pretty")`
+- `bash("mu runs start \"ship release\" --max-steps 25 --pretty")`
+- `bash("mu issues close mu-abc123 --outcome success --pretty")`
+- `bash("mu forum post issue:mu-abc123 -m \"done\" --author operator --pretty")`
+- `bash("mu control reload --pretty")`
+
+Guardrails:
+- Never hand-edit `.mu/*.jsonl` for normal lifecycle actions; use `mu` CLI commands.
+- Prefer bounded retrieval (`--limit`, scoped filters) before broad scans.
+- Do NOT pre-fetch status/issues/events/runs at conversation start.
+- Fetch only what the user request requires.
+- Keep responses grounded in concrete command results.
 
 For normal answers:
 - Respond in plain text (no directive prefix).