akemon 0.3.6 → 0.3.7

package/dist/memory-recorder.js

@@ -0,0 +1,368 @@
+const BUILTIN_MEMORY_RECORDERS = [
+    {
+        id: "agent-home-initialization",
+        title: "Agent home and self-memory initialization",
+        source: "builtin",
+        owner: "self",
+        trigger: {
+            event: "agent:first-use",
+            description: "Creates the per-agent home, config, self directories, world guide, identity seed, and bio-state.",
+        },
+        destinations: [
+            destination("config", "~/.akemon/agents/{agent}/config.json", "json", "create", "Per-agent runtime configuration."),
+            destination("self", "~/.akemon/agents/{agent}/self/world.md", "markdown", "create", "World and network orientation."),
+            destination("self", "~/.akemon/agents/{agent}/self/identity.jsonl", "jsonl", "create", "Initial identity snapshot."),
+            destination("self", "~/.akemon/agents/{agent}/self/bio-state.json", "json", "create", "Initial bio-state."),
+            destination("self", "~/.akemon/agents/{agent}/self/guide.md", "markdown", "create", "Relay/network operating guide when relay is enabled."),
+        ],
+        privacy: privacy(false, false, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/akemon-home.ts"],
+    },
+    {
+        id: "conversation-transcript",
+        title: "Conversation transcript",
+        source: "builtin",
+        owner: "context",
+        trigger: {
+            event: "conversation:message",
+            description: "Appends owner/agent chat and order rounds to a local markdown conversation transcript.",
+        },
+        destinations: [
+            destination("conversation", "{workdir}/.akemon/agents/{agent}/conversations/{conversation}.md", "markdown", "append", "Conversation summary and recent rounds."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/context.ts", "src/mcp-server.ts", "src/task-module.ts"],
+    },
+    {
+        id: "product-context-log",
+        title: "Product interaction context",
+        source: "builtin",
+        owner: "context",
+        trigger: {
+            event: "product:interaction",
+            description: "Records product purchase requests/responses and creates product notes for service improvement.",
+        },
+        destinations: [
+            destination("product", "{workdir}/.akemon/products/{product}/history.log", "log", "append", "Product interaction request/response excerpts."),
+            destination("product", "{workdir}/.akemon/products/{product}/notes.md", "markdown", "create", "Editable product context notes."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/context.ts", "src/mcp-server.ts"],
+    },
+    {
+        id: "task-history",
+        title: "Task execution history",
+        source: "builtin",
+        owner: "task",
+        trigger: {
+            event: "task:completed",
+            description: "Records concise task/order execution outcome summaries.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/task-history.jsonl", "jsonl", "append", "Recent task outcome ledger."),
+            destination("self", "~/.akemon/agents/{agent}/self/task-runs.json", "json", "overwrite", "Due-task run timestamps."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/task-module.ts"],
+    },
+    {
+        id: "subjective-impressions",
+        title: "Subjective impressions",
+        source: "module",
+        owner: "memory",
+        trigger: {
+            event: "impression:new",
+            description: "Records subjective observations, decisions, activity notes, and errors for later digestion.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/impressions.jsonl", "jsonl", "append", "Subjective impression records; digestion can compress or mark entries."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/memory-module.ts", "src/script-module.ts", "src/task-module.ts"],
+    },
+    {
+        id: "identity-and-summary",
+        title: "Identity snapshots and summary",
+        source: "module",
+        owner: "memory",
+        trigger: {
+            event: "digestion:complete",
+            description: "Writes identity snapshots and compressed identity summary from self-cycle digestion.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/identity.jsonl", "jsonl", "append", "Five-question identity snapshots."),
+            destination("self", "~/.akemon/agents/{agent}/self/identity-summary.json", "json", "overwrite", "Compressed identity summary."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/memory-module.ts"],
+    },
+    {
+        id: "structured-self-memory",
+        title: "Structured self-memory stores",
+        source: "module",
+        owner: "memory",
+        trigger: {
+            event: "digestion:complete",
+            description: "Updates projects, relationships, discoveries, and canvas entries from digestion/reflection modules.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/projects.jsonl", "jsonl", "overwrite", "Long-term project records."),
+            destination("self", "~/.akemon/agents/{agent}/self/relationships.jsonl", "jsonl", "overwrite", "Social relationship records."),
+            destination("self", "~/.akemon/agents/{agent}/self/discoveries.jsonl", "jsonl", "overwrite", "Lessons and capability discoveries."),
+            destination("self", "~/.akemon/agents/{agent}/self/canvas/{timestamp}.md", "markdown", "create", "Creative inner-canvas entries."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/memory-module.ts", "src/social-module.ts", "src/longterm-module.ts", "src/reflection-module.ts"],
+    },
+    {
+        id: "bio-state-and-events",
+        title: "Bio-state and bio events",
+        source: "module",
+        owner: "biostate",
+        trigger: {
+            event: "bio:update",
+            description: "Updates bio-state and appends bounded bio event records from tasks, token usage, digestion, and shop actions.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/bio-state.json", "json", "overwrite", "Current hunger, mood, energy, boredom, fear, and personality state."),
+            destination("self", "~/.akemon/agents/{agent}/self/bio-events.jsonl", "jsonl", "append", "Recent bio event ledger."),
+        ],
+        privacy: privacy(false, false, false),
+        enabled: true,
+        sourceFiles: ["src/self.ts", "src/bio-module.ts", "src/task-module.ts", "src/mcp-server.ts"],
+    },
+    {
+        id: "role-playbook-product-files",
+        title: "Role, playbook, and product files",
+        source: "builtin",
+        owner: "role",
+        trigger: {
+            event: "role-or-product:update",
+            description: "Creates and updates role, playbook, and product markdown files; reflection may append playbook experience.",
+        },
+        destinations: [
+            destination("self", "~/.akemon/agents/{agent}/self/roles/{name}.md", "markdown", "create", "Role definitions and context boundaries."),
+            destination("self", "~/.akemon/agents/{agent}/self/playbooks/{name}.md", "markdown", "append", "Reusable domain playbooks and experience notes."),
+            destination("self", "~/.akemon/agents/{agent}/self/products/{name}.md", "markdown", "create", "Product-to-playbook mappings."),
+        ],
+        privacy: privacy(false, true, false),
+        enabled: true,
+        sourceFiles: ["src/role-module.ts", "src/reflection-module.ts"],
+        notes: "Natural-language reusable rules should eventually consolidate into relevant skill/playbook files through proposals and conflict review.",
+    },
+    {
+        id: "work-memory-note",
+        title: "Work memory notes",
+        source: "builtin",
+        owner: "work-memory",
+        trigger: {
+            event: "work-memory:note",
+            description: "Appends user or software-agent work notes to project or global work memory.",
+        },
+        destinations: [
+            destination("work", "{workdir}/.akemon/work/inbox.md", "markdown", "append", "Project-scoped work memory inbox."),
+            destination("work", "~/.akemon/agents/{agent}/work/inbox.md", "markdown", "append", "Global per-agent work memory inbox."),
+        ],
+        privacy: privacy(true, true, false),
+        enabled: true,
+        sourceFiles: ["src/work-memory.ts", "src/cli.ts"],
+    },
+    {
+        id: "software-agent-ledger",
+        title: "Software-agent task ledger and context sessions",
+        source: "builtin",
+        owner: "software-agent",
+        trigger: {
+            event: "software-agent:task",
+            description: "Records Codex software-agent task envelopes, summaries, environment audit, context packets, and session state.",
+        },
+        destinations: [
+            destination("software-agent", "{workdir}/.akemon/agents/{agent}/software-agent/tasks/{taskId}.json", "json", "overwrite", "Per-task software-agent ledger record."),
+            destination("software-agent", "{workdir}/.akemon/agents/{agent}/software-agent/sessions/{session}/TASK_CONTEXT.md", "markdown", "overwrite", "Akemon-generated context packet."),
+            destination("software-agent", "{workdir}/.akemon/agents/{agent}/software-agent/sessions/{session}/SESSION.json", "json", "overwrite", "Akemon-side software-agent session state."),
+        ],
+        privacy: privacy(true, true, false),
+        enabled: true,
+        sourceFiles: ["src/software-agent-peripheral.ts", "src/software-agent-transport.ts", "src/software-agent-memory.ts", "src/server.ts"],
+    },
+    {
+        id: "local-peer-contact",
+        title: "Local peer contact metadata",
+        source: "builtin",
+        owner: "local-interconnect",
+        trigger: {
+            event: "akemon.message",
+            description: "Records sent/received local Akemon peer contact metadata without merging self memory.",
+        },
+        destinations: [
+            destination("contacts", "~/.akemon/agents/{agent}/contacts/local-peers.jsonl", "jsonl", "append", "Local peer message metadata."),
+        ],
+        privacy: privacy(false, false, false),
+        enabled: true,
+        sourceFiles: ["src/local-interconnect.ts", "src/server.ts", "src/cli.ts"],
+    },
+    {
+        id: "accepted-social-contact",
+        title: "Accepted social contact metadata",
+        source: "builtin",
+        owner: "social-discovery",
+        trigger: {
+            event: "akemon.intro.response",
+            description: "Records accepted relay/local social introductions as contact metadata.",
+        },
+        destinations: [
+            destination("contacts", "~/.akemon/agents/{agent}/contacts/accepted-social-contacts.jsonl", "jsonl", "append", "Accepted social relationship metadata."),
+        ],
+        privacy: privacy(false, false, false),
+        enabled: true,
+        sourceFiles: ["src/social-discovery.ts"],
+    },
+    {
+        id: "persistent-event-log",
+        title: "Persistent event log",
+        source: "builtin",
+        owner: "event-bus",
+        trigger: {
+            event: "*",
+            description: "Appends emitted core/module/peripheral signals for recovery and later audit.",
+        },
+        destinations: [
+            destination("events", "{workdir}/.akemon/agents/{agent}/events/events.jsonl", "jsonl", "append", "Append-only event stream."),
+        ],
+        privacy: privacy(true, true, false),
+        enabled: true,
+        sourceFiles: ["src/event-bus.ts", "src/server.ts"],
+    },
+    {
+        id: "relay-staged-artifact-imports",
+        title: "Relay-staged artifact imports",
+        source: "builtin",
+        owner: "relay",
+        trigger: {
+            event: "relay:pull",
+            description: "Stages relay-hosted games, notes, and pages as external import candidates.",
+        },
+        destinations: [
+            destination("inbox", "~/.akemon/agents/{agent}/inbox/relay-imports/games/{slug}.html", "html", "create", "Relay-hosted game import candidates."),
+            destination("inbox", "~/.akemon/agents/{agent}/inbox/relay-imports/notes/{slug}.md", "markdown", "create", "Relay-hosted note import candidates."),
+            destination("inbox", "~/.akemon/agents/{agent}/inbox/relay-imports/pages/{slug}.html", "html", "create", "Relay-hosted page import candidates."),
+            destination("inbox", "~/.akemon/agents/{agent}/inbox/relay-imports/{kind}/{slug}.{ext}.relay-import.json", "json", "create", "Sidecar source and authority metadata."),
+        ],
+        privacy: privacy(false, false, true),
+        enabled: true,
+        sourceFiles: ["src/relay-peripheral.ts", "src/server.ts"],
+        notes: "Relay data is an external source. Staging does not make it canonical self memory; owner-approved import is required before writing self.",
+    },
+    {
+        id: "local-instance-registry",
+        title: "Local runtime instance registry",
+        source: "builtin",
+        owner: "local-registry",
+        trigger: {
+            event: "agent:start",
+            description: "Tracks running local Akemon instances so CLI commands can select by name.",
+        },
+        destinations: [
+            destination("runtime", "~/.akemon/runtime/instances.json", "json", "overwrite", "Running local instance registry."),
+        ],
+        privacy: privacy(false, false, false),
+        enabled: true,
+        sourceFiles: ["src/local-registry.ts", "src/server.ts"],
+    },
+    {
+        id: "peripheral-registry",
+        title: "Peripheral configuration registry",
+        source: "builtin",
+        owner: "peripheral-registry",
+        trigger: {
+            event: "peripheral:registered",
+            description: "Records configured and runtime-discovered peripheral descriptors for routing and exploration.",
+        },
+        destinations: [
+            destination("config", "~/.akemon/agents/{agent}/peripherals/registry.json", "json", "overwrite", "Configured peripheral records with capabilities, risk, allowed actions, and explore behavior."),
+        ],
+        privacy: privacy(true, false, false),
+        enabled: true,
+        sourceFiles: ["src/peripheral-registry.ts", "src/server.ts", "src/cli.ts"],
+        notes: "This registry stores peripheral descriptors and should not treat peripheral state or explore output as canonical self memory.",
+    },
+    {
+        id: "permission-audit-log",
+        title: "Permission and action audit log",
+        source: "builtin",
+        owner: "permission-audit",
+        trigger: {
+            event: "permission:audit",
+            description: "Appends inspectable records for risk-relevant actions and permission decisions.",
+        },
+        destinations: [
+            destination("audit", "~/.akemon/agents/{agent}/audit/actions.jsonl", "jsonl", "append", "Action audit records for software-agent tasks, inter-Akemon messages, relay publication, and work-memory writes."),
+        ],
+        privacy: privacy(true, true, false),
+        enabled: true,
+        sourceFiles: [
+            "src/permission-audit.ts",
+            "src/software-agent-peripheral.ts",
+            "src/server.ts",
+            "src/relay-peripheral.ts",
+            "src/work-memory.ts",
+        ],
+        notes: "This is an audit trail for later approval UI and policy work. It records decisions and boundaries, not a full RBAC system.",
+    },
+];
+export function listMemoryRecorders(options = {}) {
+    return BUILTIN_MEMORY_RECORDERS
+        .filter((recorder) => options.enabled === undefined || recorder.enabled === options.enabled)
+        .filter((recorder) => !options.source || recorder.source === options.source)
+        .filter((recorder) => !options.scope || recorder.destinations.some((dest) => dest.scope === options.scope))
+        .map(cloneRecorder);
+}
+export function getMemoryRecorder(id) {
+    const normalized = id.trim();
+    const recorder = BUILTIN_MEMORY_RECORDERS.find((item) => item.id === normalized);
+    return recorder ? cloneRecorder(recorder) : null;
+}
+export function createMemoryWriteProposal(input) {
+    const recorder = getMemoryRecorder(input.recorderId);
+    if (!recorder)
+        throw new Error(`Unknown memory recorder: ${input.recorderId}`);
+    const destination = input.destinationPath
+        ? recorder.destinations.find((dest) => dest.path === input.destinationPath)
+        : recorder.destinations[0];
+    if (!destination)
+        throw new Error(`Unknown memory recorder destination: ${input.destinationPath}`);
+    const reason = input.reason.trim();
+    if (!reason)
+        throw new Error("Memory write proposal reason is required");
+    return {
+        recorderId: recorder.id,
+        ...(input.eventId ? { eventId: input.eventId } : {}),
+        destination,
+        record: input.record,
+        reason,
+        risk: input.risk || "low",
+        createdAt: input.createdAt || new Date().toISOString(),
+    };
+}
+function destination(scope, path, format, writeMode, description) {
+    return { scope, path, format, writeMode, description };
+}
+function privacy(redactsSecrets, includesOwnerMemory, approvalRequired) {
+    return { redactsSecrets, includesOwnerMemory, approvalRequired };
+}
+function cloneRecorder(recorder) {
+    return {
+        ...recorder,
+        trigger: { ...recorder.trigger },
+        destinations: recorder.destinations.map((dest) => ({ ...dest })),
+        privacy: { ...recorder.privacy },
+        sourceFiles: [...recorder.sourceFiles],
+    };
+}

package/dist/orphan-scan.js

@@ -10,6 +10,7 @@
  * processes that happen to have a matching command name.
  */
 import { execFile } from "child_process";
+import { getRuntimePlatform } from "./runtime-platform.js";
 // ---------------------------------------------------------------------------
 // Patterns — agent-mode invocations only (not install/update/etc.)
 // ---------------------------------------------------------------------------
@@ -48,32 +49,43 @@ export function parseProcessList(psOutput) {
 // Runtime — scan ps output and kill matched orphans
 // ---------------------------------------------------------------------------
 export async function scanAndKillOrphans() {
+    const runtime = getRuntimePlatform();
+    if (!runtime.capabilities.canScanOrphanProcesses) {
+        console.log(`[orphan] scan unsupported on platform=${runtime.platform}`);
+        return 0;
+    }
     return new Promise((resolve) => {
-        execFile("ps", ["-eo", "pid,ppid,command"], (err, stdout) => {
-            if (err) {
-                console.log(`[orphan] ps failed: ${err.message}`);
-                resolve(0);
-                return;
-            }
-            const orphans = parseProcessList(stdout);
-            if (orphans.length === 0) {
-                console.log("[orphan] none found");
-                resolve(0);
-                return;
-            }
-            let killed = 0;
-            for (const { pid, command } of orphans) {
-                console.log(`[orphan] killing pid=${pid} cmd="${command.slice(0, 80)}"`);
-                try {
-                    process.kill(pid, "SIGKILL");
-                    killed++;
+        try {
+            execFile("ps", ["-eo", "pid,ppid,command"], (err, stdout) => {
+                if (err) {
+                    console.log(`[orphan] ps failed: ${err.message}`);
+                    resolve(0);
+                    return;
+                }
+                const orphans = parseProcessList(stdout);
+                if (orphans.length === 0) {
+                    console.log("[orphan] none found");
+                    resolve(0);
+                    return;
                 }
-                catch (e) {
-                    console.log(`[orphan] failed to kill pid=${pid}: ${e.message}`);
+                let killed = 0;
+                for (const { pid, command } of orphans) {
+                    console.log(`[orphan] killing pid=${pid} cmd="${command.slice(0, 80)}"`);
+                    try {
+                        process.kill(pid, "SIGKILL");
+                        killed++;
+                    }
+                    catch (e) {
+                        console.log(`[orphan] failed to kill pid=${pid}: ${e.message}`);
+                    }
                 }
-            }
-            console.log(`[orphan] killed ${killed} process${killed !== 1 ? "es" : ""}`);
-            resolve(killed);
-        });
+                console.log(`[orphan] killed ${killed} process${killed !== 1 ? "es" : ""}`);
+                resolve(killed);
+            });
+        }
+        catch (err) {
+            console.log(`[orphan] ps failed: ${err.message || String(err)}`);
+            resolve(0);
+        }
     });
 }

package/dist/passive-reflection-cognitive-module.js

@@ -0,0 +1,172 @@
+import { appendCognitiveArtifact, } from "./cognitive-artifact-store.js";
+import { readCognitiveEvents, } from "./cognitive-event-log.js";
+const MIN_REFLECTION_VALUE_SCORE = 0.65;
+const MAX_EVENT_TEXT_LENGTH = 900;
+export function shouldRunPassiveReflection(input) {
+    if (!input.conversationId)
+        return false;
+    return (input.eventIds.peripheral?.length || 0) > 0
+        || (input.eventIds.cm?.length || 0) > 0;
+}
+export async function runPassiveReflectionOnce(input) {
+    if (!shouldRunPassiveReflection(input))
+        return null;
+    const events = await collectRecentEvents({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        conversationId: input.conversationId,
+    });
+    if (!events.length)
+        return null;
+    const result = await input.requestCompute({
+        taskId: `reflection:${input.conversationId || "unknown"}`,
+        taskKind: "reflection_passive",
+        purpose: "Reflection CM reviews recent chat, peripheral, and CM events for one high-value passive reflection.",
+        priority: "low",
+        origin: "reflection",
+        engineHints: {
+            requiredCapabilities: ["chat", "json", "reflection"],
+            maxCost: "medium",
+            maxLatency: "medium",
+        },
+        context: [
+            "[Akemon Reflection CM]",
+            `Agent: ${input.agentName}`,
+            "",
+            "You are a passive reflection sidecar for Akemon.",
+            "Review recent main chat, peripheral observations, and CM events.",
+            "Write one high-value reflection only when there is a non-obvious lesson, risk, recurring pattern, or useful next question.",
+            "Do not write memory. Do not ask the owner anything directly. Do not summarize routine actions.",
+            "",
+            "Return strict JSON only.",
+            "Use this schema:",
+            "{\"kind\":\"none\",\"reason\":\"...\"}",
+            "or",
+            "{\"kind\":\"reflection\",\"insight\":\"...\",\"reasoning\":\"...\",\"suggestedAction\":\"...\",\"valueScore\":0.0,\"confidence\":\"low|medium|high\",\"tags\":[\"...\"]}",
+        ].join("\n"),
+        question: [
+            "Recent event buffer:",
+            formatEventsForReflection(events),
+            "",
+            "Decide whether there is one valuable passive reflection to store.",
+        ].join("\n"),
+    });
+    if (!result.success || !result.response)
+        return null;
+    const decision = parseReflectionDecision(result.response);
+    if (!decision || decision.kind === "none")
+        return null;
+    const valueScore = clampScore(decision.valueScore);
+    if (valueScore < MIN_REFLECTION_VALUE_SCORE)
+        return null;
+    return appendCognitiveArtifact({
+        workdir: input.workdir,
+        agentName: input.agentName,
+        record: {
+            kind: "reflection",
+            refs: [createReflectionRef(input)],
+            tags: normalizeTags(["reflection", "passive", ...normalizeTags(decision.tags)]),
+            insight: decision.insight.trim(),
+            reasoning: decision.reasoning.trim(),
+            ...(decision.suggestedAction?.trim() ? { suggestedAction: decision.suggestedAction.trim() } : {}),
+            valueScore,
+            confidence: normalizeConfidence(decision.confidence),
+            surfaced: false,
+            outcome: "unknown",
+        },
+    });
+}
+async function collectRecentEvents(input) {
+    const [mainChat, peripheral, cm, task] = await Promise.all([
+        readCognitiveEvents({ workdir: input.workdir, agentName: input.agentName, stream: "main_chat", limit: 12 }),
+        readCognitiveEvents({ workdir: input.workdir, agentName: input.agentName, stream: "peripheral", limit: 8 }),
+        readCognitiveEvents({ workdir: input.workdir, agentName: input.agentName, stream: "cm", limit: 8 }),
+        readCognitiveEvents({ workdir: input.workdir, agentName: input.agentName, stream: "task", limit: 8 }),
+    ]);
+    return [...mainChat, ...peripheral, ...cm, ...task]
+        .filter((event) => !input.conversationId || event.conversationId === input.conversationId)
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+        .slice(-16);
+}
+function createReflectionRef(input) {
+    return {
+        conversationId: input.conversationId,
+        eventIds: [
+            ...(input.eventIds.mainChat || []),
+            ...(input.eventIds.peripheral || []),
+            ...(input.eventIds.cm || []),
+            ...(input.eventIds.task || []),
+        ],
+    };
+}
+function formatEventsForReflection(events) {
+    return events.map((event) => {
+        const prefix = `[${event.createdAt}] ${event.stream}:${event.id}`;
+        if (event.stream === "main_chat") {
+            return `${prefix} ${event.role}: ${truncate(event.text)}`;
+        }
+        if (event.stream === "peripheral") {
+            return `${prefix} ${event.peripheral}.${event.capability} ok=${event.ok}: ${truncate(event.summary)}`;
+        }
+        if (event.stream === "cm") {
+            return `${prefix} ${event.cm}.${event.itemType} status=${event.status || "info"}: ${truncate(event.summary)}`;
+        }
+        if (event.stream === "task") {
+            return `${prefix} task ${event.taskId} ${event.phase}/${event.status}: ${truncate(event.summary)}`;
+        }
+        return `${prefix} compute ${event.taskKind || "unknown"} success=${event.success}: ${event.inputChars} input chars`;
+    }).join("\n");
+}
+function parseReflectionDecision(raw) {
+    const json = extractJsonObject(raw.trim());
+    if (!json)
+        return null;
+    try {
+        const value = JSON.parse(json);
+        if (value.kind === "none")
+            return { kind: "none", reason: String(value.reason || "") };
+        if (value.kind !== "reflection")
+            return null;
+        const insight = typeof value.insight === "string" ? value.insight.trim() : "";
+        const reasoning = typeof value.reasoning === "string" ? value.reasoning.trim() : "";
+        if (!insight || !reasoning)
+            return null;
+        return {
+            kind: "reflection",
+            insight,
+            reasoning,
+            suggestedAction: typeof value.suggestedAction === "string" ? value.suggestedAction : undefined,
+            valueScore: typeof value.valueScore === "number" ? value.valueScore : undefined,
+            confidence: normalizeConfidence(value.confidence),
+            tags: normalizeTags(value.tags),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function extractJsonObject(raw) {
+    if (raw.startsWith("{") && raw.endsWith("}"))
+        return raw;
+    const start = raw.indexOf("{");
+    const end = raw.lastIndexOf("}");
+    if (start < 0 || end <= start)
+        return null;
+    return raw.slice(start, end + 1);
+}
+function normalizeConfidence(value) {
+    return value === "low" || value === "medium" || value === "high" ? value : "medium";
+}
+function normalizeTags(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map((tag) => String(tag).trim()).filter(Boolean))];
+}
+function clampScore(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function truncate(text) {
+    return text.length <= MAX_EVENT_TEXT_LENGTH ? text : `${text.slice(0, MAX_EVENT_TEXT_LENGTH)}...`;
+}