akemon 0.3.6 → 0.3.7

package/dist/mcp-server.js

@@ -17,7 +17,10 @@ import { biosPath, loadBioState, saveBioState, localNow, bioStatePromptModifier,
 async function handleCallAgent(agentName, target, task) {
     console.log(`[call_agent] ${agentName} → ${target}: ${task.slice(0, 80)}`);
     try {
-        const result = await callAgent(target, task);
+        const result = await callAgent(target, task, {
+            sourceAgent: agentName,
+            memoryScope: "task",
+        });
         return { content: [{ type: "text", text: result }] };
     }
     catch (err) {

package/dist/memory-proposal.js

@@ -0,0 +1,379 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { appendImpression, loadImpressions, selfDir } from "./self.js";
+import { appendWorkMemoryNote, buildWorkMemoryContext } from "./work-memory.js";
+const pendingMemoryProposals = new Map();
+export const MEMORY_ACTION_PROPOSAL_GUIDE = [
+    "[Akemon Memory Proposal Contract]",
+    "Akemon memory is Akemon's own memory mechanism. It is not CLAUDE.md, ChatGPT memory, Claude memory, or an external agent's private memory.",
+    "When the owner asks Akemon to remember something and provides the content, output only JSON in this exact shape:",
+    "{",
+    "  \"kind\": \"memory_proposal\",",
+    "  \"answer\": \"natural-language reply to the owner; do not mention JSON or internal proposal mechanics\",",
+    "  \"memory\": {",
+    "    \"summary\": \"why this may be useful to remember\",",
+    "    \"self\": [\"optional Akemon self-memory item\"],",
+    "    \"work\": [\"optional owner/project work-memory item\"]",
+    "  },",
+    "  \"reason\": \"short machine-readable reason\",",
+    "  \"processNote\": \"one concise owner-facing sentence explaining why Memory CM is proposing this\"",
+    "}",
+    "",
+    "Memory proposal rules:",
+    "- Use memory_proposal for owner phrases such as remember, 记住, 记一下, 以后默认, 偏好, 写入记忆, Akemon 记住.",
+    "- Prefer work memory for project preferences, project decisions, repo conventions, and owner instructions scoped to the current workdir.",
+    "- Prefer self memory for Akemon's own durable behavior or identity, not project facts.",
+    "- Do not redirect Akemon memory requests to CLAUDE.md or other external files unless the owner explicitly asks to edit those files.",
+    "- Do not claim memory has been written when creating a proposal; Akemon will show the pending memory to the owner for confirmation.",
+    "- Always write processNote in the configured owner-facing language. It is for the CM area, not a debug log.",
+    "",
+    "[Memory Action Proposal Contract]",
+    "Use this only when the owner is responding to a pending Akemon memory suggestion.",
+    "Output only JSON in this exact shape:",
+    "{",
+    "  \"kind\": \"memory_action\",",
+    "  \"action\": \"list_pending\" | \"show_memory\" | \"accept_pending\" | \"reject_pending\" | \"revise_pending\",",
+    "  \"proposalId\": \"latest\" | string,",
+    "  \"scope\": \"self\" | \"work\" | \"all\",",
+    "  \"memory\": { \"summary\": \"optional revised summary\", \"self\": [\"optional revised self-memory item\"], \"work\": [\"optional revised work-memory item\"] },",
+    "  \"reason\": \"short machine-readable reason\",",
+    "  \"processNote\": \"one concise owner-facing sentence explaining the memory action\"",
+    "}",
+    "",
+    "Rules:",
+    "- Use show_memory when the owner asks what Akemon remembers or what work memory contains.",
+    "- Use accept_pending only when the owner clearly confirms that the pending memory should be kept.",
+    "- Use reject_pending only when the owner clearly rejects or cancels the pending memory.",
+    "- Use revise_pending when the owner says the pending suggestion is wrong and gives replacement wording.",
+    "- Use list_pending when the owner asks what Akemon is waiting to remember.",
+    "- Use proposalId \"latest\" when the owner refers to the most recent pending memory.",
+    "- Default scope to \"all\" when the owner says a general phrase such as remember this.",
+    "- Do not write memory yourself. Akemon will execute the memory action after this JSON is returned.",
+].join("\n");
+export function createMemoryProposal(input) {
+    const self = normalizeMemoryItems(input.content?.self);
+    const work = normalizeMemoryItems(input.content?.work);
+    if (!self.length && !work.length)
+        return null;
+    const now = new Date().toISOString();
+    const proposal = {
+        id: `mem_${Date.now()}_${randomUUID().slice(0, 8)}`,
+        createdAt: now,
+        updatedAt: now,
+        agentName: input.agentName,
+        workdir: input.workdir,
+        source: input.source,
+        status: "pending",
+        summary: cleanOptionalText(input.content?.summary),
+        self,
+        work,
+        reason: cleanOptionalText(input.reason),
+    };
+    pendingMemoryProposals.set(proposal.id, proposal);
+    return proposal;
+}
+export function describePendingMemoryProposalsForCoreCm(input) {
+    const proposals = listPendingMemoryProposals(input);
+    if (!proposals.length)
+        return "- No pending memory proposals.";
+    return proposals.map((proposal) => {
+        const lines = [
+            `- ${proposal.id}`,
+            `  summary: ${proposal.summary || "(none)"}`,
+            `  self: ${proposal.self.length ? proposal.self.join(" | ") : "(none)"}`,
+            `  work: ${proposal.work.length ? proposal.work.join(" | ") : "(none)"}`,
+        ];
+        return lines.join("\n");
+    }).join("\n");
+}
+export function formatMemoryProposalForOwner(proposal) {
+    const lines = [
+        "I have a memory suggestion waiting for confirmation.",
+    ];
+    if (proposal.summary)
+        lines.push(proposal.summary);
+    if (proposal.self.length)
+        lines.push(`Akemon self memory: ${proposal.self.join("; ")}`);
+    if (proposal.work.length)
+        lines.push(`Work memory: ${proposal.work.join("; ")}`);
+    lines.push("You can tell me to remember it or ignore it.");
+    return lines.join("\n");
+}
+export function formatPendingMemoryProposalsForOwner(input) {
+    const proposals = listPendingMemoryProposals(input);
+    if (!proposals.length)
+        return "There are no pending memory suggestions.";
+    return [
+        `There ${proposals.length === 1 ? "is" : "are"} ${proposals.length} pending memory suggestion${proposals.length === 1 ? "" : "s"}.`,
+        "",
+        ...proposals.map(formatMemoryProposalForOwner),
+    ].join("\n");
+}
+export async function formatCurrentMemoryForOwner(input) {
+    const scope = normalizeScope(input.scope);
+    const sections = [];
+    if (scope === "self" || scope === "all") {
+        const impressions = await loadImpressions(input.workdir, input.agentName, 30);
+        const selfMemory = impressions
+            .filter((entry) => entry.cat === "owner_confirmed_memory")
+            .slice(-20);
+        sections.push("Akemon self memory:");
+        if (selfMemory.length) {
+            sections.push(...selfMemory.map((entry) => `- ${entry.text}`));
+        }
+        else {
+            sections.push("- No owner-confirmed self memory found.");
+        }
+    }
+    if (scope === "work" || scope === "all") {
+        const packet = await buildWorkMemoryContext({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            purpose: "Akemon chat memory review",
+            budget: 5_000,
+        });
+        sections.push("Project work memory:");
+        sections.push(formatWorkMemoryForOwner(packet));
+    }
+    if (scope === "all") {
+        sections.push("Pending memory suggestions:");
+        sections.push(formatPendingMemoryProposalsForOwner(input));
+    }
+    return sections.join("\n\n");
+}
+export async function formatCurrentMemoryForCoreCm(input) {
+    const scope = normalizeScope(input.scope);
+    const sections = [];
+    if (scope === "self" || scope === "all") {
+        const impressions = await loadImpressions(input.workdir, input.agentName, 30);
+        const selfMemory = impressions
+            .filter((entry) => entry.cat === "owner_confirmed_memory")
+            .slice(-20);
+        sections.push("Akemon self memory:");
+        if (selfMemory.length) {
+            sections.push(...selfMemory.map((entry) => `- ${entry.text}`));
+        }
+        else {
+            sections.push("- No owner-confirmed self memory found.");
+        }
+    }
+    if (scope === "work" || scope === "all") {
+        const packet = await buildWorkMemoryContext({
+            workdir: input.workdir,
+            agentName: input.agentName,
+            purpose: "Akemon Core CM memory context",
+            budget: 8_000,
+        });
+        sections.push("Project work memory:");
+        sections.push(packet.sections.length ? packet.text : `- No project work memory found in ${packet.workMemoryDir}.`);
+    }
+    if (scope === "all") {
+        sections.push("Pending memory suggestions:");
+        sections.push(formatPendingMemoryProposalsForOwner(input));
+    }
+    return sections.join("\n\n");
+}
+function formatWorkMemoryForOwner(packet) {
+    const contentSections = packet.sections
+        .filter((section) => section.title !== "work memory file index")
+        .map(formatWorkMemorySectionForOwner)
+        .filter(Boolean);
+    if (!contentSections.length)
+        return "- No project work memory found.";
+    return contentSections.join("\n");
+}
+function formatWorkMemorySectionForOwner(section) {
+    const content = section.content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("Source:") && !line.startsWith("## "))
+        .join("\n")
+        .trim();
+    if (!content)
+        return "";
+    const oneLine = content.replace(/\s+/g, " ").trim();
+    const excerpt = oneLine.length > 600 ? `${oneLine.slice(0, 597)}...` : oneLine;
+    return `- ${section.relativePath || section.title}: ${excerpt}`;
+}
+export async function executeMemoryActionProposal(input) {
+    const result = await executeMemoryActionProposalWithResult(input);
+    return result.output;
+}
+export async function executeMemoryActionProposalWithResult(input) {
+    const requestedProposalId = input.proposal.proposalId?.trim();
+    if (input.proposal.action === "list_pending") {
+        return {
+            output: formatPendingMemoryProposalsForOwner(input),
+            action: input.proposal.action,
+            status: "listed",
+            proposalId: requestedProposalId,
+            scope: normalizeScope(input.proposal.scope),
+        };
+    }
+    if (input.proposal.action === "show_memory") {
+        const scope = normalizeScope(input.proposal.scope);
+        return {
+            output: await formatCurrentMemoryForOwner({
+                agentName: input.agentName,
+                workdir: input.workdir,
+                scope,
+            }),
+            action: input.proposal.action,
+            status: "shown",
+            proposalId: requestedProposalId,
+            scope,
+        };
+    }
+    const proposal = resolvePendingMemoryProposal(input);
+    if (!proposal) {
+        return {
+            output: "I could not find a pending memory suggestion to update.",
+            action: input.proposal.action,
+            status: "not_found",
+            proposalId: requestedProposalId,
+            scope: normalizeScope(input.proposal.scope),
+            error: "pending memory proposal not found",
+        };
+    }
+    if (input.proposal.action === "reject_pending") {
+        proposal.status = "rejected";
+        proposal.updatedAt = new Date().toISOString();
+        proposal.reason = cleanOptionalText(input.proposal.reason) || proposal.reason;
+        return {
+            output: "I discarded that pending memory suggestion.",
+            action: input.proposal.action,
+            status: "rejected",
+            proposalId: requestedProposalId,
+            resolvedProposalId: proposal.id,
+            scope: normalizeScope(input.proposal.scope),
+            selfCount: proposal.self.length,
+            workCount: proposal.work.length,
+        };
+    }
+    if (input.proposal.action === "revise_pending") {
+        const self = normalizeMemoryItems(input.proposal.memory?.self);
+        const work = normalizeMemoryItems(input.proposal.memory?.work);
+        if (!self.length && !work.length) {
+            return {
+                output: "I could not revise that memory suggestion because the replacement did not contain any memory content.",
+                action: input.proposal.action,
+                status: "invalid",
+                proposalId: requestedProposalId,
+                resolvedProposalId: proposal.id,
+                scope: normalizeScope(input.proposal.scope),
+                error: "replacement did not contain memory content",
+            };
+        }
+        proposal.summary = cleanOptionalText(input.proposal.memory?.summary) || proposal.summary;
+        proposal.self = self;
+        proposal.work = work;
+        proposal.reason = cleanOptionalText(input.proposal.reason) || proposal.reason;
+        proposal.updatedAt = new Date().toISOString();
+        return {
+            output: [
+                "I updated that pending memory suggestion.",
+                "",
+                formatMemoryProposalForOwner(proposal),
+            ].join("\n"),
+            action: input.proposal.action,
+            status: "revised",
+            proposalId: requestedProposalId,
+            resolvedProposalId: proposal.id,
+            scope: normalizeScope(input.proposal.scope),
+            selfCount: proposal.self.length,
+            workCount: proposal.work.length,
+        };
+    }
+    const scope = normalizeScope(input.proposal.scope);
+    const writtenWorkMemoryPaths = [];
+    if ((scope === "self" || scope === "all") && proposal.self.length) {
+        await mkdir(selfDir(input.workdir, input.agentName), { recursive: true });
+        for (const item of proposal.self) {
+            await appendImpression(input.workdir, input.agentName, "owner_confirmed_memory", item);
+        }
+    }
+    if ((scope === "work" || scope === "all") && proposal.work.length) {
+        for (const item of proposal.work) {
+            const result = await appendWorkMemoryNote({
+                workdir: input.workdir,
+                agentName: input.agentName,
+                text: item,
+                source: "user",
+                kind: "akemon-chat-memory-proposal",
+            });
+            writtenWorkMemoryPaths.push(result.path);
+        }
+    }
+    proposal.status = "accepted";
+    proposal.updatedAt = new Date().toISOString();
+    proposal.acceptedScopes = [scope];
+    proposal.writtenWorkMemoryPaths = writtenWorkMemoryPaths;
+    return {
+        output: formatAcceptedMemoryProposal(proposal, scope),
+        action: input.proposal.action,
+        status: "accepted",
+        proposalId: requestedProposalId,
+        resolvedProposalId: proposal.id,
+        scope,
+        selfCount: proposal.self.length,
+        workCount: proposal.work.length,
+        writtenWorkMemoryPaths,
+    };
+}
+function listPendingMemoryProposals(input) {
+    return Array.from(pendingMemoryProposals.values())
+        .filter((proposal) => {
+        return proposal.status === "pending"
+            && proposal.agentName === input.agentName
+            && proposal.workdir === input.workdir;
+    })
+        .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+function resolvePendingMemoryProposal(input) {
+    const proposalId = input.proposal.proposalId?.trim();
+    if (!proposalId || proposalId === "latest" || proposalId === "last") {
+        return listPendingMemoryProposals(input)[0] || null;
+    }
+    const proposal = pendingMemoryProposals.get(proposalId);
+    if (!proposal || proposal.status !== "pending")
+        return null;
+    if (proposal.agentName !== input.agentName || proposal.workdir !== input.workdir)
+        return null;
+    return proposal;
+}
+function formatAcceptedMemoryProposal(proposal, scope) {
+    const remembered = [];
+    if ((scope === "self" || scope === "all") && proposal.self.length) {
+        remembered.push("Akemon self memory");
+    }
+    if ((scope === "work" || scope === "all") && proposal.work.length) {
+        remembered.push("work memory");
+    }
+    if (!remembered.length)
+        return "That memory suggestion did not contain anything for the selected scope.";
+    return `I remembered that in ${remembered.join(" and ")}.`;
+}
+function normalizeScope(scope) {
+    if (scope === "self" || scope === "work" || scope === "all")
+        return scope;
+    return "all";
+}
+function normalizeMemoryItems(items) {
+    if (!Array.isArray(items))
+        return [];
+    const normalized = [];
+    for (const item of items) {
+        const text = cleanOptionalText(item);
+        if (text)
+            normalized.push(text);
+    }
+    return normalized;
+}
+function cleanOptionalText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > 1000 ? `${trimmed.slice(0, 997)}...` : trimmed;
+}