akemon 0.3.5 → 0.3.7

package/dist/server.js

@@ -2,12 +2,48 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { exec } from "child_process";
 import { scanAndKillOrphans } from "./orphan-scan.js";
+import { registerLocalInstance, touchLocalInstance, unregisterLocalInstance, } from "./local-registry.js";
+import { appendLocalPeerContact, createLocalAkemonResponseMessage, requireLocalAkemonMessageEnvelope, submitLocalAkemonMessageToMcp, } from "./local-interconnect.js";
+import { runLocalCoreCmChat, } from "./core-cognitive-module.js";
+import { runPassiveReflectionOnce, } from "./passive-reflection-cognitive-module.js";
+import { readCognitiveArtifacts, } from "./cognitive-artifact-store.js";
+import { actorRef, textFromAkemonMessage } from "./akemon-message.js";
+import { appendPermissionAuditRecord } from "./permission-audit.js";
+import { logBestEffortError } from "./best-effort.js";
 import { timingSafeEqual } from "node:crypto";
 import { createServer } from "http";
 import { createInterface } from "readline";
-import { mkdir } from "fs/promises";
-import { join } from "path";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { initWorld, initBioState, initGuide, getSelfState, loadRecentCanvasEntries, initAgentConfig, loadAgentConfig, loadDirectives, loadTaskHistory, reviveAgent, } from "./self.js";
+import { RelayPeripheral } from "./relay-peripheral.js";
+import { EnginePeripheral, LLM_ENGINES as LLM_ENGINES_SET } from "./engine-peripheral.js";
+import { EngineQueue } from "./engine-queue.js";
+import { BioStateModule } from "./bio-module.js";
+import { MemoryModule } from "./memory-module.js";
+import { RoleModule } from "./role-module.js";
+import { TaskModule } from "./task-module.js";
+import { SocialModule } from "./social-module.js";
+import { LongTermModule } from "./longterm-module.js";
+import { ReflectionModule } from "./reflection-module.js";
+import { ScriptModule } from "./script-module.js";
+import { FileEventLog, PersistentEventBus } from "./event-bus.js";
+import { CodexSoftwareAgentPeripheral, createOwnerTaskEnvelope, listSoftwareAgentContextSessions, listSoftwareAgentTaskRecords, readSoftwareAgentContextSession, readSoftwareAgentTaskRecord, softwareAgentTaskRecordPath, } from "./software-agent-peripheral.js";
+import { normalizeWorkbenchInputRequest, normalizeWorkbenchResizeRequest, normalizeWorkbenchStartRequest, normalizeWorkbenchInputMode, normalizeWorkbenchTool, } from "./workbench-session.js";
+import { executeInteractiveSessionAction, InteractiveSessionManager, InteractiveSessionPeripheral, } from "./interactive-session.js";
+import { buildSoftwareAgentMemorySummary } from "./software-agent-memory.js";
+import { buildWorkMemoryContext, workMemoryDir } from "./work-memory.js";
+import { executeMemoryActionProposalWithResult, } from "./memory-proposal.js";
+import { buildPeripheralExploreBriefing, createRuntimePeripheralRecord, loadPeripheralRecords, mergePeripheralRecords, upsertPeripheralRecords, } from "./peripheral-registry.js";
+import { SIG, sig } from "./types.js";
+import { appendRound, loadConversation, listConversations, buildLLMContext } from "./context.js";
+import { redactSecrets } from "./redaction.js";
+import { appendCognitiveEvent, createCognitiveEventId, } from "./cognitive-event-log.js";
+import { createTaskSurfaceView, listTaskRegistryRecords, readTaskRegistryRecord, upsertTaskRegistryRecord, upsertTaskRegistryRecordFromEvent, } from "./task-registry.js";
+import { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
+import { autoRoute, runCollaborativeQuery } from "./agent-utils.js";
+const SERVER_DIR = dirname(fileURLToPath(import.meta.url));
 // V2: module-level instances (set in serve())
 let _engineP = null;
 let _bus = null;
@@ -20,6 +56,7 @@ const ENGINE_WAIT_DEADLINE_MS = 5 * 60 * 1000;
 // the slot is returned to the queue. Shorter than the old 8 min — opencode
 // runs that take longer almost always hang forever.
 const ENGINE_EXEC_TIMEOUT_MS = 3 * 60 * 1000;
+const LOCAL_CHAT_FOLLOW_UP_TARGET_MAX_AGE_MS = 30 * 60 * 1000;
 // ---------------------------------------------------------------------------
 // V2 Event helpers — emit signals to EventBus
 // ---------------------------------------------------------------------------
@@ -37,6 +74,7 @@ function emitTokenUsage(promptLen, resultLen, tokenLimit = 0) {
         }));
     }
 }
+const DEFAULT_SEND_INPUT_WAIT_MS = 600;
 // V2: TaskModule ref for push notifications
 let _taskModule = null;
 export function onOrderNotify(orderId) {
@@ -117,6 +155,68 @@ function requireSoftwareAgent(res, softwareAgent) {
     writeJsonResponse(res, 503, { error: "Software agent peripheral not ready" });
     return null;
 }
+const VENDOR_XTERM_NODE_MODULES = {
+    "vendor/xterm/xterm.js": join("@xterm", "xterm", "lib", "xterm.js"),
+    "vendor/xterm/xterm.css": join("@xterm", "xterm", "css", "xterm.css"),
+    "vendor/xterm/addon-fit.js": join("@xterm", "addon-fit", "lib", "addon-fit.js"),
+    "vendor/xterm/addon-web-links.js": join("@xterm", "addon-web-links", "lib", "addon-web-links.js"),
+    "vendor/xterm/addon-search.js": join("@xterm", "addon-search", "lib", "addon-search.js"),
+};
+async function readUiAsset(relativePath) {
+    const candidates = [
+        join(SERVER_DIR, relativePath),
+        join(SERVER_DIR, "..", "src", relativePath),
+    ];
+    const nodeModulesPath = VENDOR_XTERM_NODE_MODULES[relativePath];
+    if (nodeModulesPath) {
+        candidates.push(join(SERVER_DIR, "..", "node_modules", nodeModulesPath));
+    }
+    let lastError;
+    for (const candidate of candidates) {
+        try {
+            return await readFile(candidate);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`UI asset not found: ${relativePath}`);
+}
+export async function handleLocalUiAssetRoute(req, res) {
+    const requestPath = req.url?.split("?")[0] || "";
+    const routeMap = {
+        "/live": { path: "live.html", contentType: "text/html; charset=utf-8", notFound: "Live page not found" },
+        "/live/": { path: "live.html", contentType: "text/html; charset=utf-8", notFound: "Live page not found" },
+        "/workbench": { path: "workbench.html", contentType: "text/html; charset=utf-8", notFound: "Workbench page not found" },
+        "/workbench/": { path: "workbench.html", contentType: "text/html; charset=utf-8", notFound: "Workbench page not found" },
+        "/vendor/xterm/xterm.css": { path: "vendor/xterm/xterm.css", contentType: "text/css; charset=utf-8", notFound: "xterm CSS not found" },
+        "/vendor/xterm/xterm.js": { path: "vendor/xterm/xterm.js", contentType: "application/javascript; charset=utf-8", notFound: "xterm JS not found" },
+        "/vendor/xterm/addon-fit.js": { path: "vendor/xterm/addon-fit.js", contentType: "application/javascript; charset=utf-8", notFound: "xterm addon-fit not found" },
+        "/vendor/xterm/addon-web-links.js": { path: "vendor/xterm/addon-web-links.js", contentType: "application/javascript; charset=utf-8", notFound: "xterm addon-web-links not found" },
+        "/vendor/xterm/addon-search.js": { path: "vendor/xterm/addon-search.js", contentType: "application/javascript; charset=utf-8", notFound: "xterm addon-search not found" },
+    };
+    const route = routeMap[requestPath];
+    if (!route || req.method !== "GET")
+        return false;
+    try {
+        const asset = await readUiAsset(route.path);
+        res.writeHead(200, {
+            "Content-Type": route.contentType,
+            "Cache-Control": requestPath.startsWith("/vendor/") ? "public, max-age=3600" : "no-store",
+        }).end(asset);
+    }
+    catch (err) {
+        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" })
+            .end(`${route.notFound}: ${err.message || String(err)}`);
+    }
+    return true;
+}
+function requireWorkbench(res, workbench) {
+    if (workbench)
+        return workbench;
+    writeJsonResponse(res, 503, { error: "Workbench session manager not ready" });
+    return null;
+}
 function readJsonBody(req, maxBytes = 256 * 1024) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -163,6 +263,16 @@ async function readOwnerSoftwareAgentEnvelope(req, res, deps) {
             envelope,
             request: body,
         });
+        if (readOptionalBooleanBody(body?.includeWorkMemoryContext, "includeWorkMemoryContext")) {
+            const workContext = await buildWorkMemoryContext({
+                workdir: deps.workdir,
+                agentName: deps.agentName,
+                purpose: `software-agent task: ${envelope.goal}`,
+                budget: readOptionalPositiveIntBody(body?.workMemoryContextBudget, "workMemoryContextBudget"),
+            });
+            envelope.workMemoryDir = workContext.workMemoryDir;
+            envelope.workMemoryContext = workContext.text;
+        }
         return envelope;
     }
     catch (err) {
@@ -179,134 +289,2821 @@ export async function handleSoftwareAgentRunHttp(req, res, deps) {
     const envelope = await readOwnerSoftwareAgentEnvelope(req, res, deps);
     if (!envelope)
         return;
+    ensureSoftwareAgentEnvelopeTaskId(envelope);
+    const taskEventIds = [];
+    const taskStartEventId = await appendSoftwareAgentTaskStartEvent({
+        agentName: deps.agentName,
+        workdir: deps.workdir,
+        envelope,
+        softwareAgentId: deps.softwareAgent?.id,
+    });
+    if (taskStartEventId)
+        taskEventIds.push(taskStartEventId);
     try {
         const result = await softwareAgent.sendTask(envelope);
+        await appendSoftwareAgentTaskEndEvents({
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+            envelope,
+            result,
+            softwareAgentId: deps.softwareAgent?.id,
+            sourceEventIds: taskEventIds,
+        });
         writeJsonResponse(res, 200, redactSecrets(result), true);
     }
     catch (err) {
+        await appendSoftwareAgentTaskFailureEvent({
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+            envelope,
+            softwareAgentId: deps.softwareAgent?.id,
+            sourceEventIds: taskEventIds,
+            error: err.message || String(err),
+        });
         const busy = String(err.message || "").includes("busy");
         writeJsonResponse(res, busy ? 409 : 500, { error: err.message || String(err) });
     }
 }
-export async function handleSoftwareAgentRunStreamHttp(req, res, deps) {
+export async function handleLocalAkemonMessageHttp(req, res, deps) {
     if (!requireOwnerRequest(req, res, deps.options))
         return;
-    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
-    if (!softwareAgent)
-        return;
-    const envelope = await readOwnerSoftwareAgentEnvelope(req, res, deps);
-    if (!envelope)
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (err) {
+        writeJsonResponse(res, 400, { error: err.message || "Invalid request body" });
         return;
-    const abortController = new AbortController();
-    let responseFinished = false;
-    let streamStarted = false;
-    res.on("close", () => {
-        if (!responseFinished)
-            abortController.abort();
-    });
-    const ensureStreamStarted = () => {
-        if (streamStarted)
+    }
+    let responseSent = false;
+    let acceptedAsyncTask = null;
+    try {
+        const message = requireLocalAkemonMessageEnvelope(body);
+        if (message.target.kind !== "agent" || message.target.id !== deps.agentName) {
+            writeJsonResponse(res, 400, {
+                error: `Message target ${message.target.kind}:${message.target.id} does not match this Akemon (${deps.agentName})`,
+            });
             return;
-        streamStarted = true;
-        res.writeHead(200, {
-            "Content-Type": "application/x-ndjson; charset=utf-8",
-            "Cache-Control": "no-cache",
-            "X-Accel-Buffering": "no",
+        }
+        const text = textFromAkemonMessage(message);
+        const followUpForTaskId = readLocalChatFollowUpTaskId(message);
+        const memoryCommand = !followUpForTaskId ? parseMemoryChatCommand({
+            agentName: deps.agentName,
+            workdir: deps.workdir || process.cwd(),
+            text,
+        }) : null;
+        const reflectionCommand = !followUpForTaskId && !memoryCommand
+            ? executeReflectionChatCommand({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                text,
+            })
+            : null;
+        const workbenchCommand = !followUpForTaskId
+            && deps.workbench
+            && !memoryCommand
+            && !reflectionCommand
+            ? parseWorkbenchChatCommandAction(text)
+            : null;
+        const usesCoreCmPath = !followUpForTaskId && !memoryCommand && !reflectionCommand && !workbenchCommand && deps.requestCompute;
+        const waitForCompletion = body?.wait !== false && body?.async !== true;
+        await appendLocalPeerContact({
+            schemaVersion: 1,
+            ts: new Date().toISOString(),
+            ownerAgent: deps.agentName,
+            peerAgent: message.source.id,
+            direction: "received",
+            messageId: message.id,
+            conversationId: message.conversationId,
         });
-        res.flushHeaders?.();
-    };
-    try {
-        await softwareAgent.sendTask(envelope, {
-            signal: abortController.signal,
-            observer: {
-                onStart(event) {
-                    ensureStreamStarted();
-                    writeSoftwareAgentStreamEvent(res, {
-                        type: "start",
-                        taskId: event.taskId,
-                        commandLine: event.commandLine,
-                    });
+        try {
+            await appendPermissionAuditRecord(deps.agentName, {
+                actionKind: "akemon-message",
+                action: "local-message.receive",
+                requestedBy: message.source,
+                performedBy: actorRef("agent", deps.agentName, "local"),
+                target: message.target,
+                riskLevel: message.permissions.riskLevel,
+                memoryScope: message.memoryScope,
+                transport: "local",
+                decision: {
+                    result: "allowed",
+                    mode: message.permissions.requiresOwnerApproval === true ? "owner-approved" : "automatic",
+                    reason: followUpForTaskId
+                        ? "Owner-only local message queued as a follow-up for an active Akemon task."
+                        : memoryCommand
+                            ? "Owner-only local message matched a memory command."
+                            : reflectionCommand
+                                ? "Owner-only local message matched a Reflection CM command."
+                                : workbenchCommand
+                                    ? "Owner-only local message matched a Workbench command."
+                                    : usesCoreCmPath
+                                        ? "Owner-only local message entered the Core CM chat path."
+                                        : message.permissions.requiresOwnerApproval === true
+                                            ? "Message requested owner approval before local task execution."
+                                            : "Message matched this local Akemon and was forwarded through the local MCP task path.",
                 },
-                onStream(event) {
-                    ensureStreamStarted();
-                    writeSoftwareAgentStreamEvent(res, {
-                        type: event.stream,
-                        taskId: event.taskId,
-                        chunk: event.chunk,
-                    });
+                allowedActions: message.permissions.allowedActions,
+                forbiddenActions: message.permissions.forbiddenActions,
+                references: {
+                    messageId: message.id,
+                    conversationId: message.conversationId,
                 },
-                onEnd(event) {
-                    ensureStreamStarted();
-                    writeSoftwareAgentStreamEvent(res, {
-                        type: "end",
-                        taskId: event.taskId,
-                        exitCode: event.exitCode,
-                        durationMs: event.durationMs,
-                        result: event.result,
+            });
+        }
+        catch (error) {
+            logBestEffortError("local message audit append", error);
+        }
+        if (!waitForCompletion && usesCoreCmPath) {
+            const workdir = deps.workdir || process.cwd();
+            const taskId = createLocalChatTaskId(message);
+            const task = await upsertTaskRegistryRecord({
+                workdir,
+                agentName: deps.agentName,
+                patch: {
+                    taskId,
+                    source: "local_chat",
+                    status: "pending",
+                    stage: "queued",
+                    objective: text,
+                    kind: "chat",
+                    visibility: "primary",
+                    route: "core_cm",
+                    conversationId: message.conversationId,
+                    refs: [{
+                            conversationId: message.conversationId,
+                            messageId: message.id,
+                            taskId,
+                        }],
+                    data: {
+                        source: "local_chat",
+                        objective: text,
+                        ownerTextChars: text.length,
+                        acceptedAsync: true,
+                    },
+                },
+            });
+            acceptedAsyncTask = {
+                taskId,
+                workdir,
+                conversationId: message.conversationId,
+                messageId: message.id,
+            };
+            writeJsonResponse(res, 202, {
+                success: true,
+                accepted: true,
+                queued: true,
+                async: true,
+                wait: false,
+                message,
+                output: "Akemon accepted this request and will report through the task record.",
+                task: createTaskResponseRecord(task),
+                taskView: createTaskSurfaceView(task),
+            }, true);
+            responseSent = true;
+        }
+        if (followUpForTaskId) {
+            await handleLocalChatFollowUpHttp({
+                res,
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                message,
+                taskId: followUpForTaskId,
+                text,
+            });
+            return;
+        }
+        if (memoryCommand) {
+            const workdir = deps.workdir || process.cwd();
+            const taskId = createLocalChatTaskId(message);
+            const taskEventIds = [];
+            const memoryTaskData = {
+                source: "local_chat_command",
+                objective: text,
+                action: "proposal" in memoryCommand ? memoryCommand.proposal.action : "usage",
+            };
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "received",
+                stage: "queued",
+                status: "pending",
+                route: "memory_cm",
+                summary: "Owner memory command queued.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: memoryTaskData,
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "routed",
+                stage: "framing",
+                status: "running",
+                route: "memory_cm",
+                summary: "Akemon routed the owner request to Memory CM.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: memoryTaskData,
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "delegated",
+                stage: "executing",
+                status: "running",
+                route: "memory_cm",
+                summary: "Memory CM is executing the owner command.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: memoryTaskData,
+            });
+            const memoryResult = "proposal" in memoryCommand
+                ? await executeMemoryActionProposalWithResult({
+                    agentName: deps.agentName,
+                    workdir,
+                    proposal: memoryCommand.proposal,
+                })
+                : null;
+            const output = memoryResult ? memoryResult.output : ("output" in memoryCommand ? memoryCommand.output : "");
+            const response = createLocalAkemonResponseMessage({
+                request: message,
+                responderAgent: deps.agentName,
+                result: output,
+            });
+            const mainChatEventIds = await appendLocalChatRound({
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                taskId,
+                userText: text,
+                agentText: output,
+            });
+            const cmEventIds = [];
+            if (memoryResult) {
+                const cmEventId = await appendMemoryActionCmEvent({
+                    agentName: deps.agentName,
+                    workdir,
+                    conversationId: message.conversationId,
+                    ownerMessageId: message.id,
+                    akemonMessageId: response.id,
+                    sourceEventIds: [...taskEventIds, ...mainChatEventIds],
+                    taskId,
+                    memoryAction: memoryResult,
+                });
+                if (cmEventId)
+                    cmEventIds.push(cmEventId);
+            }
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "reported",
+                stage: "reviewing",
+                status: "running",
+                route: "memory_cm",
+                summary: "Akemon is preparing the memory command report.",
+                refs: [{
+                        eventIds: [...taskEventIds, ...mainChatEventIds, ...cmEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                    }],
+                data: memoryResult
+                    ? createMemoryActionTaskData(memoryResult, "local_chat_command")
+                    : { source: "local_chat_command", action: "usage" },
+            });
+            const memoryTaskBlocked = !!(memoryResult && ["not_found", "invalid"].includes(memoryResult.status));
+            const taskEndEventId = await appendLocalTaskEvent({
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: memoryTaskBlocked ? "failed" : "completed",
+                stage: memoryTaskBlocked ? "blocked" : "done",
+                status: memoryTaskBlocked ? "failed" : "succeeded",
+                route: "memory_cm",
+                summary: memoryResult
+                    ? summarizeMemoryActionExecution(memoryResult)
+                    : "Akemon returned memory command usage guidance.",
+                refs: [{
+                        eventIds: [...taskEventIds, ...mainChatEventIds, ...cmEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        memoryProposalId: memoryResult?.resolvedProposalId || memoryResult?.proposalId,
+                        taskId,
+                    }],
+                data: memoryResult
+                    ? createMemoryActionTaskData(memoryResult, "local_chat_command")
+                    : { source: "local_chat_command", action: "usage" },
+            });
+            if (taskEndEventId)
+                taskEventIds.push(taskEndEventId);
+            const task = await readLocalTaskResponseRecord({ workdir, agentName: deps.agentName, taskId });
+            writeJsonResponse(res, 200, {
+                success: true,
+                message,
+                response,
+                output,
+                task: createOptionalTaskResponseRecord(task),
+                taskView: createTaskViewResponse(task),
+                eventIds: createLocalChatEventIds({
+                    mainChat: mainChatEventIds,
+                    cm: cmEventIds,
+                    task: taskEventIds,
+                }),
+            }, true);
+            return;
+        }
+        if (reflectionCommand) {
+            const output = await reflectionCommand;
+            const response = createLocalAkemonResponseMessage({
+                request: message,
+                responderAgent: deps.agentName,
+                result: output,
+            });
+            const mainChatEventIds = await appendLocalChatRound({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                userText: text,
+                agentText: output,
+            });
+            writeJsonResponse(res, 200, {
+                success: true,
+                message,
+                response,
+                output,
+                eventIds: createLocalChatEventIds({ mainChat: mainChatEventIds }),
+            }, true);
+            return;
+        }
+        if (workbenchCommand) {
+            const workdir = deps.workdir || process.cwd();
+            const taskId = createLocalChatTaskId(message);
+            const taskEventIds = [];
+            const workbenchTaskData = {
+                source: "local_chat_command",
+                objective: text,
+                capability: "action" in workbenchCommand ? workbenchCommand.action.capability : "invalid_command",
+            };
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "received",
+                stage: "queued",
+                status: "pending",
+                route: "interactive-session",
+                summary: "Owner Workbench command queued.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: workbenchTaskData,
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "delegated",
+                stage: "dispatching",
+                status: "running",
+                route: "interactive-session",
+                summary: "action" in workbenchCommand
+                    ? `Owner asked Akemon to run interactive-session.${workbenchCommand.action.capability}.`
+                    : "Owner entered an invalid Workbench command.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: workbenchTaskData,
+            });
+            const observation = "action" in workbenchCommand
+                ? await executeInteractiveSessionViaPeripheral(deps.workbench, deps.interactiveSessionPeripheral, workbenchCommand.action)
+                : createInvalidInteractiveSessionObservation(workbenchCommand.error);
+            const peripheralEventId = "action" in workbenchCommand
+                ? await appendInteractiveSessionPeripheralEvent({
+                    agentName: deps.agentName,
+                    workdir,
+                    conversationId: message.conversationId,
+                    ownerMessageId: message.id,
+                    taskId,
+                    action: workbenchCommand.action,
+                    observation,
+                })
+                : null;
+            const peripheralEventIds = peripheralEventId ? [peripheralEventId] : [];
+            const output = observation.summary;
+            const response = createLocalAkemonResponseMessage({
+                request: message,
+                responderAgent: deps.agentName,
+                result: output,
+            });
+            const mainChatEventIds = await appendLocalChatRound({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                taskId,
+                userText: text,
+                agentText: output,
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "observed",
+                stage: "observing",
+                status: "running",
+                route: "interactive-session",
+                summary: observation.ok
+                    ? "Akemon observed the interactive-session result."
+                    : "Akemon observed an interactive-session error.",
+                refs: [{
+                        eventIds: [...taskEventIds, ...peripheralEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                        sessionId: interactiveSessionObservationSessionId(observation, "action" in workbenchCommand ? workbenchCommand.action : undefined),
+                    }],
+                data: createInteractiveSessionTaskData({
+                    source: "local_chat_command",
+                    action: "action" in workbenchCommand ? workbenchCommand.action : undefined,
+                    observation,
+                    outputChars: output.length,
+                }),
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "reported",
+                stage: "reviewing",
+                status: "running",
+                route: "interactive-session",
+                summary: "Akemon is preparing the interactive-session report.",
+                refs: [{
+                        eventIds: [...taskEventIds, ...mainChatEventIds, ...peripheralEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                        sessionId: interactiveSessionObservationSessionId(observation, "action" in workbenchCommand ? workbenchCommand.action : undefined),
+                    }],
+                data: createInteractiveSessionTaskData({
+                    source: "local_chat_command",
+                    action: "action" in workbenchCommand ? workbenchCommand.action : undefined,
+                    observation,
+                    outputChars: output.length,
+                }),
+            });
+            const taskEndEventId = await appendLocalTaskEvent({
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: observation.ok ? "completed" : "failed",
+                stage: observation.ok ? "done" : "blocked",
+                status: observation.ok ? "succeeded" : "failed",
+                route: "interactive-session",
+                summary: summarizeInteractiveSessionTaskCompletion(observation.capability, observation.ok),
+                refs: [{
+                        eventIds: [...taskEventIds, ...mainChatEventIds, ...peripheralEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                        sessionId: interactiveSessionObservationSessionId(observation, "action" in workbenchCommand ? workbenchCommand.action : undefined),
+                    }],
+                data: createInteractiveSessionTaskData({
+                    source: "local_chat_command",
+                    action: "action" in workbenchCommand ? workbenchCommand.action : undefined,
+                    observation,
+                    outputChars: output.length,
+                }),
+            });
+            if (taskEndEventId)
+                taskEventIds.push(taskEndEventId);
+            const task = await readLocalTaskResponseRecord({ workdir, agentName: deps.agentName, taskId });
+            writeJsonResponse(res, 200, {
+                success: true,
+                message,
+                response,
+                output,
+                task: createOptionalTaskResponseRecord(task),
+                taskView: createTaskViewResponse(task),
+                eventIds: createLocalChatEventIds({
+                    mainChat: mainChatEventIds,
+                    peripheral: peripheralEventIds,
+                    task: taskEventIds,
+                }),
+            }, true);
+            return;
+        }
+        if (deps.requestCompute) {
+            const ownerLanguage = (await loadAgentConfig(deps.workdir || process.cwd(), deps.agentName)).owner_language;
+            const workdir = deps.workdir || process.cwd();
+            const taskId = createLocalChatTaskId(message);
+            const taskEventIds = [];
+            const coreTaskData = {
+                source: "local_chat",
+                objective: text,
+                ownerTextChars: text.length,
+            };
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "received",
+                stage: "queued",
+                status: "pending",
+                route: "core_cm",
+                summary: "Owner request queued for Core CM.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: coreTaskData,
+            });
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "routed",
+                stage: "framing",
+                status: "running",
+                route: "core_cm",
+                summary: "Core CM is framing the owner request.",
+                refs: [{
+                        conversationId: message.conversationId,
+                        messageId: message.id,
+                        taskId,
+                    }],
+                data: coreTaskData,
+            });
+            const peripheralEventIds = [];
+            const computeEventIds = [];
+            const dispatchCmEventIds = [];
+            const dispatchRecordsSeen = [];
+            let ownerTextForDispatch = text;
+            const requestCoreCmCompute = async (req) => {
+                const computeResult = await deps.requestCompute({
+                    ...req,
+                    taskId: req.taskId || taskId,
+                    refs: [
+                        ...(req.refs || []),
+                        {
+                            conversationId: message.conversationId,
+                            messageId: message.id,
+                            taskId,
+                        },
+                    ],
+                });
+                if (computeResult.audit?.eventId)
+                    computeEventIds.push(computeResult.audit.eventId);
+                return computeResult;
+            };
+            const executeCoreCmInteractiveSessionProposal = async (proposal) => {
+                const existingTask = await readTaskRegistryRecord({
+                    workdir,
+                    agentName: deps.agentName,
+                    taskId,
+                });
+                const dispatchRecord = createCoreCmDispatchRecord({
+                    proposal,
+                    ownerText: ownerTextForDispatch,
+                    taskId,
+                    conversationId: message.conversationId,
+                });
+                dispatchRecordsSeen.push(dispatchRecord);
+                const dispatchRecords = appendTaskDispatchRecord(existingTask, dispatchRecord);
+                const dispatchCmEventId = await appendCoreCmDispatchRecordEvent({
+                    agentName: deps.agentName,
+                    workdir,
+                    conversationId: message.conversationId,
+                    ownerMessageId: message.id,
+                    taskId,
+                    dispatchRecord,
+                    sourceEventIds: taskEventIds,
+                });
+                if (dispatchCmEventId)
+                    dispatchCmEventIds.push(dispatchCmEventId);
+                await appendLocalTaskStageEvent({
+                    taskEventIds,
+                    agentName: deps.agentName,
+                    workdir,
+                    conversationId: message.conversationId,
+                    taskId,
+                    phase: "delegated",
+                    stage: "dispatching",
+                    status: "running",
+                    route: "core_cm",
+                    summary: `Core CM dispatched ${proposal.capability} to interactive-session.`,
+                    refs: [{
+                            conversationId: message.conversationId,
+                            messageId: message.id,
+                            taskId,
+                        }],
+                    data: {
+                        ...coreTaskData,
+                        peripheral: proposal.peripheral,
+                        capability: proposal.capability,
+                        dispatchRecord,
+                        dispatchRecords,
+                        dispatchRecordCount: dispatchRecords.length,
+                        latestDispatchTarget: dispatchRecord.targetPeripheral,
+                        latestDispatchCapability: dispatchRecord.capability,
+                    },
+                });
+                const observation = await executeInteractiveSessionActionProposal(deps.workbench, deps.interactiveSessionPeripheral, proposal);
+                const eventId = await appendInteractiveSessionPeripheralEvent({
+                    agentName: deps.agentName,
+                    workdir: deps.workdir || process.cwd(),
+                    conversationId: message.conversationId,
+                    ownerMessageId: message.id,
+                    taskId,
+                    action: proposal,
+                    observation,
+                });
+                if (eventId)
+                    peripheralEventIds.push(eventId);
+                await appendLocalTaskStageEvent({
+                    taskEventIds,
+                    agentName: deps.agentName,
+                    workdir,
+                    conversationId: message.conversationId,
+                    taskId,
+                    phase: "observed",
+                    stage: "observing",
+                    status: "running",
+                    route: "core_cm",
+                    summary: observation.ok
+                        ? "Core CM observed the peripheral result."
+                        : "Core CM observed a peripheral error.",
+                    refs: [{
+                            eventIds: eventId ? [eventId] : [],
+                            conversationId: message.conversationId,
+                            messageId: message.id,
+                            taskId,
+                            sessionId: interactiveSessionObservationSessionId(observation, proposal),
+                        }],
+                    data: {
+                        ...coreTaskData,
+                        peripheral: proposal.peripheral,
+                        capability: proposal.capability,
+                        observationOk: observation.ok,
+                    },
+                });
+                return observation;
+            };
+            let result = await runLocalCoreCmChat({
+                agentName: deps.agentName,
+                workdir,
+                text,
+                conversationId: message.conversationId,
+                ownerLanguage,
+                interactiveSessions: deps.workbench,
+                requestCompute: requestCoreCmCompute,
+                executeInteractiveSessionActionProposal: executeCoreCmInteractiveSessionProposal,
+            });
+            let absorbedFollowUps = [];
+            const queuedFollowUps = await readQueuedActionableFollowUps({
+                workdir,
+                agentName: deps.agentName,
+                taskId,
+            });
+            if (queuedFollowUps.length) {
+                const followUpText = formatCoreCmQueuedFollowUpText({
+                    originalText: text,
+                    currentOutput: result.output,
+                    followUps: queuedFollowUps,
+                });
+                const previousOwnerTextForDispatch = ownerTextForDispatch;
+                ownerTextForDispatch = followUpText;
+                try {
+                    const followUpResult = await runLocalCoreCmChat({
+                        agentName: deps.agentName,
+                        workdir,
+                        text: followUpText,
+                        conversationId: message.conversationId,
+                        ownerLanguage,
+                        interactiveSessions: deps.workbench,
+                        requestCompute: requestCoreCmCompute,
+                        executeInteractiveSessionActionProposal: executeCoreCmInteractiveSessionProposal,
                     });
+                    result = mergeCoreCmQueuedFollowUpResult({
+                        base: result,
+                        followUp: followUpResult,
+                        followUps: queuedFollowUps,
+                        ownerLanguage,
+                    });
+                    absorbedFollowUps = queuedFollowUps;
+                }
+                finally {
+                    ownerTextForDispatch = previousOwnerTextForDispatch;
+                }
+            }
+            const output = result.output;
+            const response = createLocalAkemonResponseMessage({
+                request: message,
+                responderAgent: deps.agentName,
+                result: output,
+            });
+            const mainChatEventIds = await appendLocalChatRound({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                taskId,
+                userText: text,
+                agentText: output,
+            });
+            const cmEventIds = await appendCoreCmResultEvents({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                sourceEventIds: [...dispatchCmEventIds, ...mainChatEventIds, ...peripheralEventIds],
+                taskId,
+                processNotes: result.processNotes,
+                memoryProposal: result.memoryProposal,
+                memoryAction: result.memoryAction,
+            });
+            const existingReviewTask = await readTaskRegistryRecord({
+                workdir,
+                agentName: deps.agentName,
+                taskId,
+            });
+            const followUpTaskData = createAbsorbedFollowUpTaskData(existingReviewTask, absorbedFollowUps);
+            const reviewRecord = createCoreCmReviewRecord({
+                result,
+                output,
+                taskId,
+                conversationId: message.conversationId,
+                dispatchRecord: dispatchRecordsSeen[dispatchRecordsSeen.length - 1],
+            });
+            const reviewRecords = appendTaskReviewRecord(existingReviewTask, reviewRecord);
+            const reviewCmEventId = await appendCoreCmReviewRecordEvent({
+                agentName: deps.agentName,
+                workdir: deps.workdir || process.cwd(),
+                conversationId: message.conversationId,
+                ownerMessageId: message.id,
+                akemonMessageId: response.id,
+                taskId,
+                reviewRecord,
+                sourceEventIds: [...dispatchCmEventIds, ...mainChatEventIds, ...peripheralEventIds, ...cmEventIds, ...computeEventIds],
+            });
+            const reviewCmEventIds = reviewCmEventId ? [reviewCmEventId] : [];
+            await appendLocalTaskStageEvent({
+                taskEventIds,
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "reported",
+                stage: "reviewing",
+                status: "running",
+                route: "core_cm",
+                summary: "Core CM is reviewing the result for the owner report.",
+                refs: [{
+                        eventIds: [...taskEventIds, ...dispatchCmEventIds, ...mainChatEventIds, ...peripheralEventIds, ...cmEventIds, ...reviewCmEventIds, ...computeEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                        ...(result.memoryProposal?.id ? { memoryProposalId: result.memoryProposal.id } : {}),
+                    }],
+                data: {
+                    ...coreTaskData,
+                    ...followUpTaskData,
+                    outputChars: output.length,
+                    peripheralEventCount: peripheralEventIds.length,
+                    cmEventCount: dispatchCmEventIds.length + cmEventIds.length + reviewCmEventIds.length,
+                    computeEventCount: computeEventIds.length,
+                    reviewRecord,
+                    reviewRecords,
+                    reviewRecordCount: reviewRecords.length,
+                    latestReviewQuality: reviewRecord.resultQuality,
+                    latestCompletionDecision: reviewRecord.completionDecision,
+                    followUpNeeded: reviewRecord.followUpNeeded,
+                    memoryProposalRefs: reviewRecord.memoryProposalRefs,
+                    reportText: reviewRecord.reportText,
+                    ...(result.memoryProposal?.id ? { memoryProposalId: result.memoryProposal.id } : {}),
                 },
-            },
+            });
+            const taskEndEventId = await appendLocalTaskEvent({
+                agentName: deps.agentName,
+                workdir,
+                conversationId: message.conversationId,
+                taskId,
+                phase: "completed",
+                stage: "done",
+                status: "succeeded",
+                route: "core_cm",
+                summary: summarizeCoreCmTaskOutcome({
+                    peripheralEventIds,
+                    cmEventIds,
+                    memoryProposal: result.memoryProposal,
+                    memoryAction: result.memoryAction,
+                }),
+                refs: [{
+                        eventIds: [...taskEventIds, ...dispatchCmEventIds, ...mainChatEventIds, ...peripheralEventIds, ...cmEventIds, ...reviewCmEventIds, ...computeEventIds],
+                        conversationId: message.conversationId,
+                        messageId: response.id,
+                        taskId,
+                        ...(result.memoryProposal?.id ? { memoryProposalId: result.memoryProposal.id } : {}),
+                    }],
+                data: {
+                    outputChars: output.length,
+                    peripheralEventCount: peripheralEventIds.length,
+                    cmEventCount: dispatchCmEventIds.length + cmEventIds.length + reviewCmEventIds.length,
+                    computeEventCount: computeEventIds.length,
+                    latestReviewQuality: reviewRecord.resultQuality,
+                    latestCompletionDecision: reviewRecord.completionDecision,
+                    followUpNeeded: reviewRecord.followUpNeeded,
+                    ...(result.memoryProposal?.id ? { memoryProposalId: result.memoryProposal.id } : {}),
+                    ...(result.memoryAction ? { memoryAction: createMemoryActionTaskData(result.memoryAction, "core_cm") } : {}),
+                },
+            });
+            if (taskEndEventId)
+                taskEventIds.push(taskEndEventId);
+            const task = await readLocalTaskResponseRecord({ workdir, agentName: deps.agentName, taskId });
+            const eventIds = createLocalChatEventIds({
+                mainChat: mainChatEventIds,
+                peripheral: peripheralEventIds,
+                cm: [...dispatchCmEventIds, ...cmEventIds, ...reviewCmEventIds],
+                compute: computeEventIds,
+                task: taskEventIds,
+            });
+            const cmItems = createCoreCmProcessItems(result.processNotes, eventIds);
+            if (!responseSent) {
+                writeJsonResponse(res, 200, {
+                    success: true,
+                    message,
+                    response,
+                    output,
+                    task: createOptionalTaskResponseRecord(task),
+                    taskView: createTaskViewResponse(task),
+                    memoryProposal: result.memoryProposal || null,
+                    eventIds,
+                    cmItems,
+                }, true);
+            }
+            if (deps.passiveReflection) {
+                const passiveReflectionEventIds = createLocalChatEventIds({
+                    mainChat: mainChatEventIds,
+                    peripheral: peripheralEventIds,
+                    cm: result.memoryProposal || result.memoryAction ? cmEventIds : [],
+                    compute: computeEventIds,
+                    task: taskEventIds,
+                });
+                schedulePassiveReflection({
+                    agentName: deps.agentName,
+                    workdir: deps.workdir || process.cwd(),
+                    conversationId: message.conversationId,
+                    eventIds: passiveReflectionEventIds,
+                    requestCompute: deps.requestCompute,
+                });
+            }
+            return;
+        }
+        const output = await submitLocalAkemonMessageToMcp({
+            localPort: deps.localPort,
+            message,
+        });
+        const response = createLocalAkemonResponseMessage({
+            request: message,
+            responderAgent: deps.agentName,
+            result: output,
         });
+        const mainChatEventIds = await appendLocalChatRound({
+            agentName: deps.agentName,
+            workdir: deps.workdir || process.cwd(),
+            conversationId: message.conversationId,
+            ownerMessageId: message.id,
+            akemonMessageId: response.id,
+            userText: text,
+            agentText: output,
+        });
+        writeJsonResponse(res, 200, {
+            success: true,
+            message,
+            response,
+            output,
+            eventIds: createLocalChatEventIds({ mainChat: mainChatEventIds }),
+        }, true);
     }
     catch (err) {
-        if (!streamStarted) {
-            const busy = String(err.message || "").includes("busy");
-            writeJsonResponse(res, busy ? 409 : 500, { error: err.message || String(err) });
-            responseFinished = true;
+        if (responseSent && acceptedAsyncTask) {
+            await appendLocalTaskEvent({
+                agentName: deps.agentName,
+                workdir: acceptedAsyncTask.workdir,
+                conversationId: acceptedAsyncTask.conversationId,
+                taskId: acceptedAsyncTask.taskId,
+                phase: "failed",
+                stage: "blocked",
+                status: "failed",
+                route: "core_cm",
+                summary: err.message || "Core CM task failed after async acceptance.",
+                refs: [{
+                        conversationId: acceptedAsyncTask.conversationId,
+                        messageId: acceptedAsyncTask.messageId,
+                        taskId: acceptedAsyncTask.taskId,
+                    }],
+                data: {
+                    source: "local_chat",
+                    acceptedAsync: true,
+                    error: err.message || String(err),
+                },
+            });
             return;
         }
-        writeSoftwareAgentStreamEvent(res, {
-            type: "error",
-            error: err.message || String(err),
+        writeJsonResponse(res, 400, { error: err.message || "Invalid local Akemon message" });
+    }
+}
+async function appendLocalChatRound(input) {
+    const eventIds = [];
+    if (!input.conversationId)
+        return eventIds;
+    try {
+        await appendRound(input.workdir, input.agentName, input.conversationId, input.userText, input.agentText);
+    }
+    catch (error) {
+        logBestEffortError("local chat conversation append", error);
+    }
+    try {
+        const ownerEvent = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "main_chat",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                role: "owner",
+                text: input.userText,
+                messageId: input.ownerMessageId,
+                refs: [
+                    {
+                        conversationId: input.conversationId,
+                        messageId: input.ownerMessageId,
+                        taskId: input.taskId,
+                    },
+                ],
+            },
+        });
+        eventIds.push(ownerEvent.id);
+        const akemonEvent = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "main_chat",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                role: "akemon",
+                text: input.agentText,
+                messageId: input.akemonMessageId,
+                refs: [
+                    {
+                        conversationId: input.conversationId,
+                        messageId: input.akemonMessageId,
+                        taskId: input.taskId,
+                    },
+                ],
+            },
         });
+        eventIds.push(akemonEvent.id);
     }
-    finally {
-        responseFinished = true;
-        if (streamStarted && !res.writableEnded)
-            res.end();
+    catch (error) {
+        logBestEffortError("local chat event append", error);
     }
+    return eventIds;
 }
-export async function handleSoftwareAgentStatusHttp(req, res, deps) {
-    if (!requireOwnerRequest(req, res, deps.options))
-        return;
-    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
-    if (!softwareAgent)
-        return;
-    writeJsonResponse(res, 200, softwareAgent.getState(), true);
+function createLocalChatEventIds(input) {
+    return {
+        mainChat: input.mainChat || [],
+        peripheral: input.peripheral || [],
+        cm: input.cm || [],
+        compute: input.compute || [],
+        task: input.task || [],
+    };
 }
-export async function handleSoftwareAgentTasksHttp(req, res, deps) {
-    if (!requireOwnerRequest(req, res, deps.options))
-        return;
-    const url = new URL(req.url || "/", "http://127.0.0.1");
-    const basePath = "/self/software-agent/tasks";
-    const taskLedgerDir = softwareAgentTaskLedgerDir(deps.workdir, deps.agentName);
-    if (url.pathname === basePath) {
-        const limit = readPositiveIntQuery(url.searchParams.get("limit"), 20, 100);
-        const tasks = listSoftwareAgentTaskRecords(taskLedgerDir, limit);
-        writeJsonResponse(res, 200, { tasks }, true);
+function createCoreCmProcessItems(processNotes, eventIds) {
+    return (processNotes || [])
+        .map((note) => (typeof note === "string" ? note.trim() : ""))
+        .filter(Boolean)
+        .map((text) => ({
+        type: "process",
+        title: "Core CM",
+        text,
+        status: "info",
+        eventIds,
+    }));
+}
+function createLocalChatTaskId(message) {
+    const suffix = message.id || `${message.conversationId || "local"}_${Date.now()}`;
+    return `task_${suffix.replace(/[^a-zA-Z0-9_.:-]/g, "_")}`;
+}
+function readLocalChatFollowUpTaskId(message) {
+    const value = message.metadata?.followUpForTaskId;
+    if (typeof value !== "string")
+        return null;
+    const taskId = value.trim();
+    if (!taskId || taskId.includes("/") || taskId.length > 220)
+        return null;
+    return taskId;
+}
+async function handleLocalChatFollowUpHttp(input) {
+    const existing = await readTaskRegistryRecord({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        taskId: input.taskId,
+    });
+    if (existing && (existing.stage === "done" || existing.stage === "blocked")) {
+        writeJsonResponse(input.res, 409, { error: `Task ${input.taskId} is already ${existing.stage}` });
         return;
     }
-    if (url.pathname.startsWith(`${basePath}/`)) {
-        const taskId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
-        if (!taskId || taskId.includes("/")) {
-            writeJsonResponse(res, 400, { error: "Invalid software-agent task id" });
-            return;
-        }
-        const task = readSoftwareAgentTaskRecord(taskLedgerDir, taskId);
-        if (!task) {
-            writeJsonResponse(res, 404, { error: "Software-agent task not found" });
-            return;
-        }
-        writeJsonResponse(res, 200, { task }, true);
+    if (existing && isExpiredLocalChatFollowUpTarget(existing)) {
+        await appendLocalTaskEvent({
+            agentName: input.agentName,
+            workdir: input.workdir,
+            conversationId: existing.conversationId || input.message.conversationId,
+            taskId: input.taskId,
+            phase: "failed",
+            stage: "blocked",
+            status: "failed",
+            route: existing.route || "core_cm",
+            summary: "Akemon stopped recovering a stale local chat task.",
+            refs: [{
+                    conversationId: input.message.conversationId,
+                    messageId: input.message.id,
+                    taskId: input.taskId,
+                }],
+            data: {
+                source: "local_chat_stale_recovery",
+                staleTaskCreatedAt: existing.createdAt,
+                staleTaskUpdatedAt: existing.updatedAt,
+            },
+        });
+        writeJsonResponse(input.res, 409, {
+            error: `Task ${input.taskId} is stale and can no longer accept follow-ups. Send a new message instead.`,
+        });
         return;
     }
-    writeJsonResponse(res, 404, { error: "Software-agent task endpoint not found" });
+    const followUp = createLocalChatFollowUp(input.text);
+    const followUps = appendTaskFollowUp(existing, followUp);
+    const output = formatLocalChatFollowUpAck(input.text, followUp.kind);
+    const response = createLocalAkemonResponseMessage({
+        request: input.message,
+        responderAgent: input.agentName,
+        result: output,
+    });
+    const taskEventIds = [];
+    const mainChatEventIds = await appendLocalChatRound({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        conversationId: input.message.conversationId,
+        ownerMessageId: input.message.id,
+        akemonMessageId: response.id,
+        taskId: input.taskId,
+        userText: input.text,
+        agentText: output,
+    });
+    await appendLocalTaskStageEvent({
+        taskEventIds,
+        agentName: input.agentName,
+        workdir: input.workdir,
+        conversationId: input.message.conversationId,
+        taskId: input.taskId,
+        phase: "received",
+        stage: existing?.stage || "queued",
+        status: existing?.status && existing.status !== "succeeded" && existing.status !== "failed"
+            ? existing.status
+            : "running",
+        route: existing?.route || "core_cm",
+        summary: `Owner ${followUp.kind} follow-up queued.`,
+        refs: [{
+                eventIds: mainChatEventIds,
+                conversationId: input.message.conversationId,
+                messageId: input.message.id,
+                taskId: input.taskId,
+            }],
+        data: {
+            source: "local_chat_follow_up",
+            followUp,
+            followUps,
+            followUpCount: followUps.length,
+            latestFollowUpKind: followUp.kind,
+            latestFollowUpText: followUp.text,
+        },
+    });
+    const task = await readLocalTaskResponseRecord({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        taskId: input.taskId,
+    });
+    writeJsonResponse(input.res, 200, {
+        success: true,
+        queued: true,
+        message: input.message,
+        response,
+        output,
+        followUp,
+        task: createOptionalTaskResponseRecord(task),
+        taskView: createTaskViewResponse(task),
+        eventIds: createLocalChatEventIds({
+            mainChat: mainChatEventIds,
+            task: taskEventIds,
+        }),
+    }, true);
 }
-function softwareAgentTaskLedgerDir(workdir, agentName) {
-    return join(workdir, ".akemon", "agents", agentName, "software-agent", "tasks");
+function isExpiredLocalChatFollowUpTarget(task) {
+    if (task.route !== "core_cm")
+        return false;
+    if (task.stage === "done" || task.stage === "blocked")
+        return false;
+    if (task.status === "succeeded" || task.status === "failed" || task.status === "info")
+        return false;
+    const createdAt = Date.parse(task.createdAt || "");
+    if (!Number.isFinite(createdAt))
+        return false;
+    return Date.now() - createdAt > LOCAL_CHAT_FOLLOW_UP_TARGET_MAX_AGE_MS;
 }
-function softwareAgentContextSessionDir(workdir, agentName) {
-    return join(workdir, ".akemon", "agents", agentName, "software-agent", "sessions");
+function createLocalChatFollowUp(text) {
+    return {
+        id: createCognitiveEventId("followup"),
+        kind: classifyLocalChatFollowUp(text),
+        text: truncateEventText(text.trim(), 1000),
+        createdAt: new Date().toISOString(),
+        status: "queued",
+    };
+}
+function appendTaskFollowUp(existing, followUp) {
+    const current = Array.isArray(existing?.data?.followUps)
+        ? existing.data.followUps
+            .map(normalizeTaskFollowUp)
+            .filter((item) => !!item)
+        : [];
+    return [...current, followUp].slice(-20);
+}
+function normalizeTaskFollowUp(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const item = value;
+    const text = typeof item.text === "string" ? item.text.trim() : "";
+    if (!text)
+        return null;
+    return {
+        id: typeof item.id === "string" && item.id ? item.id : createCognitiveEventId("followup"),
+        kind: isLocalChatFollowUpKind(item.kind) ? item.kind : "note",
+        text: truncateEventText(text, 1000),
+        createdAt: typeof item.createdAt === "string" && item.createdAt ? item.createdAt : new Date().toISOString(),
+        status: isLocalChatFollowUpStatus(item.status) ? item.status : "queued",
+        absorbedAt: typeof item.absorbedAt === "string" && item.absorbedAt ? item.absorbedAt : undefined,
+    };
+}
+function classifyLocalChatFollowUp(text) {
+    const normalized = text.trim().toLowerCase();
+    if (/^(correction|actually|instead|wait|no,|not that)\b/.test(normalized)
+        || /^(不是|不对|等等|等下|更正|纠正|改成)/.test(text.trim())) {
+        return "correction";
+    }
+    if (/(constraint|requirement|must|must not|do not|don't|only|never)\b/.test(normalized)
+        || /(不要|不能|必须|只能|不允许|限制|约束)/.test(text)) {
+        return "constraint";
+    }
+    if (/[?？]\s*$/.test(text)
+        || /^(why|how|what|when|where|can|could|should|will|is|are)\b/.test(normalized)
+        || /^(为什么|怎么|如何|是否|能不能|可以|会不会)/.test(text.trim())) {
+        return "question";
+    }
+    return "note";
+}
+function isLocalChatFollowUpKind(value) {
+    return value === "correction" || value === "constraint" || value === "question" || value === "note";
+}
+function isLocalChatFollowUpStatus(value) {
+    return value === "queued" || value === "absorbed";
+}
+function formatLocalChatFollowUpAck(text, kind) {
+    if (shouldUseChineseOwnerText(undefined, text)) {
+        const labels = {
+            correction: "修正",
+            constraint: "约束",
+            question: "问题",
+            note: "补充",
+        };
+        return `已把这条${labels[kind]}加入当前任务队列。`;
+    }
+    return `Queued this ${kind} for the current task.`;
+}
+async function readQueuedActionableFollowUps(input) {
+    const task = await readTaskRegistryRecord(input);
+    if (!Array.isArray(task?.data?.followUps))
+        return [];
+    return task.data.followUps
+        .map(normalizeTaskFollowUp)
+        .filter((item) => !!item
+        && item.status !== "absorbed"
+        && isActionableQueuedFollowUpKind(item.kind));
+}
+function createAbsorbedFollowUpTaskData(existing, absorbedFollowUps) {
+    const absorbedIds = new Set(absorbedFollowUps.map((followUp) => followUp.id).filter(Boolean));
+    if (!absorbedIds.size)
+        return {};
+    const now = new Date().toISOString();
+    const currentFollowUps = Array.isArray(existing?.data?.followUps)
+        ? existing.data.followUps
+            .map(normalizeTaskFollowUp)
+            .filter((item) => !!item)
+        : absorbedFollowUps;
+    const followUps = currentFollowUps.map((followUp) => absorbedIds.has(followUp.id)
+        ? {
+            ...followUp,
+            status: "absorbed",
+            absorbedAt: followUp.absorbedAt || now,
+        }
+        : followUp);
+    const absorbedFollowUpIds = followUps
+        .filter((followUp) => followUp.status === "absorbed")
+        .map((followUp) => followUp.id);
+    return {
+        followUps,
+        followUpCount: followUps.length,
+        pendingFollowUpCount: followUps.filter((followUp) => followUp.status !== "absorbed").length,
+        absorbedFollowUpCount: absorbedFollowUpIds.length,
+        absorbedFollowUpIds,
+    };
+}
+function isActionableQueuedFollowUpKind(kind) {
+    return kind === "question" || kind === "constraint" || kind === "correction";
+}
+function formatCoreCmQueuedFollowUpText(input) {
+    const lines = [
+        "Queued owner follow-up(s) arrived while Akemon was handling the current task.",
+        "",
+        "Original owner request:",
+        input.originalText,
+        "",
+        "Current Akemon result for the original request:",
+        input.currentOutput || "(no result yet)",
+        "",
+        "Queued owner follow-up(s) to incorporate now:",
+        ...input.followUps.map((followUp, index) => `${index + 1}. [${followUp.kind}] ${followUp.text}`),
+        "",
+        "Before completing the task, produce the final owner-facing report.",
+        "If a follow-up is a constraint, apply it when possible and state whether it changed the final answer or next action.",
+        "If a follow-up is a correction, revise the final answer when possible and state whether the earlier result needed correction.",
+        "If a follow-up is a question, answer it directly using the current result and available context.",
+        "If the task already performed an action that cannot be undone, say that clearly and propose the safest next step.",
+    ];
+    return lines.join("\n");
+}
+function mergeCoreCmQueuedFollowUpResult(input) {
+    return {
+        output: mergeCoreCmQueuedFollowUpOutput(input),
+        processNotes: [
+            ...(input.base.processNotes || []),
+            ...(input.followUp.processNotes || []),
+        ],
+        memoryProposal: input.followUp.memoryProposal || input.base.memoryProposal,
+        memoryAction: input.followUp.memoryAction || input.base.memoryAction,
+        review: input.followUp.review || input.base.review,
+    };
+}
+function mergeCoreCmQueuedFollowUpOutput(input) {
+    const baseOutput = input.base.output.trim();
+    const followUpOutput = input.followUp.output.trim();
+    if (!baseOutput)
+        return followUpOutput;
+    if (!followUpOutput)
+        return baseOutput;
+    const ownerText = input.followUps.map((followUp) => followUp.text).join("\n");
+    const includesQuestion = input.followUps.some((followUp) => followUp.kind === "question");
+    const includesRevision = input.followUps.some((followUp) => followUp.kind === "constraint" || followUp.kind === "correction");
+    if (includesQuestion && includesRevision) {
+        const mixedLabel = shouldUseChineseOwnerText(input.ownerLanguage, ownerText)
+            ? "关于你排队的后续问题、约束和修正："
+            : "Queued follow-up answer with applied correction/constraint:";
+        return `${baseOutput}\n\n${mixedLabel}\n${followUpOutput}`;
+    }
+    if (includesRevision) {
+        const revisionLabel = shouldUseChineseOwnerText(input.ownerLanguage, ownerText)
+            ? "已根据你排队的修正/约束更新最终报告："
+            : "Updated final report after queued correction/constraint:";
+        return `${revisionLabel}\n${followUpOutput}`;
+    }
+    const label = shouldUseChineseOwnerText(input.ownerLanguage, ownerText)
+        ? "关于你排队的后续问题："
+        : "Queued follow-up answer:";
+    return `${baseOutput}\n\n${label}\n${followUpOutput}`;
+}
+function shouldUseChineseOwnerText(_ownerLanguage, ownerText) {
+    return /[\u3400-\u9fff]/.test(ownerText || "");
+}
+function createCoreCmDispatchRecord(input) {
+    return {
+        id: createCognitiveEventId("dispatch"),
+        createdAt: new Date().toISOString(),
+        taskId: input.taskId,
+        conversationId: input.conversationId,
+        targetPeripheral: input.proposal.peripheral,
+        capability: input.proposal.capability,
+        brief: coreCmDispatchBrief(input.proposal, input.ownerText),
+        contextBoundary: {
+            includes: [
+                "owner request",
+                "current interactive-session context",
+                "relevant Akemon memory summary",
+            ],
+            excludes: [
+                "unbounded owner context",
+                "direct Akemon self-memory writes",
+                "peripheral-owned private state outside the requested capability",
+            ],
+        },
+        permissionBoundary: {
+            allowed: [`interactive-session.${input.proposal.capability}`],
+            forbidden: [
+                "memory writes without a Memory CM proposal",
+                "actions outside the selected interactive-session capability",
+            ],
+            requiresOwnerApproval: false,
+        },
+        expectedDeliverable: expectedInteractiveSessionDeliverable(input.proposal.capability),
+        reason: input.proposal.reason,
+        argsSummary: summarizeInteractiveSessionDispatchArgs(input.proposal),
+    };
+}
+function coreCmDispatchBrief(proposal, ownerText) {
+    if (proposal.reason?.trim())
+        return truncateEventText(proposal.reason.trim(), 260);
+    const target = proposal.peripheral === "workbench" ? "interactive-session" : proposal.peripheral;
+    const ownerBrief = truncateEventText(ownerText.trim(), 140);
+    return ownerBrief
+        ? `Use ${target}.${proposal.capability} for: ${ownerBrief}`
+        : `Use ${target}.${proposal.capability}.`;
+}
+function expectedInteractiveSessionDeliverable(capability) {
+    switch (capability) {
+        case "list_sessions":
+            return "List available interactive sessions and their owner-relevant state.";
+        case "inspect_session":
+        case "capture_output":
+            return "Return session status and recent output relevant to the owner request.";
+        case "start_session":
+            return "Return started session metadata and how the owner can observe or control it.";
+        case "send_input":
+            return "Return input delivery status and any observed output after the requested wait.";
+        case "set_input_mode":
+            return "Return confirmation of the session input mode change.";
+        case "stop_session":
+            return "Return confirmation that the session was asked to stop and current session state.";
+        case "resize_session":
+            return "Return confirmation of the terminal size update.";
+        default:
+            return "Return the peripheral observation needed for Core CM review.";
+    }
+}
+function summarizeInteractiveSessionDispatchArgs(proposal) {
+    const args = proposal.args || {};
+    const summary = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key === "input" && typeof value === "string") {
+            summary.inputChars = value.length;
+            summary.inputPreview = truncateEventText(value.replace(/\s+/g, " ").trim(), 120);
+        }
+        else if (key === "args" && Array.isArray(value)) {
+            summary.argsCount = value.length;
+        }
+        else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            summary[key] = value;
+        }
+    }
+    return Object.keys(summary).length ? summary : undefined;
+}
+function appendTaskDispatchRecord(existing, dispatchRecord) {
+    const current = Array.isArray(existing?.data?.dispatchRecords)
+        ? existing.data.dispatchRecords
+            .map(normalizeCoreCmDispatchRecord)
+            .filter((item) => !!item)
+        : [];
+    return [...current, dispatchRecord].slice(-20);
+}
+function normalizeCoreCmDispatchRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.id !== "string" || typeof record.targetPeripheral !== "string" || typeof record.capability !== "string")
+        return null;
+    return {
+        id: record.id,
+        createdAt: typeof record.createdAt === "string" ? record.createdAt : new Date().toISOString(),
+        taskId: typeof record.taskId === "string" ? record.taskId : "",
+        conversationId: typeof record.conversationId === "string" ? record.conversationId : undefined,
+        targetPeripheral: record.targetPeripheral,
+        capability: record.capability,
+        brief: typeof record.brief === "string" ? record.brief : `${record.targetPeripheral}.${record.capability}`,
+        contextBoundary: normalizeDispatchBoundary(record.contextBoundary),
+        permissionBoundary: normalizePermissionBoundary(record.permissionBoundary),
+        expectedDeliverable: typeof record.expectedDeliverable === "string" ? record.expectedDeliverable : "Return a peripheral observation.",
+        reason: typeof record.reason === "string" ? record.reason : undefined,
+        argsSummary: record.argsSummary && typeof record.argsSummary === "object" && !Array.isArray(record.argsSummary)
+            ? record.argsSummary
+            : undefined,
+    };
+}
+function normalizeDispatchBoundary(value) {
+    const record = value && typeof value === "object" ? value : {};
+    return {
+        includes: Array.isArray(record.includes) ? record.includes.filter((item) => typeof item === "string") : [],
+        excludes: Array.isArray(record.excludes) ? record.excludes.filter((item) => typeof item === "string") : [],
+    };
+}
+function normalizePermissionBoundary(value) {
+    const record = value && typeof value === "object" ? value : {};
+    return {
+        allowed: Array.isArray(record.allowed) ? record.allowed.filter((item) => typeof item === "string") : [],
+        forbidden: Array.isArray(record.forbidden) ? record.forbidden.filter((item) => typeof item === "string") : [],
+        requiresOwnerApproval: record.requiresOwnerApproval === true,
+    };
+}
+async function appendCoreCmDispatchRecordEvent(input) {
+    if (!input.conversationId)
+        return null;
+    try {
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "cm",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                cm: "core",
+                itemType: "dispatch_record",
+                status: "info",
+                summary: `Core CM dispatched ${input.dispatchRecord.capability} to ${input.dispatchRecord.targetPeripheral}.`,
+                data: {
+                    dispatchRecord: input.dispatchRecord,
+                },
+                refs: [{
+                        eventIds: input.sourceEventIds,
+                        conversationId: input.conversationId,
+                        messageId: input.ownerMessageId,
+                        taskId: input.taskId,
+                    }],
+            },
+        });
+        return event.id;
+    }
+    catch (error) {
+        logBestEffortError("Core CM dispatch event append", error);
+        return null;
+    }
+}
+function createCoreCmReviewRecord(input) {
+    const review = input.result.review;
+    const completionDecision = normalizeCoreCmCompletionDecision(review?.completionDecision)
+        || (input.output.trim() ? "complete" : "blocked");
+    const resultQuality = normalizeCoreCmResultQuality(review?.resultQuality)
+        || (completionDecision === "blocked" ? "failed" : "good");
+    const followUpNeeded = typeof review?.followUpNeeded === "boolean"
+        ? review.followUpNeeded
+        : completionDecision !== "complete";
+    const memoryProposalRefs = createCoreCmReviewMemoryProposalRefs(input.result);
+    return {
+        id: createCognitiveEventId("review"),
+        createdAt: new Date().toISOString(),
+        taskId: input.taskId,
+        conversationId: input.conversationId,
+        source: review ? "core_cm_observation_review" : "core_cm_task_report",
+        resultQuality,
+        completionDecision,
+        followUpNeeded,
+        memoryProposalRefs,
+        reportText: truncateEventText(review?.reportText || input.output, 4000),
+        summary: review?.summary || `Core CM reviewed the report with ${completionDecision} completion.`,
+        dispatchRecordId: input.dispatchRecord?.id,
+        targetPeripheral: input.dispatchRecord?.targetPeripheral,
+        capability: input.dispatchRecord?.capability,
+    };
+}
+function createCoreCmReviewMemoryProposalRefs(input) {
+    if (input.memoryProposal?.id) {
+        return [{
+                memoryProposalId: input.memoryProposal.id,
+                source: input.memoryProposal.source,
+                summary: input.memoryProposal.summary,
+            }];
+    }
+    const memoryActionProposalId = input.memoryAction?.resolvedProposalId || input.memoryAction?.proposalId;
+    if (!memoryActionProposalId)
+        return [];
+    return [{
+            memoryProposalId: memoryActionProposalId,
+            source: "memory_action",
+            summary: `Memory action ${input.memoryAction?.action || "unknown"} ${input.memoryAction?.status || "completed"}.`,
+        }];
+}
+function appendTaskReviewRecord(existing, reviewRecord) {
+    const current = Array.isArray(existing?.data?.reviewRecords)
+        ? existing.data.reviewRecords
+            .map(normalizeCoreCmReviewRecord)
+            .filter((item) => !!item)
+        : [];
+    return [...current, reviewRecord].slice(-20);
+}
+function normalizeCoreCmReviewRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.id !== "string" || typeof record.taskId !== "string")
+        return null;
+    const completionDecision = normalizeCoreCmCompletionDecision(record.completionDecision) || "complete";
+    const resultQuality = normalizeCoreCmResultQuality(record.resultQuality) || "good";
+    return {
+        id: record.id,
+        createdAt: typeof record.createdAt === "string" ? record.createdAt : new Date().toISOString(),
+        taskId: record.taskId,
+        conversationId: typeof record.conversationId === "string" ? record.conversationId : undefined,
+        source: record.source === "core_cm_observation_review" ? "core_cm_observation_review" : "core_cm_task_report",
+        resultQuality,
+        completionDecision,
+        followUpNeeded: record.followUpNeeded === true,
+        memoryProposalRefs: normalizeCoreCmReviewMemoryRefs(record.memoryProposalRefs),
+        reportText: typeof record.reportText === "string" ? record.reportText : "",
+        summary: typeof record.summary === "string" ? record.summary : undefined,
+        dispatchRecordId: typeof record.dispatchRecordId === "string" ? record.dispatchRecordId : undefined,
+        targetPeripheral: typeof record.targetPeripheral === "string" ? record.targetPeripheral : undefined,
+        capability: typeof record.capability === "string" ? record.capability : undefined,
+    };
+}
+function normalizeCoreCmReviewMemoryRefs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const record = item;
+        if (typeof record.memoryProposalId !== "string" || !record.memoryProposalId)
+            return [];
+        return [{
+                memoryProposalId: record.memoryProposalId,
+                source: typeof record.source === "string" ? record.source : undefined,
+                summary: typeof record.summary === "string" ? record.summary : undefined,
+            }];
+    });
+}
+function normalizeCoreCmResultQuality(value) {
+    return value === "good" || value === "partial" || value === "failed" || value === "uncertain"
+        ? value
+        : undefined;
+}
+function normalizeCoreCmCompletionDecision(value) {
+    return value === "complete" || value === "partial" || value === "blocked" || value === "needs_follow_up"
+        ? value
+        : undefined;
+}
+async function appendCoreCmReviewRecordEvent(input) {
+    if (!input.conversationId)
+        return null;
+    try {
+        const memoryProposalId = input.reviewRecord.memoryProposalRefs[0]?.memoryProposalId;
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "cm",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                cm: "core",
+                itemType: "review_record",
+                status: input.reviewRecord.completionDecision === "blocked" ? "failed" : "info",
+                summary: `Core CM reviewed the report: ${input.reviewRecord.completionDecision} (${input.reviewRecord.resultQuality}).`,
+                memoryProposalId,
+                data: {
+                    reviewRecord: input.reviewRecord,
+                },
+                refs: [{
+                        eventIds: input.sourceEventIds,
+                        conversationId: input.conversationId,
+                        messageId: input.akemonMessageId || input.ownerMessageId,
+                        taskId: input.taskId,
+                        memoryProposalId,
+                    }],
+            },
+        });
+        return event.id;
+    }
+    catch (error) {
+        logBestEffortError("Core CM review event append", error);
+        return null;
+    }
+}
+async function appendLocalTaskEvent(input) {
+    try {
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "task",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                phase: input.phase,
+                stage: input.stage,
+                status: input.status,
+                summary: input.summary,
+                route: input.route,
+                refs: input.refs,
+                data: input.data,
+            },
+        });
+        try {
+            await upsertTaskRegistryRecordFromEvent({
+                workdir: input.workdir,
+                agentName: input.agentName,
+                event: event,
+            });
+        }
+        catch (error) {
+            logBestEffortError("task registry upsert", error);
+        }
+        return event.id;
+    }
+    catch (error) {
+        logBestEffortError("local task event append", error);
+        return null;
+    }
+}
+async function appendLocalTaskStageEvent(input) {
+    const eventId = await appendLocalTaskEvent(input);
+    if (eventId)
+        input.taskEventIds.push(eventId);
+}
+async function readLocalTaskResponseRecord(input) {
+    try {
+        return await readTaskRegistryRecord(input);
+    }
+    catch (error) {
+        logBestEffortError("task registry read", error);
+        return null;
+    }
+}
+function createTaskResponseRecord(task) {
+    return {
+        ...task,
+        view: createTaskSurfaceView(task),
+    };
+}
+function createOptionalTaskResponseRecord(task) {
+    return task ? createTaskResponseRecord(task) : null;
+}
+function createTaskViewResponse(task) {
+    return task ? createTaskSurfaceView(task) : null;
+}
+function summarizeCoreCmTaskOutcome(input) {
+    if (input.memoryAction) {
+        return `Core CM completed the request through Memory CM: ${summarizeMemoryActionExecution(input.memoryAction)}`;
+    }
+    if (input.memoryProposal?.id) {
+        return "Core CM completed the request and produced a memory proposal.";
+    }
+    if (input.peripheralEventIds.length > 0) {
+        return "Core CM completed the request after observing a peripheral result.";
+    }
+    if (input.cmEventIds.length > 0) {
+        return "Core CM completed the request with internal CM notes.";
+    }
+    return "Core CM completed the request with a direct answer.";
+}
+async function appendMemoryActionCmEvent(input) {
+    if (!input.conversationId)
+        return null;
+    try {
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "cm",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                cm: "memory",
+                itemType: "memory_action",
+                status: cmStatusForMemoryAction(input.memoryAction),
+                summary: summarizeMemoryActionExecution(input.memoryAction),
+                memoryProposalId: input.memoryAction.resolvedProposalId || input.memoryAction.proposalId,
+                data: createMemoryActionTaskData(input.memoryAction, "memory_cm"),
+                refs: [{
+                        eventIds: input.sourceEventIds,
+                        conversationId: input.conversationId,
+                        messageId: input.akemonMessageId || input.ownerMessageId,
+                        memoryProposalId: input.memoryAction.resolvedProposalId || input.memoryAction.proposalId,
+                        taskId: input.taskId,
+                    }],
+            },
+        });
+        return event.id;
+    }
+    catch (error) {
+        logBestEffortError("memory action CM event append", error);
+        return null;
+    }
+}
+function cmStatusForMemoryAction(result) {
+    if (result.status === "accepted")
+        return "accepted";
+    if (result.status === "rejected")
+        return "rejected";
+    if (result.status === "revised")
+        return "revised";
+    if (result.status === "not_found" || result.status === "invalid")
+        return "failed";
+    return "info";
+}
+function summarizeMemoryActionExecution(result) {
+    if (result.status === "accepted")
+        return "Memory CM accepted a pending memory proposal.";
+    if (result.status === "rejected")
+        return "Memory CM rejected a pending memory proposal.";
+    if (result.status === "revised")
+        return "Memory CM revised a pending memory proposal.";
+    if (result.status === "listed")
+        return "Memory CM listed pending memory proposals.";
+    if (result.status === "shown")
+        return "Memory CM showed current memory.";
+    if (result.status === "not_found")
+        return "Memory CM could not find the requested pending memory proposal.";
+    if (result.status === "invalid")
+        return "Memory CM could not apply the requested memory action.";
+    return `Memory CM completed ${result.action}.`;
+}
+function createMemoryActionTaskData(result, source) {
+    return {
+        source,
+        action: result.action,
+        status: result.status,
+        proposalId: result.proposalId,
+        resolvedProposalId: result.resolvedProposalId,
+        scope: result.scope,
+        selfCount: result.selfCount,
+        workCount: result.workCount,
+        writtenWorkMemoryPathCount: result.writtenWorkMemoryPaths?.length || 0,
+        outputChars: result.output.length,
+        error: result.error,
+    };
+}
+async function appendOwnerDirectInteractiveSessionEvents(input) {
+    const eventIds = { task: [], peripheral: [] };
+    if (!input.agentName || !input.workdir)
+        return eventIds;
+    const taskId = createOwnerDirectTaskId("interactive_session", input.action.capability);
+    const taskStartEventId = await appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: "delegated",
+        stage: "dispatching",
+        status: "running",
+        route: "interactive-session",
+        summary: `Owner requested ${interactiveSessionCapabilityOwnerLabel(input.action.capability)}.`,
+        refs: [{
+                taskId,
+                sessionId: interactiveSessionObservationSessionId(input.observation, input.action),
+            }],
+        data: {
+            source: input.source,
+            objective: interactiveSessionCapabilityOwnerLabel(input.action.capability),
+            capability: input.action.capability,
+        },
+    });
+    if (taskStartEventId)
+        eventIds.task.push(taskStartEventId);
+    const peripheralEventId = await appendInteractiveSessionPeripheralEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        action: input.action,
+        observation: input.observation,
+    });
+    if (peripheralEventId)
+        eventIds.peripheral.push(peripheralEventId);
+    const taskEndEventId = await appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: input.observation.ok ? "completed" : "failed",
+        stage: input.observation.ok ? "done" : "blocked",
+        status: input.observation.ok ? "succeeded" : "failed",
+        route: "interactive-session",
+        summary: summarizeInteractiveSessionTaskCompletion(input.action.capability, input.observation.ok),
+        refs: [{
+                taskId,
+                eventIds: [...eventIds.task, ...eventIds.peripheral],
+                sessionId: interactiveSessionObservationSessionId(input.observation, input.action),
+            }],
+        data: createInteractiveSessionTaskData({
+            source: input.source,
+            action: input.action,
+            observation: input.observation,
+        }),
+    });
+    if (taskEndEventId)
+        eventIds.task.push(taskEndEventId);
+    return eventIds;
+}
+function createOwnerDirectTaskId(kind, label) {
+    const safeLabel = label.replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 60) || "task";
+    return createCognitiveEventId(`task_${kind}_${safeLabel}`);
+}
+function summarizeInteractiveSessionTaskCompletion(capability, ok) {
+    const label = interactiveSessionCapabilityOwnerLabel(capability);
+    return ok ? `${label} completed.` : `${label} failed.`;
+}
+function interactiveSessionCapabilityOwnerLabel(capability) {
+    switch (capability) {
+        case "start_session": return "terminal start";
+        case "send_input": return "terminal input";
+        case "resize_session": return "terminal resize";
+        case "stop_session": return "terminal stop";
+        case "inspect_session": return "terminal inspect";
+        case "set_input_mode": return "terminal input mode change";
+        case "list_sessions": return "terminal session list";
+        default: return `terminal action ${capability}`;
+    }
+}
+function ensureSoftwareAgentEnvelopeTaskId(envelope) {
+    if (!envelope.taskId)
+        envelope.taskId = createCognitiveEventId("task_software_agent");
+    return envelope.taskId;
+}
+async function appendSoftwareAgentTaskStartEvent(input) {
+    const taskId = ensureSoftwareAgentEnvelopeTaskId(input.envelope);
+    return appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: "delegated",
+        stage: "dispatching",
+        status: "running",
+        route: "software-agent",
+        summary: `Owner delegated a software-agent task: ${truncateEventText(input.envelope.goal || input.envelope.purpose || taskId, 180)}`,
+        refs: [{ taskId }],
+        data: {
+            source: input.envelope.sourceModule,
+            softwareAgentId: input.softwareAgentId || "software-agent",
+            purpose: input.envelope.purpose,
+            goal: input.envelope.goal,
+            goalChars: (input.envelope.goal || "").length,
+            workdir: input.envelope.workdir,
+            roleScope: input.envelope.roleScope,
+            memoryScope: input.envelope.memoryScope,
+            riskLevel: input.envelope.riskLevel,
+            contextSessionId: input.envelope.contextSessionId,
+            workMemoryDir: input.envelope.workMemoryDir,
+            taskRecordPath: softwareAgentTaskRecordPath(softwareAgentTaskLedgerDir(input.workdir, input.agentName), taskId),
+        },
+    });
+}
+async function appendSoftwareAgentTaskEndEvents(input) {
+    const eventIds = { task: [], peripheral: [] };
+    const taskId = input.result.taskId || ensureSoftwareAgentEnvelopeTaskId(input.envelope);
+    const taskRecordPath = softwareAgentTaskRecordPath(softwareAgentTaskLedgerDir(input.workdir, input.agentName), taskId);
+    try {
+        const peripheralEvent = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "peripheral",
+                taskId,
+                peripheral: input.softwareAgentId || "software-agent",
+                capability: "send_task",
+                ok: input.result.success,
+                summary: input.result.success
+                    ? `Software-agent task ${taskId} completed.`
+                    : `Software-agent task ${taskId} failed.`,
+                observation: {
+                    taskId,
+                    success: input.result.success,
+                    exitCode: input.result.exitCode,
+                    durationMs: input.result.durationMs,
+                    outputChars: (input.result.output || "").length,
+                    error: input.result.error,
+                    contextSessionId: input.result.contextSessionId,
+                    contextPacketPath: input.result.contextPacketPath,
+                    workMemoryDir: input.result.workMemoryDir,
+                    taskRecordPath,
+                },
+                refs: [{
+                        taskId,
+                        eventIds: input.sourceEventIds || [],
+                    }],
+            },
+        });
+        eventIds.peripheral.push(peripheralEvent.id);
+    }
+    catch (error) {
+        logBestEffortError("software-agent peripheral event append", error);
+    }
+    const taskEndEventId = await appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: input.result.success ? "completed" : "failed",
+        stage: input.result.success ? "done" : "blocked",
+        status: input.result.success ? "succeeded" : "failed",
+        route: "software-agent",
+        summary: input.result.success
+            ? `Software-agent task ${taskId} completed.`
+            : `Software-agent task ${taskId} failed.`,
+        refs: [{
+                taskId,
+                eventIds: [...(input.sourceEventIds || []), ...eventIds.peripheral],
+            }],
+        data: {
+            softwareAgentId: input.softwareAgentId || "software-agent",
+            success: input.result.success,
+            exitCode: input.result.exitCode,
+            durationMs: input.result.durationMs,
+            outputChars: (input.result.output || "").length,
+            error: input.result.error,
+            contextSessionId: input.result.contextSessionId,
+            contextPacketPath: input.result.contextPacketPath,
+            workMemoryDir: input.result.workMemoryDir,
+            taskRecordPath,
+        },
+    });
+    if (taskEndEventId)
+        eventIds.task.push(taskEndEventId);
+    return eventIds;
+}
+async function appendSoftwareAgentTaskFailureEvent(input) {
+    const taskId = ensureSoftwareAgentEnvelopeTaskId(input.envelope);
+    return appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: "failed",
+        stage: "blocked",
+        status: "failed",
+        route: "software-agent",
+        summary: `Software-agent task ${taskId} failed before producing a result.`,
+        refs: [{
+                taskId,
+                eventIds: input.sourceEventIds || [],
+            }],
+        data: {
+            softwareAgentId: input.softwareAgentId || "software-agent",
+            error: input.error,
+            taskRecordPath: softwareAgentTaskRecordPath(softwareAgentTaskLedgerDir(input.workdir, input.agentName), taskId),
+        },
+    });
+}
+function truncateEventText(value, maxChars) {
+    const text = value.trim();
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+async function appendInteractiveSessionOutcomeEvent(input) {
+    const { snapshot } = input.event;
+    const taskId = `task_interactive_session_${snapshot.sessionId}`;
+    await appendLocalTaskEvent({
+        agentName: input.agentName,
+        workdir: input.workdir,
+        taskId,
+        phase: snapshot.status === "failed" ? "failed" : "completed",
+        stage: snapshot.status === "failed" ? "blocked" : "done",
+        status: snapshot.status === "failed" ? "failed" : "succeeded",
+        route: "interactive-session",
+        summary: `Interactive session ${snapshot.sessionId} ended with status ${snapshot.status}.`,
+        refs: [{
+                taskId,
+                sessionId: snapshot.sessionId,
+            }],
+        data: {
+            source: "interactive_session_exit",
+            sessionId: snapshot.sessionId,
+            tool: snapshot.tool,
+            status: snapshot.status,
+            command: snapshot.commandLineDisplay,
+            workdir: snapshot.workdir,
+            logPath: snapshot.logPath,
+            outputChars: snapshot.outputChars,
+            exitCode: input.event.exitCode,
+            signal: input.event.signal,
+            startedAt: snapshot.startedAt,
+            endedAt: snapshot.endedAt,
+        },
+    });
+}
+function schedulePassiveReflection(input) {
+    setTimeout(() => {
+        runPassiveReflectionOnce(input).catch((error) => {
+            logBestEffortError("passive reflection", error);
+        });
+    }, 0);
+}
+async function appendComputeAuditEvent(input) {
+    const summary = {
+        origin: input.req.origin,
+        taskKind: input.req.taskKind,
+        purpose: input.req.purpose,
+        priority: input.req.priority,
+        routeId: input.invocation?.routeId,
+        resourceId: input.invocation?.resourceId,
+        resourceKind: input.invocation?.resourceKind,
+        provider: input.invocation?.provider,
+        protocol: input.invocation?.protocol,
+        engine: input.invocation?.engine,
+        model: input.invocation?.model,
+        reasoningEffort: input.invocation?.reasoningEffort,
+        verbosity: input.invocation?.verbosity,
+        command: input.invocation?.command,
+        inputChars: input.promptChars,
+        outputChars: input.outputChars,
+        durationMs: input.durationMs,
+        success: input.success,
+        ...(input.error ? { error: input.error } : {}),
+    };
+    try {
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "compute",
+                taskId: input.req.taskId,
+                ...summary,
+                refs: input.req.refs || [],
+            },
+        });
+        return { ...summary, eventId: event.id };
+    }
+    catch (error) {
+        logBestEffortError("compute audit event append", error);
+        return summary;
+    }
+}
+async function appendInteractiveSessionPeripheralEvent(input) {
+    try {
+        const sessionId = interactiveSessionObservationSessionId(input.observation, input.action);
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "peripheral",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                peripheral: input.observation.peripheral,
+                capability: input.observation.capability,
+                ok: input.observation.ok,
+                summary: input.observation.summary,
+                sessionId,
+                actionReason: input.action.reason,
+                observation: {
+                    capability: input.observation.capability,
+                    ok: input.observation.ok,
+                    summary: input.observation.summary,
+                    data: input.observation.data,
+                    error: input.observation.error,
+                },
+                refs: [
+                    {
+                        conversationId: input.conversationId,
+                        messageId: input.ownerMessageId,
+                        sessionId,
+                        taskId: input.taskId,
+                    },
+                ],
+            },
+        });
+        return event.id;
+    }
+    catch (error) {
+        logBestEffortError("interactive session peripheral event append", error);
+        return null;
+    }
+}
+async function appendCoreCmResultEvents(input) {
+    const eventIds = [];
+    if (!input.conversationId)
+        return eventIds;
+    try {
+        const processNotes = (input.processNotes || [])
+            .map((note) => (typeof note === "string" ? note.trim() : ""))
+            .filter(Boolean);
+        for (let index = 0; index < processNotes.length; index += 1) {
+            const event = await appendCognitiveEvent({
+                workdir: input.workdir,
+                agentName: input.agentName,
+                event: {
+                    stream: "cm",
+                    taskId: input.taskId,
+                    conversationId: input.conversationId,
+                    cm: "core",
+                    itemType: "process_note",
+                    status: "info",
+                    summary: processNotes[index],
+                    data: {
+                        order: index + 1,
+                    },
+                    refs: [
+                        {
+                            eventIds: input.sourceEventIds,
+                            conversationId: input.conversationId,
+                            messageId: input.akemonMessageId || input.ownerMessageId,
+                            taskId: input.taskId,
+                        },
+                    ],
+                },
+            });
+            eventIds.push(event.id);
+        }
+        if (input.memoryAction) {
+            const memoryActionEventId = await appendMemoryActionCmEvent({
+                agentName: input.agentName,
+                workdir: input.workdir,
+                conversationId: input.conversationId,
+                ownerMessageId: input.ownerMessageId,
+                akemonMessageId: input.akemonMessageId,
+                sourceEventIds: input.sourceEventIds,
+                taskId: input.taskId,
+                memoryAction: input.memoryAction,
+            });
+            if (memoryActionEventId)
+                eventIds.push(memoryActionEventId);
+        }
+        if (!input.memoryProposal)
+            return eventIds;
+        const proposal = input.memoryProposal;
+        const event = await appendCognitiveEvent({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            event: {
+                stream: "cm",
+                taskId: input.taskId,
+                conversationId: input.conversationId,
+                cm: "memory",
+                itemType: "memory_proposal",
+                status: "pending",
+                summary: proposal.summary || "Akemon Memory CM created a pending memory proposal.",
+                memoryProposalId: proposal.id,
+                data: {
+                    source: proposal.source,
+                    selfCount: Array.isArray(proposal.self) ? proposal.self.length : 0,
+                    workCount: Array.isArray(proposal.work) ? proposal.work.length : 0,
+                },
+                refs: [
+                    {
+                        eventIds: input.sourceEventIds,
+                        conversationId: input.conversationId,
+                        messageId: input.akemonMessageId || input.ownerMessageId,
+                        memoryProposalId: proposal.id,
+                        taskId: input.taskId,
+                    },
+                ],
+            },
+        });
+        eventIds.push(event.id);
+    }
+    catch (error) {
+        logBestEffortError("Core CM result event append", error);
+    }
+    return eventIds;
+}
+async function executeInteractiveSessionViaPeripheral(workbench, peripheral, action) {
+    return peripheral ? peripheral.execute(action) : executeInteractiveSessionAction(workbench, action);
+}
+function interactiveSessionObservationSessionId(observation, action) {
+    const observedSession = observation.data?.session;
+    if (observedSession && typeof observedSession === "object") {
+        const sessionId = observedSession.sessionId;
+        if (typeof sessionId === "string" && sessionId)
+            return sessionId;
+    }
+    const args = action?.args;
+    return typeof args?.sessionId === "string" && args.sessionId ? args.sessionId : undefined;
+}
+function createInvalidInteractiveSessionObservation(message) {
+    return {
+        kind: "peripheral_observation",
+        peripheral: "interactive-session",
+        capability: "list_sessions",
+        ok: false,
+        summary: message,
+        error: message,
+    };
+}
+function createInteractiveSessionTaskData(input) {
+    return {
+        source: input.source,
+        capability: input.observation.capability,
+        ok: input.observation.ok,
+        sessionId: interactiveSessionObservationSessionId(input.observation, input.action),
+        outputChars: input.outputChars,
+        error: input.observation.error,
+    };
+}
+async function executeInteractiveSessionActionProposal(workbench, peripheral, proposal) {
+    const action = {
+        capability: proposal.capability,
+        args: proposal.args,
+        reason: proposal.reason,
+    };
+    if (peripheral)
+        return peripheral.execute(action);
+    if (!workbench) {
+        return {
+            kind: "peripheral_observation",
+            peripheral: "interactive-session",
+            capability: proposal.capability,
+            ok: false,
+            reason: proposal.reason,
+            summary: "I could not use interactive sessions because the adapter is not available in this runtime.",
+            error: "Interactive session adapter is not available in this runtime.",
+        };
+    }
+    return executeInteractiveSessionAction(workbench, action);
+}
+function parseMemoryChatCommand(input) {
+    const trimmed = input.text.trim();
+    if (!trimmed.startsWith("/memory"))
+        return null;
+    const tokens = splitWorkbenchCommandLine(trimmed.slice("/memory".length).trim());
+    const action = tokens[0] || "pending";
+    if (["pending", "list", "list_pending"].includes(action)) {
+        return {
+            proposal: {
+                kind: "memory_action",
+                action: "list_pending",
+                proposalId: tokens[1] || "latest",
+                scope: "all",
+            },
+        };
+    }
+    if (["show", "current", "status", "what"].includes(action)) {
+        return {
+            proposal: {
+                kind: "memory_action",
+                action: "show_memory",
+                scope: parseMemoryCommandScope(tokens[1]),
+            },
+        };
+    }
+    if (["revise", "update", "edit"].includes(action)) {
+        let proposalId = tokens[1] || "latest";
+        let rest = tokens.slice(2);
+        if (isMemoryCommandScope(proposalId)) {
+            rest = tokens.slice(1);
+            proposalId = "latest";
+        }
+        const scope = isMemoryCommandScope(rest[0]) ? parseMemoryCommandScope(rest.shift()) : "work";
+        const revisedText = rest.join(" ").trim();
+        if (!revisedText) {
+            return { output: "Usage: /memory revise [proposalId|latest] [self|work] <replacement memory text>" };
+        }
+        return {
+            proposal: {
+                kind: "memory_action",
+                action: "revise_pending",
+                proposalId,
+                scope,
+                memory: scope === "self" ? { self: [revisedText] } : { work: [revisedText] },
+            },
+        };
+    }
+    if (["accept", "remember", "accept_pending"].includes(action)) {
+        return {
+            proposal: {
+                kind: "memory_action",
+                action: "accept_pending",
+                proposalId: tokens[1] || "latest",
+                scope: parseMemoryCommandScope(tokens[2]),
+            },
+        };
+    }
+    if (["reject", "ignore", "reject_pending"].includes(action)) {
+        return {
+            proposal: {
+                kind: "memory_action",
+                action: "reject_pending",
+                proposalId: tokens[1] || "latest",
+                scope: "all",
+            },
+        };
+    }
+    return { output: "Usage: /memory pending | /memory show [all|self|work] | /memory revise [proposalId|latest] [self|work] <text> | /memory accept [proposalId|latest] [all|self|work] | /memory reject [proposalId|latest]" };
+}
+function parseMemoryCommandScope(value) {
+    return value === "self" || value === "work" || value === "all" ? value : "all";
+}
+function isMemoryCommandScope(value) {
+    return value === "self" || value === "work" || value === "all";
+}
+function executeReflectionChatCommand(input) {
+    const trimmed = input.text.trim();
+    const command = trimmed.match(/^\/([a-zA-Z][a-zA-Z0-9_-]*)/)?.[1] || "";
+    if (!["reflection", "reflections"].includes(command))
+        return null;
+    const tokens = splitWorkbenchCommandLine(trimmed.slice(command.length + 1).trim());
+    const action = tokens[0] || "show";
+    if (!["show", "list", "latest", "recent"].includes(action)) {
+        return Promise.resolve("Usage: /reflection show [count]");
+    }
+    const countToken = action === "latest" ? "1" : tokens[1];
+    const count = readReflectionCount(countToken);
+    return formatRecentReflectionRecords(input.workdir, input.agentName, count);
+}
+async function formatRecentReflectionRecords(workdir, agentName, count) {
+    const records = await readCognitiveArtifacts({
+        workdir,
+        agentName,
+        kind: "reflection",
+        limit: count,
+    });
+    if (!records.length) {
+        return "Reflection CM 目前还没有留下反思记录。它只会在主聊天产生外设观察或 CM 事件后，异步记录高价值发现。";
+    }
+    const newestFirst = [...records].reverse();
+    const lines = newestFirst.flatMap((record, index) => {
+        const score = typeof record.valueScore === "number" ? `，价值 ${Math.round(record.valueScore * 100)}%` : "";
+        const header = `${index + 1}. ${formatShortTimestamp(record.createdAt)}，Reflection CM 发现：${record.insight}`;
+        const details = [
+            `原因：${record.reasoning}`,
+            ...(record.suggestedAction ? [`建议：${record.suggestedAction}`] : []),
+            `信心：${formatConfidence(record.confidence)}${score}`,
+        ];
+        return [header, ...details, ""];
+    });
+    return [`最近 ${records.length} 条 Reflection CM 记录：`, "", ...lines].join("\n").trim();
+}
+function readReflectionCount(token) {
+    const count = Number(token || 5);
+    if (!Number.isFinite(count) || count <= 0)
+        return 5;
+    return Math.max(1, Math.min(20, Math.floor(count)));
+}
+function formatShortTimestamp(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return value;
+    return date.toLocaleString("zh-CN", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+}
+function formatConfidence(value) {
+    if (value === "high")
+        return "高";
+    if (value === "low")
+        return "低";
+    return "中";
+}
+function parseWorkbenchChatCommandAction(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const command = trimmed.match(/^\/([a-zA-Z][a-zA-Z0-9_-]*)/)?.[1] || "";
+    if (!["start", "sessions", "input", "mode", "input-mode", "stop", "resize"].includes(command))
+        return null;
+    try {
+        switch (command) {
+            case "sessions":
+                return {
+                    action: {
+                        capability: "list_sessions",
+                        reason: "owner used /sessions in Akemon chat",
+                    },
+                };
+            case "start": {
+                const tokens = splitWorkbenchCommandLine(trimmed.slice("/start".length).trim());
+                if (!tokens.length) {
+                    throw new Error("Usage: /start <codex|claude|cursor|shell|custom> [args...]");
+                }
+                const tool = normalizeWorkbenchTool(tokens[0]);
+                const request = tool === "custom"
+                    ? {
+                        tool,
+                        command: tokens[1],
+                        args: tokens.slice(2),
+                    }
+                    : {
+                        tool,
+                        args: tokens.slice(1),
+                    };
+                return {
+                    action: {
+                        capability: "start_session",
+                        args: request,
+                        reason: "owner used /start in Akemon chat",
+                    },
+                };
+            }
+            case "input": {
+                const match = trimmed.match(/^\/input\s+(\S+)\s+([\s\S]+)$/);
+                if (!match)
+                    throw new Error("Usage: /input <sessionId> <text>");
+                return {
+                    action: {
+                        capability: "send_input",
+                        args: {
+                            sessionId: match[1],
+                            input: match[2],
+                        },
+                        reason: "owner used /input in Akemon chat",
+                    },
+                };
+            }
+            case "mode":
+            case "input-mode": {
+                const tokens = splitWorkbenchCommandLine(trimmed.slice(command === "mode" ? "/mode".length : "/input-mode".length).trim());
+                if (tokens.length !== 2)
+                    throw new Error(`Usage: /${command} <sessionId|active|latest> <line|tui>`);
+                return {
+                    action: {
+                        capability: "set_input_mode",
+                        args: {
+                            sessionId: tokens[0],
+                            inputMode: normalizeWorkbenchInputMode(tokens[1]),
+                        },
+                        reason: `owner used /${command} in Akemon chat`,
+                    },
+                };
+            }
+            case "stop": {
+                const tokens = splitWorkbenchCommandLine(trimmed.slice("/stop".length).trim());
+                if (tokens.length !== 1)
+                    throw new Error("Usage: /stop <sessionId>");
+                return {
+                    action: {
+                        capability: "stop_session",
+                        args: { sessionId: tokens[0] },
+                        reason: "owner used /stop in Akemon chat",
+                    },
+                };
+            }
+            case "resize": {
+                const tokens = splitWorkbenchCommandLine(trimmed.slice("/resize".length).trim());
+                if (tokens.length !== 3)
+                    throw new Error("Usage: /resize <sessionId> <cols> <rows>");
+                const cols = Number(tokens[1]);
+                const rows = Number(tokens[2]);
+                if (!Number.isInteger(cols) || cols <= 0 || !Number.isInteger(rows) || rows <= 0) {
+                    throw new Error("Usage: /resize <sessionId> <cols> <rows>");
+                }
+                return {
+                    action: {
+                        capability: "resize_session",
+                        args: {
+                            sessionId: tokens[0],
+                            cols,
+                            rows,
+                        },
+                        reason: "owner used /resize in Akemon chat",
+                    },
+                };
+            }
+            default:
+                return null;
+        }
+    }
+    catch (error) {
+        return { error: `I could not complete this Workbench action: ${error?.message || String(error)}` };
+    }
+}
+function splitWorkbenchCommandLine(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    for (const char of input) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            else
+                current += char;
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (escaping)
+        throw new Error("Invalid Workbench command: trailing escape");
+    if (quote)
+        throw new Error("Invalid Workbench command: unterminated quote");
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+export async function handleSoftwareAgentRunStreamHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
+        return;
+    const envelope = await readOwnerSoftwareAgentEnvelope(req, res, deps);
+    if (!envelope)
+        return;
+    ensureSoftwareAgentEnvelopeTaskId(envelope);
+    const taskEventIds = [];
+    const taskStartEventId = await appendSoftwareAgentTaskStartEvent({
+        agentName: deps.agentName,
+        workdir: deps.workdir,
+        envelope,
+        softwareAgentId: deps.softwareAgent?.id,
+    });
+    if (taskStartEventId)
+        taskEventIds.push(taskStartEventId);
+    const abortController = new AbortController();
+    let responseFinished = false;
+    let streamStarted = false;
+    res.on("close", () => {
+        if (!responseFinished)
+            abortController.abort();
+    });
+    const ensureStreamStarted = () => {
+        if (streamStarted)
+            return;
+        streamStarted = true;
+        res.writeHead(200, {
+            "Content-Type": "application/x-ndjson; charset=utf-8",
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        });
+        res.flushHeaders?.();
+    };
+    try {
+        const result = await softwareAgent.sendTask(envelope, {
+            signal: abortController.signal,
+            observer: {
+                onStart(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: "start",
+                        taskId: event.taskId,
+                        commandLine: event.commandLine,
+                        contextSessionId: event.contextSessionId,
+                        contextPacketPath: event.contextPacketPath,
+                        workMemoryDir: event.workMemoryDir,
+                    });
+                },
+                onStream(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: event.stream,
+                        taskId: event.taskId,
+                        chunk: event.chunk,
+                    });
+                },
+                onEnd(event) {
+                    ensureStreamStarted();
+                    writeSoftwareAgentStreamEvent(res, {
+                        type: "end",
+                        taskId: event.taskId,
+                        exitCode: event.exitCode,
+                        durationMs: event.durationMs,
+                        result: event.result,
+                        contextSessionId: event.contextSessionId,
+                        contextPacketPath: event.contextPacketPath,
+                        workMemoryDir: event.workMemoryDir,
+                    });
+                },
+            },
+        });
+        await appendSoftwareAgentTaskEndEvents({
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+            envelope,
+            result,
+            softwareAgentId: deps.softwareAgent?.id,
+            sourceEventIds: taskEventIds,
+        });
+    }
+    catch (err) {
+        await appendSoftwareAgentTaskFailureEvent({
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+            envelope,
+            softwareAgentId: deps.softwareAgent?.id,
+            sourceEventIds: taskEventIds,
+            error: err.message || String(err),
+        });
+        if (!streamStarted) {
+            const busy = String(err.message || "").includes("busy");
+            writeJsonResponse(res, busy ? 409 : 500, { error: err.message || String(err) });
+            responseFinished = true;
+            return;
+        }
+        writeSoftwareAgentStreamEvent(res, {
+            type: "error",
+            error: err.message || String(err),
+        });
+    }
+    finally {
+        responseFinished = true;
+        if (streamStarted && !res.writableEnded)
+            res.end();
+    }
+}
+export async function handleSoftwareAgentStatusHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const softwareAgent = requireSoftwareAgent(res, deps.softwareAgent);
+    if (!softwareAgent)
+        return;
+    writeJsonResponse(res, 200, softwareAgent.getState(), true);
+}
+export async function handleSoftwareAgentTasksHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const basePath = "/self/software-agent/tasks";
+    const taskLedgerDir = softwareAgentTaskLedgerDir(deps.workdir, deps.agentName);
+    if (url.pathname === basePath) {
+        const limit = readPositiveIntQuery(url.searchParams.get("limit"), 20, 100);
+        const tasks = listSoftwareAgentTaskRecords(taskLedgerDir, limit, {
+            contextSessionId: url.searchParams.get("session") || undefined,
+        });
+        writeJsonResponse(res, 200, { tasks }, true);
+        return;
+    }
+    if (url.pathname.startsWith(`${basePath}/`)) {
+        const taskId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+        if (!taskId || taskId.includes("/")) {
+            writeJsonResponse(res, 400, { error: "Invalid software-agent task id" });
+            return;
+        }
+        const task = readSoftwareAgentTaskRecord(taskLedgerDir, taskId);
+        if (!task) {
+            writeJsonResponse(res, 404, { error: "Software-agent task not found" });
+            return;
+        }
+        let contextSession;
+        if (readBooleanQuery(url.searchParams.get("includeContext")) && task.contextSession?.sessionId) {
+            try {
+                contextSession = readSoftwareAgentContextSession(softwareAgentContextSessionDir(deps.workdir, deps.agentName), task.contextSession.sessionId, { includeContextPacket: true });
+            }
+            catch {
+                contextSession = null;
+            }
+        }
+        writeJsonResponse(res, 200, { task, ...(contextSession ? { contextSession } : {}) }, true);
+        return;
+    }
+    writeJsonResponse(res, 404, { error: "Software-agent task endpoint not found" });
+}
+export async function handleLocalTasksHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const basePath = "/self/tasks";
+    if (url.pathname === basePath) {
+        const status = readTaskStatusQuery(url.searchParams.get("status"));
+        const route = url.searchParams.get("route") || undefined;
+        const visibility = readTaskVisibilityQuery(url.searchParams.get("visibility"));
+        const parentTaskId = url.searchParams.get("parentTaskId") || undefined;
+        const tasks = await listTaskRegistryRecords({
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            limit: readPositiveIntQuery(url.searchParams.get("limit"), 50, 200),
+            status,
+            route,
+            visibility,
+            parentTaskId,
+        });
+        const taskViews = tasks.map(createTaskSurfaceView);
+        writeJsonResponse(res, 200, {
+            tasks: tasks.map(createTaskResponseRecord),
+            taskViews,
+        }, true);
+        return;
+    }
+    if (url.pathname.startsWith(`${basePath}/`)) {
+        const taskId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+        if (!taskId || taskId.includes("/")) {
+            writeJsonResponse(res, 400, { error: "Invalid task id" });
+            return;
+        }
+        const task = await readTaskRegistryRecord({
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            taskId,
+        });
+        if (!task) {
+            writeJsonResponse(res, 404, { error: "Task not found" });
+            return;
+        }
+        writeJsonResponse(res, 200, {
+            task: createTaskResponseRecord(task),
+            taskView: createTaskSurfaceView(task),
+        }, true);
+        return;
+    }
+    writeJsonResponse(res, 404, { error: "Task endpoint not found" });
+}
+export async function handleSoftwareAgentContextSessionsHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const basePath = "/self/software-agent/sessions";
+    const contextSessionDir = softwareAgentContextSessionDir(deps.workdir, deps.agentName);
+    if (url.pathname === basePath) {
+        const limit = readPositiveIntQuery(url.searchParams.get("limit"), 20, 100);
+        const sessions = listSoftwareAgentContextSessions(contextSessionDir, limit);
+        writeJsonResponse(res, 200, { sessions }, true);
+        return;
+    }
+    if (url.pathname.startsWith(`${basePath}/`)) {
+        const sessionId = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+        if (!sessionId || sessionId.includes("/")) {
+            writeJsonResponse(res, 400, { error: "Invalid software-agent context session id" });
+            return;
+        }
+        let session;
+        try {
+            session = readSoftwareAgentContextSession(contextSessionDir, sessionId, {
+                includeContextPacket: readBooleanQuery(url.searchParams.get("includeContext")),
+            });
+        }
+        catch (err) {
+            writeJsonResponse(res, 400, { error: err.message || "Invalid software-agent context session id" });
+            return;
+        }
+        if (!session) {
+            writeJsonResponse(res, 404, { error: "Software-agent context session not found" });
+            return;
+        }
+        writeJsonResponse(res, 200, { session }, true);
+        return;
+    }
+    writeJsonResponse(res, 404, { error: "Software-agent context session endpoint not found" });
+}
+function softwareAgentTaskLedgerDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "software-agent", "tasks");
+}
+function softwareAgentContextSessionDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "software-agent", "sessions");
 }
 function readPositiveIntQuery(value, fallback, max) {
     if (!value)
@@ -316,11 +3113,51 @@ function readPositiveIntQuery(value, fallback, max) {
         return fallback;
     return Math.min(parsed, max);
 }
+function readBooleanQuery(value) {
+    return value === "1" || value === "true" || value === "yes";
+}
+function readTaskStatusQuery(value) {
+    if (value === "pending"
+        || value === "running"
+        || value === "waiting"
+        || value === "succeeded"
+        || value === "failed"
+        || value === "info") {
+        return value;
+    }
+    return undefined;
+}
+function readTaskVisibilityQuery(value) {
+    if (value === "primary" || value === "technical")
+        return value;
+    return undefined;
+}
+function readOptionalBooleanBody(value, field) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value !== "boolean")
+        throw new Error(`Invalid ${field}: expected boolean`);
+    return value;
+}
+function readOptionalPositiveIntBody(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`Invalid ${field}: expected positive integer`);
+    }
+    return value;
+}
 function writeSoftwareAgentStreamEvent(res, event) {
     if (res.destroyed)
         return;
     res.write(`${JSON.stringify(redactSecrets(event))}\n`);
 }
+function writeWorkbenchSseEvent(res, eventName, data) {
+    if (res.destroyed)
+        return;
+    res.write(`event: ${eventName}\n`);
+    res.write(`data: ${JSON.stringify(redactSecrets(data))}\n\n`);
+}
 export async function handleSoftwareAgentResetHttp(req, res, deps) {
     if (!requireOwnerRequest(req, res, deps.options))
         return;
@@ -328,43 +3165,403 @@ export async function handleSoftwareAgentResetHttp(req, res, deps) {
     if (!softwareAgent)
         return;
     try {
-        await softwareAgent.resetSession();
-        writeJsonResponse(res, 200, { ok: true, state: softwareAgent.getState() }, true);
+        await softwareAgent.resetSession();
+        writeJsonResponse(res, 200, { ok: true, state: softwareAgent.getState() }, true);
+    }
+    catch (err) {
+        writeJsonResponse(res, 500, { error: err.message || String(err) });
+    }
+}
+export async function handleWorkbenchSessionsHttp(req, res, deps) {
+    if (!requireOwnerRequest(req, res, deps.options))
+        return;
+    const workbench = requireWorkbench(res, deps.workbench);
+    if (!workbench)
+        return;
+    await workbench.ready();
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const basePath = "/self/workbench/sessions";
+    const suffix = url.pathname === basePath ? "" : url.pathname.slice(basePath.length + 1);
+    const [sessionId, action] = suffix ? suffix.split("/") : ["", ""];
+    try {
+        if (url.pathname === basePath && req.method === "GET") {
+            writeJsonResponse(res, 200, {
+                sessions: workbench.listSessions(),
+                activeSessionId: workbench.getActiveSessionId(),
+                ...(deps.agentName ? { agentName: deps.agentName } : {}),
+            }, true);
+            return;
+        }
+        if (url.pathname === basePath && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const action = {
+                capability: "start_session",
+                args: normalizeWorkbenchStartRequest(body),
+                reason: "owner used Workbench HTTP start",
+            };
+            const observation = await executeInteractiveSessionViaPeripheral(workbench, deps.interactiveSessionPeripheral, action);
+            await appendOwnerDirectInteractiveSessionEvents({
+                agentName: deps.agentName,
+                workdir: deps.workdir,
+                source: "workbench_http",
+                action,
+                observation,
+            });
+            if (!observation.ok)
+                throw new Error(observation.error || observation.summary);
+            const sessionId = interactiveSessionObservationSessionId(observation, action);
+            const session = sessionId ? workbench.getSession(sessionId) : null;
+            writeJsonResponse(res, 201, { session }, true);
+            return;
+        }
+        if (!sessionId || sessionId.includes("/") || sessionId.includes("\\")) {
+            writeJsonResponse(res, 404, { error: "Workbench session endpoint not found" });
+            return;
+        }
+        if (!action && req.method === "GET") {
+            const session = workbench.getSession(sessionId);
+            if (!session) {
+                writeJsonResponse(res, 404, { error: "Workbench session not found" });
+                return;
+            }
+            writeJsonResponse(res, 200, { session }, true);
+            return;
+        }
+        if (action === "activate" && req.method === "POST") {
+            const session = workbench.setActiveSession(sessionId);
+            writeJsonResponse(res, 200, { ok: true, activeSessionId: session.sessionId, session }, true);
+            return;
+        }
+        if (action === "tail" && req.method === "GET") {
+            const session = workbench.getSession(sessionId);
+            if (!session) {
+                writeJsonResponse(res, 404, { error: "Workbench session not found" });
+                return;
+            }
+            writeJsonResponse(res, 200, { sessionId, tail: session.tail }, true);
+            return;
+        }
+        if (action === "stream" && req.method === "GET") {
+            const session = workbench.getSession(sessionId);
+            if (!session) {
+                writeJsonResponse(res, 404, { error: "Workbench session not found" });
+                return;
+            }
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream; charset=utf-8",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            });
+            res.flushHeaders?.();
+            writeWorkbenchSseEvent(res, "snapshot", { session });
+            let done = false;
+            let unsubscribe = () => { };
+            const cleanup = () => {
+                if (done)
+                    return;
+                done = true;
+                unsubscribe();
+            };
+            unsubscribe = workbench.subscribe((event) => {
+                if (event.sessionId !== sessionId || done)
+                    return;
+                if (event.type === "output") {
+                    writeWorkbenchSseEvent(res, "output", event);
+                    return;
+                }
+                if (event.type === "status") {
+                    writeWorkbenchSseEvent(res, "status", event);
+                    return;
+                }
+                writeWorkbenchSseEvent(res, "exit", event);
+                cleanup();
+                if (!res.writableEnded)
+                    res.end();
+            });
+            res.on("close", cleanup);
+            const latestSession = workbench.getSession(sessionId) || session;
+            if (latestSession.status !== "running") {
+                writeWorkbenchSseEvent(res, "exit", {
+                    type: "exit",
+                    sessionId,
+                    exitCode: latestSession.exitCode,
+                    signal: latestSession.signal,
+                    snapshot: latestSession,
+                });
+                cleanup();
+                if (!res.writableEnded)
+                    res.end();
+            }
+            return;
+        }
+        if (action === "input" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const session = workbench.writeInput(sessionId, normalizeWorkbenchInputRequest(body));
+            writeJsonResponse(res, 200, { ok: true, session }, true);
+            return;
+        }
+        if (action === "input-mode" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const interactiveAction = {
+                capability: "set_input_mode",
+                args: {
+                    sessionId,
+                    inputMode: normalizeWorkbenchInputMode(body?.inputMode),
+                },
+                reason: "owner used Workbench HTTP input-mode",
+            };
+            const observation = await executeInteractiveSessionViaPeripheral(workbench, deps.interactiveSessionPeripheral, interactiveAction);
+            await appendOwnerDirectInteractiveSessionEvents({
+                agentName: deps.agentName,
+                workdir: deps.workdir,
+                source: "workbench_http",
+                action: interactiveAction,
+                observation,
+            });
+            if (!observation.ok)
+                throw new Error(observation.error || observation.summary);
+            const session = workbench.getSession(sessionId);
+            writeJsonResponse(res, 200, { ok: true, session }, true);
+            return;
+        }
+        if (action === "resize" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const resize = normalizeWorkbenchResizeRequest(body);
+            const interactiveAction = {
+                capability: "resize_session",
+                args: {
+                    sessionId,
+                    cols: resize.cols,
+                    rows: resize.rows,
+                },
+                reason: "owner used Workbench HTTP resize",
+            };
+            const observation = await executeInteractiveSessionViaPeripheral(workbench, deps.interactiveSessionPeripheral, interactiveAction);
+            await appendOwnerDirectInteractiveSessionEvents({
+                agentName: deps.agentName,
+                workdir: deps.workdir,
+                source: "workbench_http",
+                action: interactiveAction,
+                observation,
+            });
+            if (!observation.ok)
+                throw new Error(observation.error || observation.summary);
+            const session = workbench.getSession(sessionId);
+            writeJsonResponse(res, 200, { ok: true, session }, true);
+            return;
+        }
+        if (action === "stop" && req.method === "POST") {
+            const interactiveAction = {
+                capability: "stop_session",
+                args: { sessionId },
+                reason: "owner used Workbench HTTP stop",
+            };
+            const observation = await executeInteractiveSessionViaPeripheral(workbench, deps.interactiveSessionPeripheral, interactiveAction);
+            await appendOwnerDirectInteractiveSessionEvents({
+                agentName: deps.agentName,
+                workdir: deps.workdir,
+                source: "workbench_http",
+                action: interactiveAction,
+                observation,
+            });
+            if (!observation.ok)
+                throw new Error(observation.error || observation.summary);
+            const session = workbench.getSession(sessionId);
+            writeJsonResponse(res, 200, { ok: true, session }, true);
+            return;
+        }
+        writeJsonResponse(res, 404, { error: "Workbench session endpoint not found" });
     }
     catch (err) {
-        writeJsonResponse(res, 500, { error: err.message || String(err) });
+        const message = err.message || String(err);
+        const status = /not found/i.test(message) ? 404
+            : /limit reached|not running/i.test(message) ? 409
+                : 400;
+        writeJsonResponse(res, status, { error: message });
     }
 }
-import { RelayPeripheral } from "./relay-peripheral.js";
-import { EnginePeripheral, LLM_ENGINES as LLM_ENGINES_SET } from "./engine-peripheral.js";
-import { EngineQueue } from "./engine-queue.js";
-import { BioStateModule } from "./bio-module.js";
-import { MemoryModule } from "./memory-module.js";
-import { RoleModule } from "./role-module.js";
-import { TaskModule } from "./task-module.js";
-import { SocialModule } from "./social-module.js";
-import { LongTermModule } from "./longterm-module.js";
-import { ReflectionModule } from "./reflection-module.js";
-import { ScriptModule } from "./script-module.js";
-import { FileEventLog, PersistentEventBus } from "./event-bus.js";
-import { CodexSoftwareAgentPeripheral, createOwnerTaskEnvelope, listSoftwareAgentTaskRecords, readSoftwareAgentTaskRecord, } from "./software-agent-peripheral.js";
-import { buildSoftwareAgentMemorySummary } from "./software-agent-memory.js";
-import { SIG, sig } from "./types.js";
-import { loadConversation, listConversations, buildLLMContext } from "./context.js";
-import { redactSecrets } from "./redaction.js";
-import { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
-import { autoRoute, runCollaborativeQuery } from "./agent-utils.js";
 // createMcpServer, initMcpProxy, createMcpProxyServer → see mcp-server.ts
 const LLM_ENGINES = LLM_ENGINES_SET;
+async function handleOwnerActionHttpRoute(req, res, deps) {
+    const requestPath = req.url?.split("?")[0] || "";
+    if (requestPath === "/self/workbench/sessions"
+        || requestPath.startsWith("/self/workbench/sessions/")) {
+        await handleWorkbenchSessionsHttp(req, res, {
+            options: deps.options,
+            workbench: deps.workbench,
+            interactiveSessionPeripheral: deps.interactiveSessionPeripheral,
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+        });
+        return true;
+    }
+    if (req.url === "/self/software-agent/run-stream" && req.method === "POST") {
+        await handleSoftwareAgentRunStreamHttp(req, res, {
+            options: deps.options,
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            softwareAgent: deps.softwareAgent,
+        });
+        return true;
+    }
+    if (req.url === "/self/software-agent/run" && req.method === "POST") {
+        await handleSoftwareAgentRunHttp(req, res, {
+            options: deps.options,
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+            softwareAgent: deps.softwareAgent,
+        });
+        return true;
+    }
+    if (req.url === "/self/software-agent/status" && req.method === "GET") {
+        await handleSoftwareAgentStatusHttp(req, res, {
+            options: deps.options,
+            softwareAgent: deps.softwareAgent,
+        });
+        return true;
+    }
+    if (req.method === "GET"
+        && (requestPath === "/self/tasks" || requestPath.startsWith("/self/tasks/"))) {
+        await handleLocalTasksHttp(req, res, {
+            options: deps.options,
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+        });
+        return true;
+    }
+    if (req.method === "GET"
+        && (requestPath === "/self/software-agent/sessions" || requestPath.startsWith("/self/software-agent/sessions/"))) {
+        await handleSoftwareAgentContextSessionsHttp(req, res, {
+            options: deps.options,
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+        });
+        return true;
+    }
+    if (req.method === "GET"
+        && (requestPath === "/self/software-agent/tasks" || requestPath.startsWith("/self/software-agent/tasks/"))) {
+        await handleSoftwareAgentTasksHttp(req, res, {
+            options: deps.options,
+            workdir: deps.workdir,
+            agentName: deps.agentName,
+        });
+        return true;
+    }
+    if (req.url === "/self/software-agent/reset" && req.method === "POST") {
+        await handleSoftwareAgentResetHttp(req, res, {
+            options: deps.options,
+            softwareAgent: deps.softwareAgent,
+        });
+        return true;
+    }
+    if (req.url === "/self/message" && req.method === "POST") {
+        await handleLocalAkemonMessageHttp(req, res, {
+            options: deps.options,
+            agentName: deps.agentName,
+            workdir: deps.workdir,
+            localPort: deps.localPort,
+            workbench: deps.workbench,
+            interactiveSessionPeripheral: deps.interactiveSessionPeripheral,
+            requestCompute: deps.requestCompute,
+            passiveReflection: true,
+        });
+        return true;
+    }
+    return false;
+}
+async function handleSelfHttpRoute(req, res, deps) {
+    const requestPath = req.url?.split("?")[0] || "";
+    if (req.url === "/self/state" && req.method === "GET") {
+        const state = await getSelfState(deps.workdir, deps.agentName);
+        if (deps.relay?.connected) {
+            try {
+                const agents = await deps.relay.listAgents({ online: true, public: true });
+                const self = agents.find((a) => a.name === deps.agentName);
+                state.credits = self?.credits ?? 0;
+                state.level = self?.level ?? 0;
+            }
+            catch {
+                state.credits = null;
+            }
+        }
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(state, null, 2));
+        return true;
+    }
+    if (requestPath === "/self/peripherals/explore" && req.method === "GET") {
+        const url = new URL(req.url || requestPath, `http://localhost`);
+        const id = url.searchParams.get("id") || undefined;
+        const configured = await loadPeripheralRecords(deps.agentName);
+        const records = mergePeripheralRecords(configured, deps.runtimePeripheralRecords);
+        const briefing = await buildPeripheralExploreBriefing({
+            records,
+            runtimePeripherals: deps.peripherals,
+            id,
+        });
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(briefing, null, 2));
+        return true;
+    }
+    if (requestPath === "/self/peripherals" && req.method === "GET") {
+        const configured = await loadPeripheralRecords(deps.agentName);
+        const records = mergePeripheralRecords(configured, deps.runtimePeripheralRecords);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ records }, null, 2));
+        return true;
+    }
+    if (req.url === "/self/revive" && req.method === "POST") {
+        await reviveAgent(deps.workdir, deps.agentName);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true, message: "Agent revived. Energy=50, Hunger=50." }));
+        return true;
+    }
+    if (req.url?.startsWith("/self/task-history") && req.method === "GET") {
+        const url = new URL(req.url, `http://localhost`);
+        const limit = parseInt(url.searchParams.get("limit") || "50") || 50;
+        const history = await loadTaskHistory(deps.workdir, deps.agentName, limit);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(history, null, 2));
+        return true;
+    }
+    if (req.url === "/self/directives" && req.method === "GET") {
+        const dirs = await loadDirectives(deps.workdir, deps.agentName);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(dirs, null, 2));
+        return true;
+    }
+    if (req.url === "/self/canvas" && req.method === "GET") {
+        const entries = await loadRecentCanvasEntries(deps.workdir, deps.agentName, 10);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(entries, null, 2));
+        return true;
+    }
+    if (req.url === "/self/conversations" && req.method === "GET") {
+        const list = await listConversations(deps.workdir, deps.agentName);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(list, null, 2));
+        return true;
+    }
+    if (req.url?.startsWith("/self/conversation/") && req.method === "GET") {
+        const convId = decodeURIComponent(req.url.slice("/self/conversation/".length));
+        if (!convId) {
+            res.writeHead(400).end("Missing conversation ID");
+            return true;
+        }
+        const conv = await loadConversation(deps.workdir, deps.agentName, convId);
+        const config = await loadAgentConfig(deps.workdir, deps.agentName);
+        const budget = config.context_budget ?? 4096;
+        const { recentStartIndex } = buildLLMContext(conv, budget);
+        res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
+            summary: conv.summary,
+            rounds: conv.rounds,
+            recentStartIndex,
+        }, null, 2));
+        return true;
+    }
+    return false;
+}
 // ---------------------------------------------------------------------------
 // Engine execution — delegates to EnginePeripheral (V2 Step 3)
 // ---------------------------------------------------------------------------
 /** Unified engine runner — delegates to EnginePeripheral */
-function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing, taskId, routeRequest) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing, taskId, routeRequest, engineResources) {
     if (!_engineP) {
         throw new Error("Engine peripheral not initialized");
     }
-    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest);
+    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest, engineResources);
     // Sync trace back to module-level for reporting
     result.then(() => { lastEngineTrace = _engineP.lastTrace; }).catch(() => { lastEngineTrace = _engineP.lastTrace; });
     return result;
@@ -373,14 +3570,18 @@ function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, re
 // pullFromRelay → see relay-peripheral.ts
 export async function serve(options) {
     const workdir = options.workdir || process.cwd();
+    let registryHeartbeat = null;
     // Reclaim stale CLI children from any previous daemon crash before starting.
     await scanAndKillOrphans();
-    // V2: Relay peripheral — unified relay API access
-    const relay = new RelayPeripheral({
-        httpUrl: options.relayHttp || "",
-        secretKey: options.secretKey || "",
-        agentName: options.agentName,
-    });
+    // V2: Relay peripheral — unified relay API access. Local-only mode does not
+    // register this peripheral, so modules cannot accidentally use relay APIs.
+    const relay = options.relayHttp
+        ? new RelayPeripheral({
+            httpUrl: options.relayHttp,
+            secretKey: options.secretKey || "",
+            agentName: options.agentName,
+        })
+        : null;
     // V2: Engine peripheral — unified engine execution
     const engineP = new EnginePeripheral({
         engine: options.engine || "claude",
@@ -392,23 +3593,54 @@ export async function serve(options) {
         rawMaxRounds: 20,
         relay: options.relayHttp ? { http: options.relayHttp, agentName: options.agentName } : undefined,
     });
+    options.relay = relay ?? undefined;
+    options.enginePeripheral = engineP;
+    _engineP = engineP;
     // Expose port to engine subprocesses so they can callback to local MCP server
     process.env.AKEMON_PORT = String(options.port);
     if (options.key)
         process.env.AKEMON_KEY = options.key;
-    // Initialize MCP proxy if --mcp-server specified
+    // Initialize MCP proxy lazily so HTTP startup is not gated by child MCP boot.
     let mcpProxy = null;
-    if (options.mcpServer) {
-        try {
-            mcpProxy = await initMcpProxy(options.mcpServer, workdir);
-        }
-        catch (err) {
-            console.error(`[mcp-proxy] Failed to start child MCP server: ${err.message}`);
-            process.exit(1);
+    let mcpProxyPromise = null;
+    const ensureMcpProxy = () => {
+        if (!options.mcpServer)
+            return Promise.resolve(null);
+        if (mcpProxy)
+            return Promise.resolve(mcpProxy);
+        if (!mcpProxyPromise) {
+            mcpProxyPromise = initMcpProxy(options.mcpServer, workdir)
+                .then((proxy) => {
+                mcpProxy = proxy;
+                return proxy;
+            })
+                .catch((err) => {
+                console.error(`[mcp-proxy] Failed to start child MCP server: ${err.message || String(err)}`);
+                process.exit(1);
+            });
         }
-    }
+        return mcpProxyPromise;
+    };
     const sessions = new Map();
     const publisherIds = new Map();
+    const interactiveSessions = new InteractiveSessionManager({
+        agentName: options.agentName,
+        baseWorkdir: workdir,
+    });
+    const workbench = interactiveSessions;
+    const interactiveSessionPeripheral = new InteractiveSessionPeripheral(interactiveSessions);
+    workbench.ready()
+        .then(() => console.log("[workbench] session recovery ready"))
+        .catch((error) => logBestEffortError("workbench session recovery", error));
+    workbench.subscribe((event) => {
+        if (event.type !== "exit")
+            return;
+        appendInteractiveSessionOutcomeEvent({
+            agentName: options.agentName,
+            workdir,
+            event,
+        }).catch((error) => logBestEffortError("interactive session outcome event append", error));
+    });
     // Build deps for MCP server
     const mcpDeps = {
         runEngine,
@@ -426,52 +3658,37 @@ export async function serve(options) {
         emitTaskCompleted,
     };
     let codexSoftwareAgent = null;
+    let peripherals = [
+        ...(relay ? [relay] : []),
+        engineP,
+        interactiveSessionPeripheral,
+    ];
+    let runtimePeripheralRecords = [];
+    let requestCompute = async () => ({
+        success: false,
+        error: "Akemon runtime is still initializing. Please retry in a moment.",
+    });
+    let bus = null;
+    const allModules = [];
     const httpServer = createServer(async (req, res) => {
         // Suppress noisy polling endpoints from log
         const isQuiet = req.url === "/self/state" || req.url?.startsWith("/self/state?");
         if (!isQuiet)
             console.log(`[http] ${req.method} ${req.url} session=${req.headers["mcp-session-id"] || "none"}`);
         try {
-            if (req.url === "/self/software-agent/run-stream" && req.method === "POST") {
-                await handleSoftwareAgentRunStreamHttp(req, res, {
-                    options,
-                    workdir,
-                    agentName: options.agentName,
-                    softwareAgent: codexSoftwareAgent,
-                });
+            if (await handleOwnerActionHttpRoute(req, res, {
+                options,
+                workdir,
+                agentName: options.agentName,
+                localPort: options.port,
+                softwareAgent: codexSoftwareAgent,
+                workbench,
+                interactiveSessionPeripheral,
+                requestCompute,
+            })) {
                 return;
             }
-            if (req.url === "/self/software-agent/run" && req.method === "POST") {
-                await handleSoftwareAgentRunHttp(req, res, {
-                    options,
-                    workdir,
-                    agentName: options.agentName,
-                    softwareAgent: codexSoftwareAgent,
-                });
-                return;
-            }
-            if (req.url === "/self/software-agent/status" && req.method === "GET") {
-                await handleSoftwareAgentStatusHttp(req, res, {
-                    options,
-                    softwareAgent: codexSoftwareAgent,
-                });
-                return;
-            }
-            const requestPath = req.url?.split("?")[0] || "";
-            if (req.method === "GET"
-                && (requestPath === "/self/software-agent/tasks" || requestPath.startsWith("/self/software-agent/tasks/"))) {
-                await handleSoftwareAgentTasksHttp(req, res, {
-                    options,
-                    workdir,
-                    agentName: options.agentName,
-                });
-                return;
-            }
-            if (req.url === "/self/software-agent/reset" && req.method === "POST") {
-                await handleSoftwareAgentResetHttp(req, res, {
-                    options,
-                    softwareAgent: codexSoftwareAgent,
-                });
+            if (await handleLocalUiAssetRoute(req, res)) {
                 return;
             }
             // Auth check
@@ -484,89 +3701,13 @@ export async function serve(options) {
                     return;
                 }
             }
-            // Live — agent life visualization
-            if ((req.url === "/live" || req.url === "/live/") && req.method === "GET") {
-                try {
-                    const { readFile: rf } = await import("fs/promises");
-                    const { fileURLToPath } = await import("url");
-                    const { dirname, join: pjoin } = await import("path");
-                    const __filename = fileURLToPath(import.meta.url);
-                    const __dirname = dirname(__filename);
-                    let html;
-                    try {
-                        html = await rf(pjoin(__dirname, "live.html"), "utf-8");
-                    }
-                    catch {
-                        html = await rf(pjoin(__dirname, "..", "src", "live.html"), "utf-8");
-                    }
-                    res.writeHead(200, { "Content-Type": "text/html" }).end(html);
-                }
-                catch (err) {
-                    res.writeHead(500).end("Live page not found: " + err.message);
-                }
-                return;
-            }
-            // Self-state API (no auth required for local monitoring)
-            if (req.url === "/self/state" && req.method === "GET") {
-                const state = await getSelfState(workdir, options.agentName);
-                // Enrich with credits from relay (best-effort)
-                if (relay.connected) {
-                    try {
-                        const agents = await relay.listAgents({ online: true, public: true });
-                        const self = agents.find((a) => a.name === options.agentName);
-                        state.credits = self?.credits ?? 0;
-                        state.level = self?.level ?? 0;
-                    }
-                    catch {
-                        state.credits = null;
-                    }
-                }
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(state, null, 2));
-                return;
-            }
-            // Revive endpoint — owner brings a forced-offline agent back
-            if (req.url === "/self/revive" && req.method === "POST") {
-                await reviveAgent(workdir, options.agentName);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true, message: "Agent revived. Energy=50, Hunger=50." }));
-                return;
-            }
-            if (req.url?.startsWith("/self/task-history") && req.method === "GET") {
-                const url = new URL(req.url, `http://localhost`);
-                const limit = parseInt(url.searchParams.get("limit") || "50") || 50;
-                const history = await loadTaskHistory(workdir, options.agentName, limit);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(history, null, 2));
-                return;
-            }
-            if (req.url === "/self/directives" && req.method === "GET") {
-                const dirs = await loadDirectives(workdir, options.agentName);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(dirs, null, 2));
-                return;
-            }
-            if (req.url === "/self/canvas" && req.method === "GET") {
-                const entries = await loadRecentCanvasEntries(workdir, options.agentName, 10);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(entries, null, 2));
-                return;
-            }
-            if (req.url === "/self/conversations" && req.method === "GET") {
-                const list = await listConversations(workdir, options.agentName);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(list, null, 2));
-                return;
-            }
-            if (req.url?.startsWith("/self/conversation/") && req.method === "GET") {
-                const convId = decodeURIComponent(req.url.slice("/self/conversation/".length));
-                if (!convId) {
-                    res.writeHead(400).end("Missing conversation ID");
-                    return;
-                }
-                const conv = await loadConversation(workdir, options.agentName, convId);
-                const config = await loadAgentConfig(workdir, options.agentName);
-                const budget = config.context_budget ?? 4096;
-                const { recentStartIndex } = buildLLMContext(conv, budget);
-                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
-                    summary: conv.summary,
-                    rounds: conv.rounds,
-                    recentStartIndex,
-                }, null, 2));
+            if (await handleSelfHttpRoute(req, res, {
+                workdir,
+                agentName: options.agentName,
+                relay,
+                peripherals,
+                runtimePeripheralRecords,
+            })) {
                 return;
             }
             // Track publisher ID per session
@@ -595,8 +3736,9 @@ export async function serve(options) {
                     publisherIds.delete(sid);
                 }
             };
-            if (mcpProxy) {
-                const proxyServer = createMcpProxyServer(mcpProxy, options.agentName);
+            const activeMcpProxy = await ensureMcpProxy();
+            if (activeMcpProxy) {
+                const proxyServer = createMcpProxyServer(activeMcpProxy, options.agentName);
                 await proxyServer.connect(transport);
             }
             else {
@@ -611,7 +3753,7 @@ export async function serve(options) {
                     relayHttp: options.relayHttp,
                     secretKey: options.secretKey,
                     publisherIds,
-                    relay,
+                    relay: relay ?? undefined,
                 }, mcpDeps);
                 await mcpServer.connect(transport);
             }
@@ -634,211 +3776,325 @@ export async function serve(options) {
         console.log(`Akemon MCP server running on port ${options.port}`);
         console.log(`Agent: ${options.agentName}`);
         console.log(`Workdir: ${workdir}`);
+        console.log("[startup] HTTP ready; runtime initialization continues in background");
+        registerLocalInstance({
+            name: options.agentName,
+            port: options.port,
+            workdir,
+            mode: options.relayHttp ? "relay" : "local-only",
+            relayHttp: options.relayHttp,
+        }).then((record) => {
+            console.log(`[local] Registered ${record.name} at ${record.endpoint}`);
+        }).catch((err) => {
+            console.log(`[local] Instance registry update failed: ${err.message || String(err)}`);
+        });
+        registryHeartbeat = setInterval(() => {
+            touchLocalInstance(options.agentName).catch(() => { });
+        }, 15_000);
+        void ensureMcpProxy();
     });
-    // Initialize agent config + consciousness (world knowledge + bio-state + guide)
-    initAgentConfig(workdir, options.agentName).catch(err => console.log(`[self] Config init failed: ${err}`));
-    loadAgentConfig(workdir, options.agentName).then(c => {
-        const flags = Object.entries(c).filter(([, v]) => v).map(([k]) => k).join(", ");
-        console.log(`[config] Features: ${flags || "(none)"}`);
-    }).catch(() => { });
-    initWorld(workdir, options.agentName, options.engine || "unknown").catch(err => console.log(`[self] World init failed: ${err}`));
-    initBioState(workdir, options.agentName).catch(err => console.log(`[self] Bio init failed: ${err}`));
-    if (options.relayHttp) {
-        initGuide(workdir, options.agentName, options.relayHttp).catch(err => console.log(`[self] Guide init failed: ${err}`));
-    }
-    // Pull games/notes/pages from relay to restore local data
-    if (options.relayHttp) {
-        relay.pullFromRelay(workdir, options.agentName).catch(err => console.log(`[sync] Pull from relay failed: ${err}`));
-    }
-    // V2: Shared module context + persistent EventBus.
-    // This is the durable spine for module/peripheral/engine activity; recovery
-    // side effects are intentionally deferred until the event schema stabilizes.
-    const eventLogDir = join(workdir, ".akemon", "agents", options.agentName, "events");
-    await mkdir(eventLogDir, { recursive: true });
-    const eventLogPath = join(eventLogDir, "events.jsonl");
-    const bus = new PersistentEventBus(new FileEventLog(eventLogPath));
-    console.log(`[v2] Event log: ${eventLogPath}`);
-    codexSoftwareAgent = new CodexSoftwareAgentPeripheral({
-        workdir,
-        model: process.env.AKEMON_CODEX_MODEL,
-        sandbox: "workspace-write",
-        taskLedgerDir: softwareAgentTaskLedgerDir(workdir, options.agentName),
-        contextSessionDir: softwareAgentContextSessionDir(workdir, options.agentName),
-        envPolicy: options.softwareAgentEnvPolicy,
-        envAllowlist: options.softwareAgentEnvAllowlist,
-    });
-    // Peripheral registry — Core routes by capability
-    const peripherals = [relay, engineP, codexSoftwareAgent];
-    for (const peripheral of peripherals) {
-        await peripheral.start(bus);
-    }
-    // requestCompute: acquire the engine slot (priority-aware), execute with a
-    // hard timeout, and release. The slot release and subprocess kill are both
-    // driven by the same AbortController so a stuck engine can't hold the lock.
-    async function requestCompute(req) {
-        // Load latest agent config for routing table (fast file read, changes rarely)
-        const agentCfg = await loadAgentConfig(workdir, options.agentName);
-        const routing = agentCfg.engine_routing;
-        // user_manual tasks also hold a subscription-CLI semaphore to cap claude CLI concurrency
-        const isUserManual = req.origin === "user_manual";
-        if (isUserManual) {
-            try {
-                await engineQueue.acquireUserManualSlot(ENGINE_WAIT_DEADLINE_MS);
-            }
-            catch (err) {
-                return { success: false, error: err.message || "User manual slot timeout" };
-            }
+    const initializeRuntime = async () => {
+        const runtimeStartedAt = Date.now();
+        console.log("[startup] Runtime initialization background started");
+        // Initialize agent config + consciousness (world knowledge + bio-state + guide)
+        initAgentConfig(workdir, options.agentName).catch(err => console.log(`[self] Config init failed: ${err}`));
+        loadAgentConfig(workdir, options.agentName).then(c => {
+            const flags = Object.entries(c).filter(([, v]) => v).map(([k]) => k).join(", ");
+            console.log(`[config] Features: ${flags || "(none)"}`);
+        }).catch(() => { });
+        initWorld(workdir, options.agentName, engineP.engineName || "unknown").catch(err => console.log(`[self] World init failed: ${err}`));
+        initBioState(workdir, options.agentName).catch(err => console.log(`[self] Bio init failed: ${err}`));
+        if (options.relayHttp) {
+            initGuide(workdir, options.agentName, options.relayHttp).catch(err => console.log(`[self] Guide init failed: ${err}`));
         }
-        try {
-            await engineQueue.acquire(req.priority, ENGINE_WAIT_DEADLINE_MS);
+        // Pull games/notes/pages from relay to restore local data
+        if (relay) {
+            relay.pullFromRelay(workdir, options.agentName).catch(err => console.log(`[sync] Pull from relay failed: ${err}`));
         }
-        catch (err) {
-            if (isUserManual)
-                engineQueue.releaseUserManualSlot();
-            return { success: false, error: err.message || "Engine busy timeout" };
-        }
-        const prompt = req.context
-            ? `${req.context}\n\n---\n\n${req.question}`
-            : req.question;
-        const abortController = new AbortController();
-        const timer = setTimeout(() => abortController.abort(), ENGINE_EXEC_TIMEOUT_MS);
+        // V2: Shared module context + persistent EventBus.
+        // This is the durable spine for module/peripheral/engine activity; recovery
+        // side effects are intentionally deferred until the event schema stabilizes.
+        const eventLogDir = join(workdir, ".akemon", "agents", options.agentName, "events");
+        await mkdir(eventLogDir, { recursive: true });
+        const eventLogPath = join(eventLogDir, "events.jsonl");
+        bus = new PersistentEventBus(new FileEventLog(eventLogPath));
+        const runtimeBus = bus;
+        console.log(`[v2] Event log: ${eventLogPath}`);
+        codexSoftwareAgent = new CodexSoftwareAgentPeripheral({
+            agentName: options.agentName,
+            workdir,
+            model: process.env.AKEMON_CODEX_MODEL,
+            sandbox: "workspace-write",
+            taskLedgerDir: softwareAgentTaskLedgerDir(workdir, options.agentName),
+            contextSessionDir: softwareAgentContextSessionDir(workdir, options.agentName),
+            workMemoryDir: workMemoryDir(workdir, options.agentName),
+            envPolicy: options.softwareAgentEnvPolicy,
+            envAllowlist: options.softwareAgentEnvAllowlist,
+        });
+        // Peripheral registry — Core routes by capability
+        peripherals = [
+            ...(relay ? [relay] : []),
+            engineP,
+            codexSoftwareAgent,
+            interactiveSessionPeripheral,
+        ];
+        runtimePeripheralRecords = [
+            ...(relay ? [createRuntimePeripheralRecord(relay, {
+                    type: "relay",
+                    riskLevel: "high",
+                    allowedActions: ["relay:read", "relay:publish", "relay:order", "relay:market"],
+                    url: options.relayHttp,
+                    exploreDescription: "Summarizes relay orders, tasks, market, and public network feed.",
+                    status: "available",
+                })] : []),
+            createRuntimePeripheralRecord(engineP, {
+                type: "engine",
+                riskLevel: "low",
+                allowedActions: ["compute:text"],
+                startCommand: engineP.engineName,
+                exploreDescription: "Primary text compute engine used through Akemon's engine queue.",
+                status: "available",
+            }),
+            createRuntimePeripheralRecord(codexSoftwareAgent, {
+                type: "software-agent",
+                riskLevel: "high",
+                allowedActions: ["repo:inspect", "repo:edit", "command:run", "skill:use"],
+                startCommand: "codex exec",
+                exploreDescription: "Owner-local Codex CLI software-agent peripheral for repository work.",
+                status: "available",
+            }),
+            createRuntimePeripheralRecord(interactiveSessionPeripheral, {
+                type: "interactive-session",
+                riskLevel: "high",
+                allowedActions: [
+                    "session:list",
+                    "session:inspect",
+                    "session:start",
+                    "session:input",
+                    "session:resize",
+                    "session:stop",
+                    "session:capture-output",
+                ],
+                exploreDescription: "Owner-local interactive sessions for Codex, Claude, shell, cursor, and custom PTY processes.",
+                status: "available",
+            }),
+        ];
         try {
-            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing, req.taskId, req.engineHints);
-            emitTokenUsage(prompt.length, response.length);
-            return { success: true, response };
+            await upsertPeripheralRecords(options.agentName, runtimePeripheralRecords.map((record) => ({ ...record, status: "configured" })));
         }
-        catch (err) {
-            const msg = abortController.signal.aborted
-                ? `Engine execution timeout (${Math.round(ENGINE_EXEC_TIMEOUT_MS / 60000)} min)`
-                : (err.message || String(err));
-            return { success: false, error: msg };
+        catch (error) {
+            logBestEffortError("peripheral registry sync", error);
         }
-        finally {
-            clearTimeout(timer);
-            engineQueue.release();
-            if (isUserManual)
-                engineQueue.releaseUserManualSlot();
+        for (const peripheral of peripherals) {
+            await peripheral.start(runtimeBus);
         }
-    }
-    const moduleCtx = {
-        bus,
-        agentName: options.agentName,
-        workdir,
-        getPeripherals: (capability) => peripherals.filter(p => p.capabilities.includes(capability)),
-        sendTo: async (capability, signal) => {
-            const p = peripherals.find(p => p.capabilities.includes(capability));
-            return p ? p.send(signal) : null;
-        },
-        requestCompute,
-        getPromptContributions: () => {
-            const contributions = [];
-            for (const m of allModules) {
-                if (m.promptContribution) {
-                    const c = m.promptContribution();
-                    if (c)
-                        contributions.push(c);
+        // requestCompute: acquire the engine slot (priority-aware), execute with a
+        // hard timeout, and release. The slot release and subprocess kill are both
+        // driven by the same AbortController so a stuck engine can't hold the lock.
+        requestCompute = async (req) => {
+            // Load latest agent config for routing table (fast file read, changes rarely)
+            const agentCfg = await loadAgentConfig(workdir, options.agentName);
+            const routing = agentCfg.engine_routing;
+            const engineResources = agentCfg.engine_resources;
+            // user_manual tasks also hold a subscription-CLI semaphore to cap claude CLI concurrency
+            const isUserManual = req.origin === "user_manual";
+            if (isUserManual) {
+                try {
+                    await engineQueue.acquireUserManualSlot(ENGINE_WAIT_DEADLINE_MS);
+                }
+                catch (err) {
+                    return { success: false, error: err.message || "User manual slot timeout" };
                 }
             }
-            return contributions;
-        },
+            try {
+                await engineQueue.acquire(req.priority, ENGINE_WAIT_DEADLINE_MS);
+            }
+            catch (err) {
+                if (isUserManual)
+                    engineQueue.releaseUserManualSlot();
+                return { success: false, error: err.message || "Engine busy timeout" };
+            }
+            const prompt = req.context
+                ? `${req.context}\n\n---\n\n${req.question}`
+                : req.question;
+            const abortController = new AbortController();
+            const timer = setTimeout(() => abortController.abort(), ENGINE_EXEC_TIMEOUT_MS);
+            const startedAt = Date.now();
+            let outputChars = 0;
+            let success = false;
+            let errorSummary;
+            let result;
+            try {
+                const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing, req.taskId, {
+                    ...req.engineHints,
+                    ...(req.taskKind ? { taskKind: req.taskKind } : {}),
+                }, engineResources);
+                success = true;
+                outputChars = response.length;
+                emitTokenUsage(prompt.length, response.length);
+                result = { success: true, response };
+            }
+            catch (err) {
+                const msg = abortController.signal.aborted
+                    ? `Engine execution timeout (${Math.round(ENGINE_EXEC_TIMEOUT_MS / 60000)} min)`
+                    : (err.message || String(err));
+                errorSummary = msg;
+                result = { success: false, error: msg };
+            }
+            finally {
+                clearTimeout(timer);
+                engineQueue.release();
+                if (isUserManual)
+                    engineQueue.releaseUserManualSlot();
+                const audit = await appendComputeAuditEvent({
+                    agentName: options.agentName,
+                    workdir,
+                    req,
+                    promptChars: prompt.length,
+                    outputChars,
+                    durationMs: Date.now() - startedAt,
+                    success,
+                    error: errorSummary,
+                    invocation: _engineP?.lastInvocation || null,
+                });
+                result.audit = audit;
+            }
+            return result;
+        };
+        const moduleCtx = {
+            bus: runtimeBus,
+            agentName: options.agentName,
+            workdir,
+            getPeripherals: (capability) => peripherals.filter(p => p.capabilities.includes(capability)),
+            sendTo: async (capability, signal) => {
+                const p = peripherals.find(p => p.capabilities.includes(capability));
+                return p ? p.send(signal) : null;
+            },
+            requestCompute,
+            getPromptContributions: () => {
+                const contributions = [];
+                for (const m of allModules) {
+                    if (m.promptContribution) {
+                        const c = m.promptContribution();
+                        if (c)
+                            contributions.push(c);
+                    }
+                }
+                return contributions;
+            },
+        };
+        // V2: Conditionally load modules based on --with/--without
+        const enabled = options.enabledModules ?? ["biostate", "memory", "role", "task", "social", "longterm", "reflection", "script"];
+        const loadedModules = [];
+        _bus = bus;
+        const startModule = async (id, create, afterCreate) => {
+            if (!enabled.includes(id))
+                return;
+            const startedAt = Date.now();
+            console.log(`[v2] Module init: ${id}...`);
+            const module = create();
+            afterCreate?.(module);
+            await module.start(moduleCtx);
+            allModules.push(module);
+            loadedModules.push(id);
+            console.log(`[v2] Module ready: ${id} (${Date.now() - startedAt}ms)`);
+        };
+        const startModules = async () => {
+            const startedAt = Date.now();
+            console.log(`[v2] Module init background: ${enabled.join(", ") || "(none)"}`);
+            await startModule("biostate", () => {
+                const bioModule = new BioStateModule();
+                options.bioModule = bioModule;
+                return bioModule;
+            });
+            await startModule("memory", () => {
+                const memoryModule = new MemoryModule();
+                if (options.cycleInterval)
+                    memoryModule.cycleIntervalMs = options.cycleInterval * 60 * 1000;
+                options.memoryModule = memoryModule;
+                return memoryModule;
+            });
+            await startModule("role", () => new RoleModule());
+            await startModule("task", () => {
+                const taskModule = new TaskModule();
+                taskModule.relayHttp = options.relayHttp || "";
+                taskModule.secretKey = options.secretKey || "";
+                taskModule.engine = options.engine || "";
+                taskModule.model = options.model;
+                taskModule.allowAll = options.allowAll;
+                taskModule.notifyUrl = options.notifyUrl;
+                _taskModule = taskModule;
+                return taskModule;
+            });
+            await startModule("social", () => new SocialModule());
+            await startModule("longterm", () => new LongTermModule());
+            await startModule("reflection", () => new ReflectionModule());
+            await startModule("script", () => {
+                const scriptModule = new ScriptModule();
+                scriptModule.scriptName = options.scriptName || "daily-life";
+                scriptModule.relayHttp = options.relayHttp || "";
+                scriptModule.secretKey = options.secretKey || "";
+                return scriptModule;
+            });
+            console.log(`[v2] Modules: ${loadedModules.join(", ") || "(none)"} (${Date.now() - startedAt}ms)`);
+            // V2: Emit agent start lifecycle event after modules have subscribed.
+            runtimeBus.emit(SIG.AGENT_START, sig(SIG.AGENT_START, {
+                agentName: options.agentName,
+                engine: engineP.engineName,
+                modules: loadedModules,
+            }));
+        };
+        setTimeout(() => {
+            startModules().catch((error) => {
+                console.error(`[v2] Module init failed: ${error instanceof Error ? error.message : String(error)}`);
+                process.exit(1);
+            });
+        }, 100);
+        console.log(`[startup] Runtime core ready (${Date.now() - runtimeStartedAt}ms)`);
     };
-    // V2: Conditionally load modules based on --with/--without
-    const enabled = options.enabledModules ?? ["biostate", "memory", "role", "task", "social", "longterm", "reflection", "script"];
-    const loadedModules = [];
-    const allModules = [];
-    if (enabled.includes("biostate")) {
-        const bioModule = new BioStateModule();
-        await bioModule.start(moduleCtx);
-        options.bioModule = bioModule;
-        allModules.push(bioModule);
-        loadedModules.push("biostate");
-    }
-    if (enabled.includes("memory")) {
-        const memoryModule = new MemoryModule();
-        if (options.cycleInterval)
-            memoryModule.cycleIntervalMs = options.cycleInterval * 60 * 1000;
-        await memoryModule.start(moduleCtx);
-        options.memoryModule = memoryModule;
-        allModules.push(memoryModule);
-        loadedModules.push("memory");
-    }
-    if (enabled.includes("role")) {
-        const roleModule = new RoleModule();
-        await roleModule.start(moduleCtx);
-        allModules.push(roleModule);
-        loadedModules.push("role");
-    }
-    if (enabled.includes("task")) {
-        const taskModule = new TaskModule();
-        taskModule.relayHttp = options.relayHttp || "";
-        taskModule.secretKey = options.secretKey || "";
-        taskModule.engine = options.engine || "";
-        taskModule.model = options.model;
-        taskModule.allowAll = options.allowAll;
-        taskModule.notifyUrl = options.notifyUrl;
-        await taskModule.start(moduleCtx);
-        _taskModule = taskModule;
-        allModules.push(taskModule);
-        loadedModules.push("task");
-    }
-    if (enabled.includes("social")) {
-        const socialModule = new SocialModule();
-        await socialModule.start(moduleCtx);
-        allModules.push(socialModule);
-        loadedModules.push("social");
-    }
-    if (enabled.includes("longterm")) {
-        const longtermModule = new LongTermModule();
-        await longtermModule.start(moduleCtx);
-        allModules.push(longtermModule);
-        loadedModules.push("longterm");
-    }
-    if (enabled.includes("reflection")) {
-        const reflectionModule = new ReflectionModule();
-        await reflectionModule.start(moduleCtx);
-        allModules.push(reflectionModule);
-        loadedModules.push("reflection");
-    }
-    if (enabled.includes("script")) {
-        const scriptModule = new ScriptModule();
-        scriptModule.scriptName = options.scriptName || "daily-life";
-        scriptModule.relayHttp = options.relayHttp || "";
-        scriptModule.secretKey = options.secretKey || "";
-        await scriptModule.start(moduleCtx);
-        allModules.push(scriptModule);
-        loadedModules.push("script");
-    }
-    console.log(`[v2] Modules: ${loadedModules.join(", ") || "(none)"}`);
-    // Inject peripherals into options
-    options.relay = relay;
-    options.enginePeripheral = engineP;
-    _engineP = engineP;
-    _bus = bus;
-    // V2: Emit agent start lifecycle event
-    bus.emit(SIG.AGENT_START, sig(SIG.AGENT_START, {
-        agentName: options.agentName,
-        engine: options.engine,
-        modules: loadedModules,
-    }));
+    setTimeout(() => {
+        initializeRuntime().catch((error) => {
+            console.error(`[startup] Runtime init failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        });
+    }, 0);
     // Graceful shutdown — kill engine children first, then stop modules.
     // Engine children are killed via process group signal so any sub-forks
     // (e.g. opencode's internal Node workers) are also terminated.
     const shutdown = async () => {
         console.log("[v2] Shutting down...");
+        if (registryHeartbeat)
+            clearInterval(registryHeartbeat);
+        try {
+            await unregisterLocalInstance(options.agentName);
+        }
+        catch (error) {
+            logBestEffortError("local instance unregister", error);
+        }
         if (_engineP)
             _engineP.killAllChildren();
-        bus.emit(SIG.AGENT_STOP, sig(SIG.AGENT_STOP, {}));
+        bus?.emit(SIG.AGENT_STOP, sig(SIG.AGENT_STOP, {}));
         for (const m of allModules) {
             try {
                 await m.stop();
             }
-            catch { }
+            catch (error) {
+                logBestEffortError(`module stop ${m.id}`, error);
+            }
+        }
+        try {
+            await workbench.shutdown();
+        }
+        catch (error) {
+            logBestEffortError("workbench shutdown", error);
         }
         try {
             await codexSoftwareAgent?.stop();
         }
-        catch { }
-        bus.getLog().close();
+        catch (error) {
+            logBestEffortError("software-agent stop", error);
+        }
+        bus?.getLog().close();
         process.exit(0);
     };
     process.on("SIGINT", shutdown);