akm-cli 0.7.4 → 0.8.0-rc.10

package/dist/integrations/session-logs/pre-filter.js

@@ -0,0 +1,152 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/** Default cap for any single event's text length. Head+tail summary applies above this. */
+export const DEFAULT_MAX_EVENT_LENGTH = 2000;
+/**
+ * Default cap on total transcript characters fed to the LLM. Chosen for a
+ * 32K-token context model with room for the prompt scaffolding (~3K chars)
+ * and JSON output (~4K chars). Adjust via {@link PreFilterOptions.maxTotalChars}
+ * when targeting larger-context models.
+ */
+export const DEFAULT_MAX_TOTAL_CHARS = 80_000;
+/**
+ * `akm` subcommands that are read-only / introspective — their invocations
+ * are operational noise, not engineering signal. Mutating commands (remember,
+ * feedback, accept, reject, extract, import, save, ...) are kept.
+ */
+export const DEFAULT_AKM_READONLY_OPS = new Set([
+    "show",
+    "search",
+    "curate",
+    "history",
+    "info",
+    "hints",
+    "help",
+    "list",
+    "completions",
+    "lessons",
+    "graph",
+    "db",
+    "events",
+    "config",
+    "health",
+]);
+/**
+ * Regex patterns that identify post-compact / activity-log noise. Conservative
+ * — only matches text that's clearly transcript pollution, not engineering
+ * content that happens to contain similar words.
+ */
+const NOISE_PATTERNS = [
+    // Claude Code injects this caveat block before every bash invocation result.
+    /<local-command-caveat>/i,
+    // Post-compact dumps embed analysis/summary XML blocks pasted from prior context.
+    /<analysis>[\s\S]{200,}<\/analysis>/i,
+    /<summary>[\s\S]{200,}<\/summary>/i,
+    // System reminders the harness injects every few turns — never carry signal.
+    /<system-reminder>/i,
+    // Opencode tool-event aggregate dumps look like repeated `akm_search unknown` blocks.
+    /^(##\s+\d+.*akm_search unknown\s*\n){3,}/im,
+];
+/**
+ * Apply the drop+truncate rules to a single event. Returns `undefined` when
+ * the event should be dropped, or the (possibly truncated) event when kept.
+ * The third return tracks why dropped, for stats.
+ */
+function classifyEvent(event, akmReadOnlyOps, maxLen) {
+    const text = event.text ?? "";
+    if (text.trim().length < 10)
+        return { keep: false, reason: "too-short" };
+    // Rule 1: read-only akm meta-ops. The flattened tool_use shape from the
+    // claude-code provider looks like: `[tool:Bash] akm show knowledge:foo`.
+    // Match the verb directly after `akm ` (with or without the `[tool:...]`
+    // prefix, since some platforms surface the command differently).
+    const akmCallMatch = text.match(/\bakm\s+(\w[\w-]*)\b/);
+    if (akmCallMatch) {
+        const op = (akmCallMatch[1] ?? "").toLowerCase();
+        if (akmReadOnlyOps.has(op)) {
+            return { keep: false, reason: `akm-readonly-${op}` };
+        }
+    }
+    // Rule 2-5: noise patterns
+    for (const pattern of NOISE_PATTERNS) {
+        if (pattern.test(text)) {
+            return { keep: false, reason: `noise-pattern-${pattern.source.slice(0, 24)}` };
+        }
+    }
+    // Rule 6: bare system events that are pure boilerplate (no engineering content).
+    // Heuristic: role=system AND short, OR role=system AND just contains `caveat`/`reminder` markers.
+    if (event.role === "system" && (text.length < 200 || /caveat|reminder/i.test(text))) {
+        return { keep: false, reason: "system-boilerplate" };
+    }
+    // Truncate long events to head + tail summary.
+    if (text.length > maxLen) {
+        const headLen = Math.floor(maxLen * 0.7);
+        const tailLen = maxLen - headLen - 32; // 32 chars for the marker
+        const truncated = text.slice(0, headLen) +
+            `\n... [truncated ${text.length - headLen - tailLen} chars] ...\n` +
+            text.slice(text.length - tailLen);
+        return { keep: true, event: { ...event, text: truncated }, truncated: true };
+    }
+    return { keep: true, event, truncated: false };
+}
+export function preFilterSession(data, options = {}) {
+    const akmReadOnlyOps = options.akmReadOnlyOps ?? DEFAULT_AKM_READONLY_OPS;
+    const maxLen = options.maxEventTextLength ?? DEFAULT_MAX_EVENT_LENGTH;
+    const maxTotalChars = options.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
+    const droppedByRule = {};
+    const kept = [];
+    let truncatedCount = 0;
+    const candidates = [];
+    for (const event of data.events) {
+        const verdict = classifyEvent(event, akmReadOnlyOps, maxLen);
+        if (!verdict.keep) {
+            droppedByRule[verdict.reason] = (droppedByRule[verdict.reason] ?? 0) + 1;
+            continue;
+        }
+        candidates.push({
+            event: verdict.event,
+            truncated: verdict.truncated,
+            chars: verdict.event.text.length,
+        });
+    }
+    // Second pass: total-budget cap. Walk from the END (most recent first) and
+    // accept events until the budget is exhausted. The remaining (head) events
+    // are dropped — insight typically emerges later in a session, so this
+    // recency-bias is the cheapest sampling heuristic that respects context
+    // limits. Maintains original timestamp order in the output.
+    let totalChars = 0;
+    let budgetDroppedCount = 0;
+    const keptIdxFromTail = [];
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const c = candidates[i];
+        if (!c)
+            continue;
+        if (totalChars + c.chars > maxTotalChars && keptIdxFromTail.length > 0) {
+            budgetDroppedCount += 1;
+            continue;
+        }
+        keptIdxFromTail.push(i);
+        totalChars += c.chars;
+    }
+    keptIdxFromTail.reverse(); // restore timestamp order
+    for (const idx of keptIdxFromTail) {
+        const c = candidates[idx];
+        if (!c)
+            continue;
+        kept.push(c.event);
+        if (c.truncated)
+            truncatedCount += 1;
+    }
+    return {
+        events: kept,
+        stats: {
+            inputCount: data.events.length,
+            outputCount: kept.length,
+            droppedByRule,
+            truncatedCount,
+            totalChars,
+            budgetDroppedCount,
+        },
+    };
+}

package/dist/integrations/session-logs/providers/claude-code.js

@@ -0,0 +1,282 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { extractInlineRefMentions } from "../inline-refs";
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+/**
+ * Parse a single Claude Code JSONL event into a normalized {@link SessionEvent}.
+ * Returns `undefined` for events that don't carry textual content (file
+ * snapshots, attachments, queue metadata). Tool calls are flattened from the
+ * `message.content` array into a stable text representation so downstream
+ * consumers don't need to know the Anthropic-tool-call shape.
+ */
+function parseClaudeEvent(entry, sessionId, filePath, fallbackTsMs) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const e = entry;
+    const tsRaw = e.timestamp;
+    const ts = typeof tsRaw === "number" ? tsRaw : typeof tsRaw === "string" ? Date.parse(tsRaw) || fallbackTsMs : fallbackTsMs;
+    const message = e.message ?? undefined;
+    const role = typeof message?.role === "string"
+        ? message.role
+        : (e.type ?? "unknown");
+    const content = message?.content;
+    let text = "";
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if (Array.isArray(content)) {
+        // Assistant messages: array of content blocks. Flatten text/thinking/tool_use
+        // into a stable representation. tool_use entries become `[tool: <name>] <input>`
+        // so the inline-ref scanner can detect `akm remember` / `akm feedback` calls.
+        const parts = [];
+        for (const block of content) {
+            if (!block || typeof block !== "object")
+                continue;
+            const b = block;
+            if (b.type === "text" && typeof b.text === "string")
+                parts.push(b.text);
+            else if (b.type === "thinking" && typeof b.thinking === "string")
+                parts.push(b.thinking);
+            else if (b.type === "tool_use") {
+                const toolName = typeof b.name === "string" ? b.name : "tool";
+                // For shell-like tools, surface the `command` field directly so
+                // inline-ref detection can match `akm remember "..."` without
+                // JSON-quote escaping mangling the regex.
+                const inputObj = b.input;
+                let inputText = "";
+                if (inputObj && typeof inputObj === "object") {
+                    const cmd = inputObj.command;
+                    inputText = typeof cmd === "string" ? cmd : JSON.stringify(inputObj);
+                }
+                else if (typeof inputObj === "string") {
+                    inputText = inputObj;
+                }
+                parts.push(`[tool:${toolName}] ${inputText}`);
+            }
+            else if (b.type === "tool_result") {
+                const out = typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? "");
+                parts.push(`[tool_result] ${out}`);
+            }
+        }
+        text = parts.join("\n");
+    }
+    if (!text || text.length < 1)
+        return undefined;
+    return {
+        harness: "claude-code",
+        text,
+        ts,
+        sessionId,
+        role,
+        filePath,
+    };
+}
+export class ClaudeCodeProvider {
+    name = "claude-code";
+    isAvailable() {
+        return fs.existsSync(CLAUDE_PROJECTS_DIR);
+    }
+    *readEvents(input) {
+        try {
+            for (const jsonlPath of this.#walkJsonl(CLAUDE_PROJECTS_DIR)) {
+                const stat = fs.statSync(jsonlPath);
+                if (stat.mtimeMs < input.sinceMs)
+                    continue;
+                const lines = fs.readFileSync(jsonlPath, "utf8").split("\n").filter(Boolean);
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        const text = entry?.message?.content ?? entry?.content ?? "";
+                        if (typeof text !== "string" || text.length < 10)
+                            continue;
+                        yield {
+                            harness: this.name,
+                            text,
+                            ts: typeof entry?.timestamp === "number" ? entry.timestamp : stat.mtimeMs,
+                            sessionId: typeof entry?.session_id === "string" ? entry.session_id : undefined,
+                            role: typeof entry?.role === "string" ? entry.role : "unknown",
+                            filePath: jsonlPath,
+                        };
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                }
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    listSessions(input = {}) {
+        const root = input.location ?? CLAUDE_PROJECTS_DIR;
+        const sinceMs = input.sinceMs ?? 0;
+        const summaries = [];
+        try {
+            for (const jsonlPath of this.#walkJsonl(root)) {
+                let stat;
+                try {
+                    stat = fs.statSync(jsonlPath);
+                }
+                catch {
+                    continue;
+                }
+                if (stat.mtimeMs < sinceMs)
+                    continue;
+                const sessionId = path.basename(jsonlPath, ".jsonl");
+                const projectHint = path.basename(path.dirname(jsonlPath));
+                // Peek first + last non-empty line to derive start/end timestamps and
+                // title. Reading the whole file would be wasteful for listing.
+                const peek = this.#peekJsonl(jsonlPath);
+                summaries.push({
+                    harness: this.name,
+                    sessionId,
+                    filePath: jsonlPath,
+                    startedAt: peek.firstTsMs ?? stat.ctimeMs,
+                    endedAt: peek.lastTsMs ?? stat.mtimeMs,
+                    projectHint,
+                    ...(peek.title ? { title: peek.title } : {}),
+                });
+            }
+        }
+        catch {
+            // Root missing or unreadable — return what we have.
+        }
+        return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
+    }
+    readSession(ref) {
+        const stat = fs.statSync(ref.filePath);
+        const lines = fs.readFileSync(ref.filePath, "utf8").split("\n").filter(Boolean);
+        const events = [];
+        const inlineRefs = [];
+        let title;
+        let firstTsMs;
+        let lastTsMs;
+        const projectHint = path.basename(path.dirname(ref.filePath));
+        for (const line of lines) {
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry)
+                continue;
+            if (entry.type === "custom-title" && typeof entry.customTitle === "string") {
+                title = entry.customTitle;
+                continue;
+            }
+            const parsed = parseClaudeEvent(entry, ref.sessionId, ref.filePath, stat.mtimeMs);
+            if (!parsed)
+                continue;
+            events.push(parsed);
+            if (firstTsMs === undefined || (parsed.ts ?? 0) < firstTsMs)
+                firstTsMs = parsed.ts;
+            if (lastTsMs === undefined || (parsed.ts ?? 0) > lastTsMs)
+                lastTsMs = parsed.ts;
+            // Extract inline akm-remember/feedback invocations from this event's text.
+            inlineRefs.push(...extractInlineRefMentions(parsed.text, parsed.ts));
+        }
+        return {
+            ref: {
+                harness: this.name,
+                sessionId: ref.sessionId,
+                filePath: ref.filePath,
+                startedAt: firstTsMs ?? stat.ctimeMs,
+                endedAt: lastTsMs ?? stat.mtimeMs,
+                projectHint,
+                ...(title ? { title } : {}),
+            },
+            events,
+            inlineRefs,
+        };
+    }
+    /**
+     * Cheap metadata peek — reads the first ~4KB to grab the `custom-title`
+     * event (always early in the file) and the first event timestamp, then
+     * reads the tail (~4KB) for the last timestamp. Avoids slurping multi-MB
+     * session files during `listSessions`.
+     */
+    #peekJsonl(filePath) {
+        const result = {};
+        try {
+            const fd = fs.openSync(filePath, "r");
+            try {
+                const stat = fs.fstatSync(fd);
+                const headSize = Math.min(stat.size, 4096);
+                const head = Buffer.alloc(headSize);
+                fs.readSync(fd, head, 0, headSize, 0);
+                const headLines = head.toString("utf8").split("\n").filter(Boolean);
+                // Walk head: track title, first timestamp, and (if file fits in head)
+                // also the last timestamp seen — saves a tail read for small files.
+                for (const line of headLines) {
+                    try {
+                        const e = JSON.parse(line);
+                        if (e.type === "custom-title" && typeof e.customTitle === "string") {
+                            result.title = e.customTitle;
+                        }
+                        if (typeof e.timestamp === "string") {
+                            const t = Date.parse(e.timestamp);
+                            if (!Number.isNaN(t)) {
+                                if (result.firstTsMs === undefined)
+                                    result.firstTsMs = t;
+                                result.lastTsMs = t;
+                            }
+                        }
+                    }
+                    catch {
+                        // partial line at buffer boundary — fine, skip
+                    }
+                }
+                // Large-file tail read overrides lastTsMs with a value closer to EOF.
+                if (stat.size > 4096) {
+                    const tailSize = Math.min(stat.size, 4096);
+                    const tail = Buffer.alloc(tailSize);
+                    fs.readSync(fd, tail, 0, tailSize, stat.size - tailSize);
+                    const tailLines = tail.toString("utf8").split("\n").filter(Boolean);
+                    for (let i = tailLines.length - 1; i >= 0; i--) {
+                        try {
+                            const e = JSON.parse(tailLines[i] ?? "");
+                            if (typeof e.timestamp === "string") {
+                                const t = Date.parse(e.timestamp);
+                                if (!Number.isNaN(t)) {
+                                    result.lastTsMs = t;
+                                    break;
+                                }
+                            }
+                        }
+                        catch {
+                            // skip partial lines from buffer boundary
+                        }
+                    }
+                }
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            // unreadable / vanished file — caller falls back to stat times
+        }
+        return result;
+    }
+    *#walkJsonl(dir) {
+        try {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    yield* this.#walkJsonl(full);
+                else if (entry.name.endsWith(".jsonl"))
+                    yield full;
+            }
+        }
+        catch {
+            // permission errors etc.
+        }
+    }
+}

package/dist/integrations/session-logs/providers/opencode.js

@@ -0,0 +1,258 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { extractInlineRefMentions } from "../inline-refs";
+function getOpenCodeBaseDir() {
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "opencode");
+    }
+    return path.join(os.homedir(), ".local", "share", "opencode");
+}
+/**
+ * Opencode storage layout (observed 2026-05):
+ *   <base>/storage/session/<projectId>/<sessionId>.json    — metadata
+ *   <base>/storage/message/<sessionId>/<messageId>.json    — one per message
+ *
+ * Older builds wrote logs directly into `<base>/log/` and `<base>/*.log`;
+ * those are still scanned by {@link OpenCodeProvider.readEvents} for
+ * backward compatibility with the existing failure-pattern aggregator.
+ */
+export class OpenCodeProvider {
+    name = "opencode";
+    #baseDir = getOpenCodeBaseDir();
+    isAvailable() {
+        return fs.existsSync(this.#baseDir);
+    }
+    *readEvents(input) {
+        // Legacy behavior: stream raw log lines from the top-level dir and `log/`
+        // subdirectory. Kept to keep `getExecutionLogCandidates` working without
+        // a coordinated change to its caller. New code should use
+        // {@link listSessions} + {@link readSession} instead.
+        const candidates = [this.#baseDir, path.join(this.#baseDir, "log")];
+        for (const dir of candidates) {
+            if (!fs.existsSync(dir))
+                continue;
+            try {
+                for (const file of fs.readdirSync(dir)) {
+                    const full = path.join(dir, file);
+                    let stat;
+                    try {
+                        stat = fs.statSync(full);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!stat.isFile())
+                        continue;
+                    if (stat.mtimeMs < input.sinceMs)
+                        continue;
+                    if (!file.endsWith(".json") && !file.endsWith(".jsonl") && !file.endsWith(".log"))
+                        continue;
+                    const content = fs.readFileSync(full, "utf8");
+                    const lines = content.includes("\n") ? content.split("\n") : [content];
+                    for (const line of lines) {
+                        try {
+                            const entry = JSON.parse(line);
+                            const text = entry?.content ?? entry?.message ?? entry?.text ?? "";
+                            if (typeof text !== "string" || text.length < 10)
+                                continue;
+                            yield {
+                                harness: this.name,
+                                text,
+                                ts: typeof entry?.timestamp === "number" ? entry.timestamp : stat.mtimeMs,
+                                sessionId: typeof entry?.sessionId === "string" ? entry.sessionId : undefined,
+                                role: typeof entry?.role === "string" ? entry.role : "unknown",
+                                filePath: full,
+                            };
+                        }
+                        catch {
+                            // skip malformed
+                        }
+                    }
+                }
+            }
+            catch {
+                // unreadable dir — skip
+            }
+        }
+    }
+    listSessions(input = {}) {
+        const base = input.location ?? this.#baseDir;
+        const sinceMs = input.sinceMs ?? 0;
+        const sessionRoot = path.join(base, "storage", "session");
+        if (!fs.existsSync(sessionRoot))
+            return [];
+        const summaries = [];
+        try {
+            for (const projectId of fs.readdirSync(sessionRoot)) {
+                const projectDir = path.join(sessionRoot, projectId);
+                let pstat;
+                try {
+                    pstat = fs.statSync(projectDir);
+                }
+                catch {
+                    continue;
+                }
+                if (!pstat.isDirectory())
+                    continue;
+                for (const file of fs.readdirSync(projectDir)) {
+                    if (!file.endsWith(".json"))
+                        continue;
+                    const filePath = path.join(projectDir, file);
+                    let stat;
+                    try {
+                        stat = fs.statSync(filePath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (stat.mtimeMs < sinceMs)
+                        continue;
+                    let meta;
+                    try {
+                        meta = JSON.parse(fs.readFileSync(filePath, "utf8"));
+                    }
+                    catch {
+                        continue;
+                    }
+                    const sessionId = typeof meta?.id === "string" ? meta.id : path.basename(file, ".json");
+                    const time = meta?.time ?? undefined;
+                    const startedAt = typeof time?.created === "number" ? time.created : stat.ctimeMs;
+                    const endedAt = typeof time?.updated === "number" ? time.updated : stat.mtimeMs;
+                    const title = typeof meta?.title === "string" ? meta.title : undefined;
+                    const projectHint = typeof meta?.directory === "string" ? meta.directory : projectId;
+                    summaries.push({
+                        harness: this.name,
+                        sessionId,
+                        filePath,
+                        startedAt,
+                        endedAt,
+                        projectHint,
+                        ...(title ? { title } : {}),
+                    });
+                }
+            }
+        }
+        catch {
+            // unreadable session root — return what we have
+        }
+        return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
+    }
+    readSession(ref) {
+        let meta = {};
+        try {
+            meta = JSON.parse(fs.readFileSync(ref.filePath, "utf8"));
+        }
+        catch {
+            // metadata missing — proceed with empty defaults
+        }
+        const time = meta.time ?? undefined;
+        const startedAt = typeof time?.created === "number" ? time.created : undefined;
+        const endedAt = typeof time?.updated === "number" ? time.updated : undefined;
+        const title = typeof meta.title === "string" ? meta.title : undefined;
+        const projectHint = typeof meta.directory === "string" ? meta.directory : undefined;
+        const events = [];
+        const inlineRefs = [];
+        // Resolve message directory: <baseDir>/storage/message/<sessionId>/
+        const inferredBase = this.#inferBaseFromSessionPath(ref.filePath) ?? this.#baseDir;
+        const msgDir = path.join(inferredBase, "storage", "message", ref.sessionId);
+        if (fs.existsSync(msgDir)) {
+            try {
+                const files = fs.readdirSync(msgDir).filter((f) => f.endsWith(".json"));
+                for (const file of files) {
+                    const full = path.join(msgDir, file);
+                    let msg;
+                    try {
+                        msg = JSON.parse(fs.readFileSync(full, "utf8"));
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!msg)
+                        continue;
+                    const evt = this.#messageToEvent(msg, ref.sessionId, full);
+                    if (evt) {
+                        events.push(evt);
+                        inlineRefs.push(...extractInlineRefMentions(evt.text, evt.ts));
+                    }
+                }
+            }
+            catch {
+                // unreadable msg dir — skip
+            }
+        }
+        events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+        return {
+            ref: {
+                harness: this.name,
+                sessionId: ref.sessionId,
+                filePath: ref.filePath,
+                ...(startedAt !== undefined ? { startedAt } : {}),
+                ...(endedAt !== undefined ? { endedAt } : {}),
+                ...(projectHint ? { projectHint } : {}),
+                ...(title ? { title } : {}),
+            },
+            events,
+            inlineRefs,
+        };
+    }
+    /**
+     * Derive opencode base dir from a session metadata file path so a caller
+     * passing a custom `--location` can still find the message dir.
+     * Layout: `<base>/storage/session/<projectId>/<id>.json` → base.
+     */
+    #inferBaseFromSessionPath(filePath) {
+        // Walk up: <id>.json → <projectId> → session → storage → <base>
+        const dir = path.dirname(filePath);
+        const parts = dir.split(path.sep);
+        if (parts.length < 3)
+            return undefined;
+        const last = parts[parts.length - 1];
+        const sndLast = parts[parts.length - 2];
+        const thirdLast = parts[parts.length - 3];
+        if (sndLast !== "session" || thirdLast !== "storage" || !last)
+            return undefined;
+        return parts.slice(0, parts.length - 3).join(path.sep);
+    }
+    #messageToEvent(msg, sessionId, filePath) {
+        const time = msg.time ?? undefined;
+        const ts = typeof time?.created === "number" ? time.created : typeof msg.timestamp === "number" ? msg.timestamp : 0;
+        const role = typeof msg.role === "string" ? msg.role : "unknown";
+        // Opencode message bodies live in summary.title / summary.diffs[].before/after /
+        // parts (referenced from storage/part/<msg-id>/). For listing+extraction
+        // purposes the summary block is sufficient — it's what the platform itself
+        // surfaces as the message preview.
+        const summary = msg.summary;
+        const parts = [];
+        if (typeof summary?.title === "string")
+            parts.push(summary.title);
+        if (Array.isArray(summary?.parts)) {
+            for (const p of summary.parts) {
+                if (typeof p === "string")
+                    parts.push(p);
+                else if (p && typeof p === "object") {
+                    const text = p.text;
+                    if (typeof text === "string")
+                        parts.push(text);
+                }
+            }
+        }
+        // content field for some opencode versions
+        if (typeof msg.content === "string")
+            parts.push(msg.content);
+        const text = parts.join("\n").trim();
+        if (text.length < 1)
+            return undefined;
+        return {
+            harness: this.name,
+            text,
+            ts: ts || undefined,
+            sessionId,
+            role,
+            filePath,
+        };
+    }
+}