akemon 0.3.5 → 0.3.7

package/dist/core-cognitive-module.js

@@ -0,0 +1,768 @@
+import { buildLLMContext, loadConversation } from "./context.js";
+import { MEMORY_ACTION_PROPOSAL_GUIDE, createMemoryProposal, describePendingMemoryProposalsForCoreCm, executeMemoryActionProposalWithResult, formatCurrentMemoryForCoreCm, } from "./memory-proposal.js";
+import { WORKBENCH_ACTION_PROPOSAL_GUIDE, WORKBENCH_PERIPHERAL_GUIDE, } from "./workbench-peripheral-guide.js";
+const DEFAULT_SEND_INPUT_WAIT_MS = 600;
+const MAX_SEND_INPUT_WAIT_MS = 10_000;
+const INTERACTIVE_SESSION_PERIPHERAL = "interactive-session";
+export async function runLocalCoreCmChat(input) {
+    const memoryContext = await buildCoreCmMemoryContext({
+        agentName: input.agentName,
+        workdir: input.workdir || "",
+    });
+    const conversationContext = await buildCoreCmConversationContext({
+        agentName: input.agentName,
+        workdir: input.workdir || "",
+        conversationId: input.conversationId,
+    });
+    const context = [
+        "[Akemon Core CM]",
+        `You are the Core Cognitive Module for ${input.agentName}.`,
+        "You are handling the owner's local Akemon chat message.",
+        "",
+        "Architecture boundaries:",
+        "- Core CM handles conversation, task judgment, delegation decisions, and natural-language explanation.",
+        "- Memory CM only participates when memory work is needed. Do not write memory here; mention possible memory changes naturally if they matter.",
+        "- Workbench is a local presentation/control surface, not a Cognitive Module.",
+        "- Claude, Codex, shell, browser, files, services, and custom PTY sessions are peripherals used through adapters.",
+        "- Owner requests to remember something are Akemon memory requests. Do not interpret them as CLAUDE.md, ChatGPT memory, Claude memory, or external agent memory unless the owner explicitly asks for that target.",
+        "- Use Akemon memory context when it is relevant to task routing, project preferences, and owner-facing explanations.",
+        "- Do not claim that you started, stopped, or sent input to a peripheral unless the observation says that already happened.",
+        "- If you request a peripheral action, Akemon will execute it and return the observation to you for final owner-facing narration and memory judgment.",
+        "",
+        formatOwnerLanguagePolicy(input.ownerLanguage),
+        "",
+        "Process visibility:",
+        "- Include processNote in JSON responses. This is the short CM-area narration for the owner.",
+        "- processNote must be natural language in the configured owner-facing language.",
+        "- processNote should explain what Core CM is doing and why. Do not expose JSON keys, taskKind, adapter internals, token counts, or event ids unless the owner explicitly asks for debug details.",
+        "",
+        WORKBENCH_PERIPHERAL_GUIDE,
+        "",
+        WORKBENCH_ACTION_PROPOSAL_GUIDE,
+        "",
+        MEMORY_ACTION_PROPOSAL_GUIDE,
+        "",
+        "Current interactive session context:",
+        describeInteractiveSessionsForCoreCm(input.interactiveSessions),
+        "",
+        "Akemon memory context:",
+        memoryContext,
+        "",
+        "Recent owner/Akemon chat context:",
+        conversationContext,
+        "",
+        input.workdir ? `Current workdir: ${input.workdir}` : "Current workdir: unknown",
+    ].join("\n");
+    const question = [
+        "Owner message:",
+        input.text,
+        "",
+        "Decide whether to answer directly, request a Workbench peripheral action, create an Akemon memory proposal, or act on a pending memory suggestion.",
+        "Return only JSON matching the relevant contract above.",
+    ].join("\n");
+    const result = await input.requestCompute({
+        context,
+        question,
+        taskKind: "core_action_proposal",
+        purpose: "Core CM decides whether to answer directly, use Workbench, create a memory proposal, or act on pending memory.",
+        priority: "normal",
+        origin: "user_manual",
+        engineHints: {
+            requiredCapabilities: ["chat", "json"],
+        },
+    });
+    if (!result.success) {
+        return {
+            output: shouldUseChineseOwnerText(input.ownerLanguage, input.text)
+                ? `Core CM 没能完成回复，因为 engine 返回了错误：${result.error || "unknown error"}`
+                : `I could not complete the Core CM response because the engine returned an error: ${result.error || "unknown error"}`,
+        };
+    }
+    const proposal = parseCoreCmActionProposal(result.response);
+    if (!proposal) {
+        return {
+            output: result.response?.trim() || (shouldUseChineseOwnerText(input.ownerLanguage, input.text)
+                ? "Core CM 没能完成回复，因为 engine 返回了空内容。"
+                : "I could not complete the Core CM response because the engine returned an empty response."),
+        };
+    }
+    if (proposal.kind === "answer") {
+        return {
+            output: proposal.answer.trim() || (shouldUseChineseOwnerText(input.ownerLanguage, input.text)
+                ? "我现在还没有有用的回答。"
+                : "I do not have a useful answer yet."),
+            processNotes: collectProcessNotes(proposal.processNote),
+        };
+    }
+    if (proposal.kind === "memory_action") {
+        const memoryAction = await executeMemoryActionProposalWithResult({
+            agentName: input.agentName,
+            workdir: input.workdir || "",
+            proposal,
+        });
+        return {
+            output: memoryAction.output,
+            memoryAction,
+            processNotes: collectProcessNotes(proposal.processNote),
+        };
+    }
+    if (proposal.kind === "memory_proposal") {
+        const memoryProposal = createMemoryProposal({
+            agentName: input.agentName,
+            workdir: input.workdir || "",
+            source: "core-cm-direct-memory-request",
+            content: proposal.memory,
+            reason: proposal.reason,
+        }) || undefined;
+        return {
+            output: proposal.answer.trim() || "I prepared that as a memory suggestion.",
+            memoryProposal,
+            processNotes: collectProcessNotes(proposal.processNote),
+        };
+    }
+    const observation = await input.executeInteractiveSessionActionProposal(proposal);
+    const reviewed = await narrateInteractiveSessionObservationWithCoreCm(input, proposal, observation);
+    return {
+        ...reviewed,
+        processNotes: collectProcessNotes(proposal.processNote, ...(reviewed.processNotes || [])),
+    };
+}
+function parseCoreCmActionProposal(raw) {
+    return parseMemoryCreateProposal(raw) || parseMemoryActionProposal(raw) || parseInteractiveSessionActionProposal(raw);
+}
+function parseMemoryCreateProposal(raw) {
+    const text = raw?.trim();
+    if (!text)
+        return null;
+    const jsonText = extractJsonObject(text);
+    if (!jsonText)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const value = parsed;
+    if (value.kind !== "memory_proposal" || typeof value.answer !== "string")
+        return null;
+    const memory = value.memory && typeof value.memory === "object"
+        ? value.memory
+        : {};
+    return {
+        kind: "memory_proposal",
+        answer: value.answer,
+        memory: {
+            summary: typeof memory.summary === "string" ? memory.summary : undefined,
+            self: Array.isArray(memory.self) ? normalizeStringArray(memory.self) : undefined,
+            work: Array.isArray(memory.work) ? normalizeStringArray(memory.work) : undefined,
+        },
+        reason: typeof value.reason === "string" ? value.reason : undefined,
+    };
+}
+function parseMemoryActionProposal(raw) {
+    const text = raw?.trim();
+    if (!text)
+        return null;
+    const jsonText = extractJsonObject(text);
+    if (!jsonText)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const value = parsed;
+    if (value.kind !== "memory_action")
+        return null;
+    if (!["list_pending", "show_memory", "accept_pending", "reject_pending", "revise_pending"].includes(value.action))
+        return null;
+    const scope = value.scope === "self" || value.scope === "work" || value.scope === "all"
+        ? value.scope
+        : undefined;
+    const memory = value.memory && typeof value.memory === "object"
+        ? value.memory
+        : {};
+    return {
+        kind: "memory_action",
+        action: value.action,
+        proposalId: typeof value.proposalId === "string" ? value.proposalId : undefined,
+        scope,
+        ...(value.action === "revise_pending" ? {
+            memory: {
+                summary: typeof memory.summary === "string" ? memory.summary : undefined,
+                self: Array.isArray(memory.self) ? normalizeStringArray(memory.self) : undefined,
+                work: Array.isArray(memory.work) ? normalizeStringArray(memory.work) : undefined,
+            },
+        } : {}),
+        reason: typeof value.reason === "string" ? value.reason : undefined,
+        processNote: parseProcessNote(value),
+    };
+}
+function parseInteractiveSessionActionProposal(raw) {
+    const text = raw?.trim();
+    if (!text)
+        return null;
+    const jsonText = extractJsonObject(text);
+    if (!jsonText)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const value = parsed;
+    if (value.kind === "answer" && typeof value.answer === "string") {
+        return { kind: "answer", answer: value.answer, processNote: parseProcessNote(value) };
+    }
+    const peripheral = parseInteractiveSessionProposalPeripheral(value.peripheral);
+    if (value.kind !== "use_peripheral" || !peripheral)
+        return null;
+    if (value.capability === "list_sessions") {
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "list_sessions",
+            args: {},
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "inspect_session" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "inspect_session",
+            args: {
+                sessionId: args.sessionId,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "start_session" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.tool !== "string")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "start_session",
+            args: {
+                tool: args.tool,
+                command: typeof args.command === "string" ? args.command : undefined,
+                args: Array.isArray(args.args) ? args.args : undefined,
+                workdir: typeof args.workdir === "string" ? args.workdir : undefined,
+                label: typeof args.label === "string" ? args.label : undefined,
+                inputMode: args.inputMode === "line" || args.inputMode === "tui" ? args.inputMode : undefined,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "send_input" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string" || typeof args.input !== "string")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "send_input",
+            args: {
+                sessionId: args.sessionId,
+                input: args.input,
+                waitMs: normalizeSendInputWaitMs(args.waitMs),
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "set_input_mode" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string" || (args.inputMode !== "line" && args.inputMode !== "tui"))
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "set_input_mode",
+            args: {
+                sessionId: args.sessionId,
+                inputMode: args.inputMode,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "stop_session" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "stop_session",
+            args: {
+                sessionId: args.sessionId,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "resize_session" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string" || typeof args.cols !== "number" || typeof args.rows !== "number")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "resize_session",
+            args: {
+                sessionId: args.sessionId,
+                cols: args.cols,
+                rows: args.rows,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    if (value.capability === "capture_output" && value.args && typeof value.args === "object") {
+        const args = value.args;
+        if (typeof args.sessionId !== "string")
+            return null;
+        return {
+            kind: "use_peripheral",
+            peripheral,
+            capability: "capture_output",
+            args: {
+                sessionId: args.sessionId,
+            },
+            reason: typeof value.reason === "string" ? value.reason : undefined,
+            processNote: parseProcessNote(value),
+        };
+    }
+    return null;
+}
+function parseInteractiveSessionProposalPeripheral(value) {
+    if (value === INTERACTIVE_SESSION_PERIPHERAL || value === "workbench")
+        return INTERACTIVE_SESSION_PERIPHERAL;
+    return null;
+}
+function extractJsonObject(text) {
+    if (text.startsWith("{") && text.endsWith("}"))
+        return text;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim();
+    if (fenced?.startsWith("{") && fenced.endsWith("}"))
+        return fenced;
+    const first = text.indexOf("{");
+    const last = text.lastIndexOf("}");
+    if (first >= 0 && last > first)
+        return text.slice(first, last + 1);
+    return null;
+}
+async function narrateInteractiveSessionObservationWithCoreCm(input, proposal, observation) {
+    const memoryContext = await buildCoreCmMemoryContext({
+        agentName: input.agentName,
+        workdir: input.workdir || "",
+    });
+    const conversationContext = await buildCoreCmConversationContext({
+        agentName: input.agentName,
+        workdir: input.workdir || "",
+        conversationId: input.conversationId,
+    });
+    const context = [
+        "[Akemon Core CM Observation Review]",
+        `You are the Core Cognitive Module for ${input.agentName}.`,
+        "An interactive-session peripheral action has already been executed. The observation below is the source of truth.",
+        "",
+        "Architecture boundaries:",
+        "- Explain the action and observation to the owner in natural language.",
+        "- Do not expose JSON schemas, internal adapter names, or implementation details unless the owner asks.",
+        "- Memory CM participates here only as a proposal mechanism. Do not claim that memory has been written.",
+        "- Self memory belongs to Akemon. Work memory belongs to the owner/project and should only be proposed when useful.",
+        "- Use Akemon memory context to explain why the action matched the owner's project preferences when relevant.",
+        "",
+        formatOwnerLanguagePolicy(input.ownerLanguage),
+        "",
+        "Process visibility:",
+        "- Include processNote in the JSON response. This is the short CM-area narration for the owner.",
+        "- processNote must be natural language in the configured owner-facing language.",
+        "- processNote should explain how Core CM interpreted the interactive-session observation. Do not expose JSON keys, taskKind, adapter internals, token counts, or event ids unless the owner explicitly asks for debug details.",
+        "",
+        "Current interactive session context:",
+        describeInteractiveSessionsForCoreCm(input.interactiveSessions),
+        "",
+        "Akemon memory context:",
+        memoryContext,
+        "",
+        "Recent owner/Akemon chat context:",
+        conversationContext,
+        "",
+        input.workdir ? `Current workdir: ${input.workdir}` : "Current workdir: unknown",
+    ].join("\n");
+    const question = [
+        "Owner message:",
+        input.text,
+        "",
+        "Interactive-session action requested:",
+        JSON.stringify(simplifyInteractiveSessionProposalForObservation(proposal), null, 2),
+        "",
+        "Peripheral observation:",
+        JSON.stringify(observation, null, 2),
+        "",
+        "Write the final response for the owner.",
+        "Write it as a short task report, not as a tool log.",
+        "Include what Akemon asked the peripheral to do, what actually happened, what output or lack of output was observed, and what this means for the owner's request.",
+        "If the action only sent input and no new output arrived yet, say that explicitly and suggest inspecting the session later if the owner wants the result.",
+        "Also include a concise Memory CM judgment in natural language. If nothing should be remembered, say that naturally.",
+        "",
+        "Return only JSON in this shape:",
+        "{",
+        "  \"answer\": \"natural-language owner-facing response, without memory bookkeeping jargon\",",
+        "  \"processNote\": \"one concise owner-facing sentence explaining how Core CM interpreted this observation\",",
+        "  \"review\": {",
+        "    \"resultQuality\": \"good | partial | failed | uncertain\",",
+        "    \"completionDecision\": \"complete | partial | blocked | needs_follow_up\",",
+        "    \"followUpNeeded\": false,",
+        "    \"reportText\": \"concise final report text to archive\"",
+        "  },",
+        "  \"memory\": {",
+        "    \"summary\": \"natural-language memory judgment\",",
+        "    \"self\": [\"optional Akemon self-memory proposal\"],",
+        "    \"work\": [\"optional owner/project work-memory proposal\"]",
+        "  }",
+        "}",
+    ].join("\n");
+    const result = await input.requestCompute({
+        context,
+        question,
+        taskKind: "core_observation_review",
+        purpose: "Core CM reviews a Workbench peripheral observation and writes the owner-facing response.",
+        priority: "normal",
+        origin: "user_manual",
+        engineHints: {
+            requiredCapabilities: ["chat", "json"],
+        },
+    });
+    if (!result.success) {
+        const output = formatInteractiveSessionObservationFallback(input.text, proposal, observation, input.ownerLanguage);
+        return {
+            output,
+            review: createCoreCmFallbackReviewDraft({ observation, output }),
+        };
+    }
+    const response = parseCoreCmObservationResponse(result.response);
+    if (!response) {
+        const output = formatInteractiveSessionObservationFallback(input.text, proposal, observation, input.ownerLanguage);
+        return {
+            output,
+            review: createCoreCmFallbackReviewDraft({ observation, output }),
+        };
+    }
+    const memoryProposal = createMemoryProposal({
+        agentName: input.agentName,
+        workdir: input.workdir || "",
+        source: "core-cm-observation-review",
+        content: response.memory,
+        reason: proposal.reason,
+    }) || undefined;
+    const output = formatCoreCmObservationResponse(response);
+    return {
+        output,
+        memoryProposal,
+        processNotes: collectProcessNotes(response.processNote),
+        review: createCoreCmObservationReviewDraft({ response, observation, output }),
+    };
+}
+function parseProcessNote(value) {
+    return typeof value.processNote === "string" && value.processNote.trim()
+        ? value.processNote.trim()
+        : undefined;
+}
+function collectProcessNotes(...notes) {
+    const result = [];
+    const seen = new Set();
+    for (const note of notes) {
+        const text = typeof note === "string" ? note.trim() : "";
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        result.push(text);
+    }
+    return result;
+}
+function formatOwnerLanguagePolicy(ownerLanguage) {
+    const normalized = typeof ownerLanguage === "string" && ownerLanguage.trim()
+        ? ownerLanguage.trim()
+        : "auto";
+    if (normalized.toLowerCase() === "auto") {
+        return [
+            "Owner-facing language policy:",
+            "- Mode: auto.",
+            "- Respond in the owner's current message language when it is clear.",
+            "- If the message language is ambiguous, use the dominant language in recent owner/Akemon chat context and relevant project memory.",
+            "- Keep code, commands, file paths, identifiers, JSON keys, and tool names unchanged.",
+        ].join("\n");
+    }
+    return [
+        "Owner-facing language policy:",
+        `- Preferred owner-facing language: ${normalized}.`,
+        "- Use this language for natural-language replies, memory judgments, explanations, and user-facing summaries unless the owner explicitly asks for another language in the current message.",
+        "- Keep code, commands, file paths, identifiers, JSON keys, and tool names unchanged.",
+    ].join("\n");
+}
+function simplifyInteractiveSessionProposalForObservation(proposal) {
+    return {
+        peripheral: proposal.peripheral,
+        capability: proposal.capability,
+        args: proposal.args || {},
+        reason: proposal.reason,
+    };
+}
+function parseCoreCmObservationResponse(raw) {
+    const text = raw?.trim();
+    if (!text)
+        return null;
+    const jsonText = extractJsonObject(text);
+    if (!jsonText)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const value = parsed;
+    if (typeof value.answer !== "string")
+        return null;
+    const memory = value.memory && typeof value.memory === "object"
+        ? value.memory
+        : undefined;
+    return {
+        answer: value.answer,
+        processNote: parseProcessNote(value),
+        review: parseCoreCmObservationReview(value.review),
+        ...(memory ? {
+            memory: {
+                summary: typeof memory.summary === "string" ? memory.summary : undefined,
+                self: Array.isArray(memory.self) ? normalizeStringArray(memory.self) : undefined,
+                work: Array.isArray(memory.work) ? normalizeStringArray(memory.work) : undefined,
+            },
+        } : {}),
+    };
+}
+function parseCoreCmObservationReview(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const resultQuality = normalizeCoreCmResultQuality(record.resultQuality);
+    const completionDecision = normalizeCoreCmCompletionDecision(record.completionDecision);
+    const followUpNeeded = typeof record.followUpNeeded === "boolean" ? record.followUpNeeded : undefined;
+    const reportText = typeof record.reportText === "string" && record.reportText.trim()
+        ? record.reportText.trim()
+        : undefined;
+    const summary = typeof record.summary === "string" && record.summary.trim()
+        ? record.summary.trim()
+        : undefined;
+    if (!resultQuality && !completionDecision && followUpNeeded === undefined && !reportText && !summary)
+        return undefined;
+    return {
+        ...(resultQuality ? { resultQuality } : {}),
+        ...(completionDecision ? { completionDecision } : {}),
+        ...(followUpNeeded !== undefined ? { followUpNeeded } : {}),
+        ...(reportText ? { reportText } : {}),
+        ...(summary ? { summary } : {}),
+    };
+}
+function createCoreCmObservationReviewDraft(input) {
+    const completionDecision = input.response.review?.completionDecision
+        || deriveCoreCmCompletionDecision(input.observation);
+    const resultQuality = input.response.review?.resultQuality
+        || deriveCoreCmResultQuality(input.observation, completionDecision);
+    const followUpNeeded = typeof input.response.review?.followUpNeeded === "boolean"
+        ? input.response.review.followUpNeeded
+        : completionDecision !== "complete";
+    return {
+        resultQuality,
+        completionDecision,
+        followUpNeeded,
+        reportText: truncateReviewText(input.response.review?.reportText || input.output, 4000),
+        summary: input.response.review?.summary || input.response.processNote || summarizeCoreCmReviewDecision(resultQuality, completionDecision),
+    };
+}
+function createCoreCmFallbackReviewDraft(input) {
+    const completionDecision = deriveCoreCmCompletionDecision(input.observation);
+    const resultQuality = deriveCoreCmResultQuality(input.observation, completionDecision);
+    return {
+        resultQuality,
+        completionDecision,
+        followUpNeeded: completionDecision !== "complete",
+        reportText: truncateReviewText(input.output, 4000),
+        summary: summarizeCoreCmReviewDecision(resultQuality, completionDecision),
+    };
+}
+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;
+}
+function deriveCoreCmCompletionDecision(observation) {
+    if (!observation.ok)
+        return "blocked";
+    if (observation.capability === "send_input") {
+        const newOutput = typeof observation.data?.newOutput === "string"
+            ? observation.data.newOutput.trim()
+            : "";
+        return newOutput ? "complete" : "needs_follow_up";
+    }
+    return "complete";
+}
+function deriveCoreCmResultQuality(observation, completionDecision) {
+    if (!observation.ok || completionDecision === "blocked")
+        return "failed";
+    if (completionDecision === "partial" || completionDecision === "needs_follow_up")
+        return "partial";
+    return "good";
+}
+function summarizeCoreCmReviewDecision(resultQuality, completionDecision) {
+    return `Core CM review recorded ${completionDecision} completion with ${resultQuality} result quality.`;
+}
+function truncateReviewText(value, maxChars) {
+    const text = value.trim();
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function formatCoreCmObservationResponse(response) {
+    const answer = response.answer.trim();
+    const memoryText = formatMemoryProposal(response.memory);
+    return [
+        answer || "I do not have a useful answer yet.",
+        memoryText,
+    ].filter(Boolean).join("\n\n");
+}
+function formatInteractiveSessionObservationFallback(ownerText, proposal, observation, ownerLanguage) {
+    const chinese = shouldUseChineseOwnerText(ownerLanguage, ownerText);
+    const lines = [observation.summary];
+    if (!observation.ok) {
+        lines.push("", chinese
+            ? "这次外设调用没有完成。我没有写入记忆。"
+            : "This peripheral action did not complete. I did not write any memory.");
+        return lines.join("\n");
+    }
+    const newOutput = typeof observation.data?.newOutput === "string"
+        ? observation.data.newOutput.trim()
+        : "";
+    if (proposal.capability === "send_input" && !newOutput) {
+        lines.push("", chinese
+            ? "我还没有看到这个会话返回新输出。需要的话，你可以让我稍后再检查这个会话。"
+            : "I have not seen new output from this session yet. You can ask me to inspect it again later if you need the result.");
+    }
+    else {
+        lines.push("", chinese
+            ? "这次结果不需要写入长期记忆。"
+            : "No long-term memory change is needed for this result.");
+    }
+    return lines.join("\n");
+}
+function shouldUseChineseOwnerText(ownerLanguage, ownerText) {
+    const normalized = typeof ownerLanguage === "string" && ownerLanguage.trim()
+        ? ownerLanguage.trim().toLowerCase()
+        : "auto";
+    if (normalized === "auto")
+        return /[\u3400-\u9fff]/.test(ownerText || "");
+    return normalized === "zh"
+        || normalized === "zh-cn"
+        || normalized === "zh_cn"
+        || normalized === "chinese"
+        || normalized === "simplified chinese"
+        || normalized === "中文"
+        || normalized === "简体中文";
+}
+function formatMemoryProposal(memory) {
+    if (!memory)
+        return "";
+    const lines = [];
+    if (memory.summary?.trim())
+        lines.push(memory.summary.trim());
+    return lines.join("\n");
+}
+async function buildCoreCmConversationContext(input) {
+    if (!input.conversationId)
+        return "- No conversation id was provided for this chat.";
+    try {
+        const conversation = await loadConversation(input.workdir, input.agentName, input.conversationId);
+        const context = buildLLMContext(conversation, 4_000).text.trim();
+        return context || "- No prior turns in this conversation.";
+    }
+    catch (error) {
+        return `- Conversation context could not be loaded: ${error?.message || String(error)}`;
+    }
+}
+async function buildCoreCmMemoryContext(input) {
+    try {
+        return await formatCurrentMemoryForCoreCm({
+            agentName: input.agentName,
+            workdir: input.workdir,
+            scope: "all",
+        });
+    }
+    catch (error) {
+        return [
+            "Akemon memory could not be loaded for this chat turn.",
+            `Reason: ${error?.message || String(error)}`,
+            "",
+            "Pending memory proposals:",
+            describePendingMemoryProposalsForCoreCm(input),
+        ].join("\n");
+    }
+}
+function describeInteractiveSessionsForCoreCm(interactiveSessions) {
+    if (!interactiveSessions) {
+        return "- Interactive session adapter is not available in this runtime.";
+    }
+    const sessions = interactiveSessions.listSessions();
+    if (!sessions.length) {
+        return "- No interactive sessions are currently active or recently tracked.";
+    }
+    return sessions.map((session) => {
+        return [
+            `- ${session.sessionId}`,
+            `  tool: ${session.tool}`,
+            `  status: ${session.status}`,
+            `  command: ${session.commandLineDisplay}`,
+            `  workdir: ${session.workdir}`,
+            `  size: ${session.cols}x${session.rows}`,
+            `  log: ${session.logPath}`,
+        ].join("\n");
+    }).join("\n");
+}
+function normalizeStringArray(value) {
+    return value.map((item) => String(item));
+}
+function normalizeSendInputWaitMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return DEFAULT_SEND_INPUT_WAIT_MS;
+    return Math.max(0, Math.min(Math.round(value), MAX_SEND_INPUT_WAIT_MS));
+}