@mindfoldhq/trellis 0.6.0-beta.14 → 0.6.0-beta.16

package/dist/commands/mem.js

@@ -1,5 +1,9 @@
 /**
- * mem.ts — search sessions across Claude Code / Codex / OpenCode.
+ * mem.ts — CLI wrapper over `@mindfoldhq/trellis-core/mem`.
+ *
+ * The reusable retrieval / context-extraction logic lives in core; this file
+ * owns only CLI concerns: argument parsing, terminal rendering, the OpenCode
+ * "reader unavailable" notice, and process exit behavior.
  *
  * Commands:
  *   list                          list sessions (default if no command)
@@ -10,126 +14,9 @@
  *
  * Run `trellis mem help` for the full flag reference.
  */
-import * as fs from "node:fs";
-import * as path from "node:path";
 import * as os from "node:os";
-import { z } from "zod";
-// ---------- schemas: domain types ----------
-const PlatformSchema = z.enum(["claude", "codex", "opencode"]);
-const SessionInfoSchema = z.object({
-    platform: PlatformSchema,
-    id: z.string(),
-    title: z.string().optional(),
-    cwd: z.string().optional(),
-    created: z.string().optional(),
-    updated: z.string().optional(),
-    filePath: z.string(),
-    parent_id: z.string().optional(), // OpenCode only: parent session id (sub-agent chain)
-});
-const DialogueRoleSchema = z.enum(["user", "assistant"]);
-const SearchExcerptSchema = z.object({
-    role: DialogueRoleSchema,
-    snippet: z.string(),
-});
-const SearchHitSchema = z.object({
-    count: z.number(), // total token occurrences across all matching turns
-    user_count: z.number(), // breakdown: user-turn occurrences
-    asst_count: z.number(), // breakdown: assistant-turn occurrences
-    total_turns: z.number(), // size of cleaned dialogue (denominator for density)
-    excerpts: z.array(SearchExcerptSchema),
-});
-/** Weighted-density relevance score:
- *   (3 * user_hits + asst_hits) / total_turns
- * Higher = the session is more topically concentrated on the query AND the
- * user themselves brought it up (user hits weighted ×3 because the user's own
- * words anchor "what they actually cared about", while assistant elaboration
- * is downstream noise). */
-export function relevanceScore(h) {
-    if (h.total_turns === 0)
-        return 0;
-    return (3 * h.user_count + h.asst_count) / h.total_turns;
-}
-const FilterSchema = z.object({
-    platform: z.union([PlatformSchema, z.literal("all")]),
-    since: z.date().optional(),
-    until: z.date().optional(),
-    cwd: z.string().optional(),
-    limit: z.number(),
-});
-const ArgvSchema = z.object({
-    cmd: z.string(),
-    positional: z.array(z.string()),
-    flags: z.record(z.string(), z.union([z.string(), z.boolean()])),
-});
-// ---------- schemas: external file formats ----------
-// Claude Code JSONL events. We only declare the fields we read; everything
-// else passes through. Content of an assistant `message` is an array of
-// blocks (text / thinking / tool_use); content of a user `message` is a
-// string for real human input or an array of tool_result blocks (skipped).
-const ClaudeBlockSchema = z
-    .object({
-    type: z.string().optional(),
-    text: z.string().optional(),
-})
-    .loose();
-const ClaudeMessageSchema = z
-    .object({
-    role: z.string().optional(),
-    content: z.union([z.string(), z.array(ClaudeBlockSchema)]).optional(),
-})
-    .loose();
-const ClaudeEventSchema = z
-    .object({
-    type: z.string().optional(),
-    cwd: z.string().optional(),
-    timestamp: z.string().optional(),
-    message: ClaudeMessageSchema.optional(),
-    isCompactSummary: z.boolean().optional(),
-})
-    .loose();
-const ClaudeIndexEntrySchema = z
-    .object({
-    id: z.string(),
-    cwd: z.string().optional(),
-    created: z.string().optional(),
-    title: z.string().optional(),
-})
-    .loose();
-const ClaudeIndexSchema = z
-    .object({ entries: z.array(ClaudeIndexEntrySchema).optional() })
-    .loose();
-// Codex rollout JSONL events.
-const CodexContentPartSchema = z
-    .object({
-    type: z.string().optional(),
-    text: z.string().optional(),
-})
-    .loose();
-const CodexCompactedItemSchema = z
-    .object({
-    type: z.string().optional(),
-    role: z.string().optional(),
-    content: z.array(CodexContentPartSchema).optional(),
-})
-    .loose();
-const CodexPayloadSchema = z
-    .object({
-    type: z.string().optional(),
-    role: z.string().optional(),
-    cwd: z.string().optional(),
-    id: z.string().optional(),
-    content: z.array(CodexContentPartSchema).optional(),
-    replacement_history: z.array(CodexCompactedItemSchema).optional(),
-})
-    .loose();
-const CodexEventSchema = z
-    .object({
-    timestamp: z.string().optional(),
-    type: z.string().optional(),
-    payload: CodexPayloadSchema.optional(),
-})
-    .loose();
-// ---------- argv ----------
+import * as path from "node:path";
+import { extractMemDialogue, listMemProjects, listMemSessions, MemSessionNotFoundError, readMemContext, searchMemSessions, } from "@mindfoldhq/trellis-core/mem";
 export function parseArgv(argv) {
     const cmd = argv[0] ?? "list";
     const positional = [];
@@ -153,1121 +40,57 @@ export function parseArgv(argv) {
             positional.push(a);
         }
     }
-    return ArgvSchema.parse({ cmd, positional, flags });
+    return { cmd, positional, flags };
 }
+const VALID_PLATFORMS = [
+    "claude",
+    "codex",
+    "opencode",
+    "all",
+];
+/** Translate parsed CLI flags into a core `MemFilter`. Validation failures
+ * exit the process — core never sees raw CLI flags. */
 export function buildFilter(flags) {
     const platformRaw = typeof flags.platform === "string" ? flags.platform : "all";
-    const platformParsed = z
-        .union([PlatformSchema, z.literal("all")])
-        .safeParse(platformRaw);
-    if (!platformParsed.success)
+    if (!VALID_PLATFORMS.includes(platformRaw))
         die(`unknown platform: ${platformRaw}`);
+    const platform = platformRaw;
     const sinceRaw = flags.since;
     const since = typeof sinceRaw === "string" ? new Date(sinceRaw) : undefined;
     if (since && Number.isNaN(+since))
-        die(`bad --since: ${sinceRaw}`);
+        die(`bad --since: ${String(sinceRaw)}`);
     const untilRaw = flags.until;
     const until = typeof untilRaw === "string"
         ? new Date(`${untilRaw}T23:59:59.999Z`)
         : undefined;
     if (until && Number.isNaN(+until))
-        die(`bad --until: ${untilRaw}`);
+        die(`bad --until: ${String(untilRaw)}`);
     const cwd = flags.global
         ? undefined
         : path.resolve(typeof flags.cwd === "string" ? flags.cwd : process.cwd());
-    const limit = typeof flags.limit === "string" ? Number(flags.limit) : 50;
-    return FilterSchema.parse({
-        platform: platformParsed.data,
-        since,
-        until,
-        cwd,
-        limit,
-    });
+    const limit = parseOptionalNumberFlag(flags.limit, "--limit", 50);
+    return { platform, since, until, cwd, limit };
+}
+function parseOptionalNumberFlag(raw, name, fallback) {
+    if (raw === undefined || raw === false)
+        return fallback;
+    if (typeof raw !== "string")
+        die(`${name} requires a number`);
+    const value = Number(raw);
+    if (!Number.isFinite(value))
+        die(`bad ${name}: ${raw}`);
+    return value;
 }
 function die(msg) {
     console.error(`error: ${msg}`);
     process.exit(2);
 }
-// ---------- common helpers ----------
-const HOME = os.homedir();
-export function inRange(iso, f) {
-    if (!iso)
-        return true;
-    const t = new Date(iso);
-    if (Number.isNaN(+t))
-        return true;
-    if (f.since && t < f.since)
-        return false;
-    if (f.until && t > f.until)
-        return false;
-    return true;
-}
-/**
- * Interval-overlap version of `inRange` for sessions with both start and end
- * timestamps. A session is kept iff its lifetime `[start, end]` overlaps the
- * query window `[f.since, f.until]`.
- *
- * Why this exists: long / cross-day sessions (created on day N, still updated
- * on day N+M) were being dropped by `inRange(created, f)` when `--since` fell
- * after `created`. Switching to interval overlap keeps sessions that were
- * active inside the window even when they started before it.
- *
- * Degenerate inputs:
- *   - both undefined → pass through (no timestamp = don't filter)
- *   - one undefined → fall back to single-point semantics on the other end
- *   - unparseable iso → defer to the parsable end (or pass through if both bad)
- */
-export function inRangeOverlap(start, end, f) {
-    const s = start ?? end;
-    const e = end ?? start;
-    if (!s && !e)
-        return true;
-    if (f.since && e) {
-        const eT = new Date(e);
-        if (!Number.isNaN(+eT) && eT < f.since)
-            return false;
-    }
-    if (f.until && s) {
-        const sT = new Date(s);
-        if (!Number.isNaN(+sT) && sT > f.until)
-            return false;
-    }
-    return true;
-}
-export function sameProject(sessionCwd, target) {
-    if (!target)
-        return true;
-    if (!sessionCwd)
-        return false;
-    const a = path.resolve(sessionCwd);
-    const b = path.resolve(target);
-    return a === b || a.startsWith(b + path.sep);
-}
-/** Walk JSONL line-by-line, calling `onLine` with each parsed object that
- * matches the supplied schema. Bad JSON or schema-mismatched lines are skipped.
- * Returning the literal "stop" from `onLine` halts iteration.
- *
- * Chunked sync streaming: 256 KB read window, leftover preserved across
- * chunks for split-line reassembly. Two practical wins over the original
- * `fs.readFileSync` + `data.split("\n")`:
- *
- * 1. **Bounded peek** — `readJsonlFirst` / `findInJsonl(maxLines<100)` only
- *    pull the first chunk (256 KB) and stop, instead of loading multi-MB
- *    rollout files in full just to read the head. 30-100× speedup on the
- *    listing fan-out path.
- * 2. **Heap floor** — full-scan paths (`extract` / `search`) keep ~256 KB +
- *    one leftover line resident instead of 36 MB sessions held as one big
- *    UTF-8 string. Roughly 30× peak-heap drop on long sessions.
- *
- * Byte-prefix fast-reject: a JSONL event line virtually always begins with
- * `{` (object). Lines starting with any other byte are blanks, log
- * preambles, or trailing whitespace — `JSON.parse` would throw and
- * `safeParse` would fail. Checking the first byte before allocating the
- * parse exception path saves measurable wall time on heavy sessions. */
-function readJsonl(file, schema, onLine) {
-    let fd;
-    try {
-        fd = fs.openSync(file, "r");
-    }
-    catch {
-        return;
-    }
-    const CHUNK = 256 * 1024;
-    const OPEN_BRACE = 0x7b; // '{'
-    const buf = Buffer.alloc(CHUNK);
-    let leftover = "";
-    try {
-        let stop = false;
-        while (!stop) {
-            const n = fs.readSync(fd, buf, 0, CHUNK, null);
-            if (n === 0)
-                break;
-            const chunk = leftover + buf.toString("utf8", 0, n);
-            let from = 0;
-            while (true) {
-                const nl = chunk.indexOf("\n", from);
-                if (nl === -1) {
-                    leftover = chunk.slice(from);
-                    break;
-                }
-                const line = chunk.slice(from, nl);
-                from = nl + 1;
-                if (!line)
-                    continue;
-                // Byte-prefix fast-reject before JSON.parse / zod.
-                if (line.charCodeAt(0) !== OPEN_BRACE)
-                    continue;
-                let raw;
-                try {
-                    raw = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                const parsed = schema.safeParse(raw);
-                if (!parsed.success)
-                    continue;
-                if (onLine(parsed.data) === "stop") {
-                    stop = true;
-                    break;
-                }
-            }
-        }
-        if (!stop && leftover) {
-            // File ended without trailing newline — process the last partial line.
-            const line = leftover;
-            if (line?.charCodeAt(0) === OPEN_BRACE) {
-                try {
-                    const raw = JSON.parse(line);
-                    const parsed = schema.safeParse(raw);
-                    if (parsed.success)
-                        onLine(parsed.data);
-                }
-                catch {
-                    /* skip */
-                }
-            }
-        }
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function readJsonlFirst(file, schema) {
-    let result;
-    readJsonl(file, schema, (obj) => {
-        result = obj;
-        return "stop";
-    });
-    return result;
-}
-function findInJsonl(file, schema, predicate, maxLines = 200) {
-    let count = 0;
-    let hit;
-    readJsonl(file, schema, (obj) => {
-        count++;
-        if (predicate(obj)) {
-            hit = obj;
-            return "stop";
-        }
-        if (count >= maxLines)
-            return "stop";
-    });
-    return hit;
-}
-function readJsonFile(file, schema) {
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(file, "utf8"));
-    }
-    catch {
-        return undefined;
-    }
-    const parsed = schema.safeParse(raw);
-    return parsed.success ? parsed.data : undefined;
-}
-// ---------- dialogue cleaning ----------
-const INJECTION_TAGS = [
-    "system-reminder",
-    "task-status",
-    "ready",
-    "current-state",
-    "workflow",
-    "workflow-state",
-    "guidelines",
-    "instructions",
-    "command-name",
-    "command-message",
-    "command-args",
-    "local-command-stdout",
-    "local-command-stderr",
-    "permissions instructions",
-    "collaboration_mode",
-    "environment_context",
-    "auto_compact_summary",
-    "user_instructions",
-];
-/** True if this turn is a platform bootstrap injection (AGENTS.md, pure
- * INSTRUCTIONS preamble, etc.) and should be dropped wholesale rather than
- * partially cleaned. Detected after stripInjectionTags, so we look at what's
- * left after tag-stripping. */
-export function isBootstrapTurn(cleaned, originalLength) {
-    if (cleaned.startsWith("# AGENTS.md instructions for"))
-        return true;
-    // A turn that's mostly an INSTRUCTIONS block (Codex injects this as user role).
-    if (originalLength > 4000 && /^<INSTRUCTIONS>/i.test(cleaned))
-        return true;
-    return false;
-}
-export function stripInjectionTags(text) {
-    let out = text;
-    for (const tag of INJECTION_TAGS) {
-        const escaped = tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        // Case-insensitive: Codex/Trellis injection tags appear as both <INSTRUCTIONS>
-        // and <instructions> across platforms.
-        out = out.replace(new RegExp(`<${escaped}[^>]*>[\\s\\S]*?</${escaped}>`, "gi"), "");
-    }
-    out = out.replace(/^# AGENTS\.md instructions for[\s\S]*?(?=\n\n[A-Z一-龥]|$)/m, "");
-    return out.replace(/\n{3,}/g, "\n\n").trim();
-}
-/** Find the paragraph-aligned chunk surrounding a hit position. A "chunk" is
- * the contiguous text bounded by the nearest blank-line breaks (`\n\n`) on
- * either side. If the natural paragraph exceeds `maxChars`, fall back to a
- * centered char window — and report the truncation so callers can mark it. */
-export function chunkAround(text, hitIdx, maxChars) {
-    const startPara = text.lastIndexOf("\n\n", hitIdx);
-    let start = startPara === -1 ? 0 : startPara + 2;
-    const endPara = text.indexOf("\n\n", hitIdx);
-    let end = endPara === -1 ? text.length : endPara;
-    let truncated = false;
-    if (end - start > maxChars) {
-        start = Math.max(0, hitIdx - Math.floor(maxChars / 2));
-        end = Math.min(text.length, hitIdx + Math.ceil(maxChars / 2));
-        truncated = true;
-    }
-    return { start, end, truncated };
-}
-/** Multi-token AND grep over cleaned dialogue. Whitespace-split tokens; a
- * turn matches if every token (case-insensitive) appears anywhere in it.
- * `count` is the total occurrence count across all tokens within matching
- * turns. Excerpts are paragraph-aligned chunks (drawer-style): for each
- * matching turn we collect chunks around every hit position, dedupe by
- * chunk start so adjacent hits inside the same paragraph collapse to one
- * chunk. User-role chunks are listed first (the user's own words anchor
- * topic intent more reliably than AI elaboration). */
-export function searchInDialogue(turns, kw, maxExcerpts = 3, chunkChars = 400) {
-    const tokens = kw.toLowerCase().split(/\s+/).filter(Boolean);
-    const empty = SearchHitSchema.parse({
-        count: 0,
-        user_count: 0,
-        asst_count: 0,
-        total_turns: turns.length,
-        excerpts: [],
-    });
-    if (tokens.length === 0)
-        return empty;
-    let userCount = 0;
-    let asstCount = 0;
-    const userExcerpts = [];
-    const asstExcerpts = [];
-    for (const t of turns) {
-        const hay = t.text.toLowerCase();
-        if (!tokens.every((tok) => hay.includes(tok)))
-            continue;
-        // Collect every hit position with the token that produced it (for both
-        // counting and rarity-aware chunk anchor selection).
-        const hitPositions = [];
-        const tokenFreq = new Map();
-        let turnHits = 0;
-        for (const tok of tokens) {
-            let from = 0;
-            let n = 0;
-            while (true) {
-                const idx = hay.indexOf(tok, from);
-                if (idx === -1)
-                    break;
-                n++;
-                turnHits++;
-                hitPositions.push({ idx, tok });
-                from = idx + tok.length;
-            }
-            tokenFreq.set(tok, n);
-        }
-        if (t.role === "user")
-            userCount += turnHits;
-        else
-            asstCount += turnHits;
-        hitPositions.sort((a, b) => a.idx - b.idx);
-        const candidates = [];
-        const seenStarts = new Set();
-        for (const { idx, tok } of hitPositions) {
-            const { start, end, truncated } = chunkAround(t.text, idx, chunkChars);
-            if (seenStarts.has(start))
-                continue;
-            seenStarts.add(start);
-            const slice = hay.slice(start, end);
-            const coverage = tokens.filter((tk) => slice.includes(tk)).length;
-            const rarity = 1 / (tokenFreq.get(tok) ?? 1);
-            candidates.push({ start, end, truncated, coverage, rarity });
-        }
-        candidates.sort((a, b) => {
-            if (b.coverage !== a.coverage)
-                return b.coverage - a.coverage;
-            if (b.rarity !== a.rarity)
-                return b.rarity - a.rarity;
-            return a.start - b.start;
-        });
-        for (const c of candidates) {
-            let snippet = t.text.slice(c.start, c.end).trim();
-            if (c.truncated) {
-                if (c.start > 0)
-                    snippet = "…" + snippet;
-                if (c.end < t.text.length)
-                    snippet += "…";
-            }
-            (t.role === "user" ? userExcerpts : asstExcerpts).push({
-                role: t.role,
-                snippet,
-            });
-        }
-    }
-    const excerpts = [...userExcerpts, ...asstExcerpts].slice(0, maxExcerpts);
-    return SearchHitSchema.parse({
-        count: userCount + asstCount,
-        user_count: userCount,
-        asst_count: asstCount,
-        total_turns: turns.length,
-        excerpts,
-    });
-}
-// ---------- claude adapter ----------
-const CLAUDE_PROJECTS = path.join(HOME, ".claude", "projects");
-function claudeProjectDirFromCwd(cwd) {
-    // Claude sanitizes path: every '/' and '_' becomes '-'.
-    return path.join(CLAUDE_PROJECTS, cwd.replace(/[/_]/g, "-"));
-}
-export function claudeListSessions(f) {
-    if (!fs.existsSync(CLAUDE_PROJECTS))
-        return [];
-    const out = [];
-    const projectDirs = f.cwd
-        ? [claudeProjectDirFromCwd(f.cwd)].filter((d) => fs.existsSync(d))
-        : fs.readdirSync(CLAUDE_PROJECTS).map((d) => path.join(CLAUDE_PROJECTS, d));
-    for (const dir of projectDirs) {
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        const indexFile = path.join(dir, "sessions-index.json");
-        const index = readJsonFile(indexFile, ClaudeIndexSchema);
-        const indexById = new Map();
-        for (const e of index?.entries ?? [])
-            indexById.set(e.id, e);
-        for (const e of entries) {
-            if (!e.isFile() || !e.name.endsWith(".jsonl"))
-                continue;
-            const filePath = path.join(dir, e.name);
-            const id = e.name.replace(/\.jsonl$/, "");
-            const idx = indexById.get(id);
-            let cwd = idx?.cwd;
-            let created = idx?.created;
-            const title = idx?.title;
-            if (!cwd || !created) {
-                const evt = findInJsonl(filePath, ClaudeEventSchema, (o) => typeof o.cwd === "string", 100);
-                cwd = cwd ?? evt?.cwd;
-                created =
-                    created ??
-                        evt?.timestamp ??
-                        readJsonlFirst(filePath, ClaudeEventSchema)?.timestamp;
-            }
-            const stat = fs.statSync(filePath);
-            const updated = stat.mtime.toISOString();
-            // Interval overlap: keep sessions whose lifetime [created, updated]
-            // intersects the query window. Cross-day sessions (created before
-            // --since but still active inside it) must survive — see PRD
-            // 05-08-mem-since-cross-day-filter.
-            if (!inRangeOverlap(created, updated, f))
-                continue;
-            if (f.cwd && cwd && !sameProject(cwd, f.cwd))
-                continue;
-            out.push(SessionInfoSchema.parse({
-                platform: "claude",
-                id,
-                title,
-                cwd,
-                created,
-                updated,
-                filePath,
-            }));
-        }
-    }
-    return out;
-}
-export function claudeExtractDialogue(s) {
-    // Mirrors session-insight/extract-session.py:
-    //   - user: type=="user" + role=="user" + content is string (list = tool_result)
-    //   - assistant: type=="assistant" + role=="assistant", keep only `text` blocks
-    //   - thinking and tool_use blocks dropped entirely
-    //   - injection tags stripped
-    // Compaction: when we hit a `user` event with isCompactSummary=true, drop all
-    // pre-compact turns and replace them with a synthetic [compact summary] turn —
-    // the pre-compact content is now redundant with the summary.
-    let turns = [];
-    readJsonl(s.filePath, ClaudeEventSchema, (obj) => {
-        const t = obj.type;
-        const msg = obj.message;
-        if (!msg)
-            return;
-        const content = msg.content;
-        if (t === "user" && obj.isCompactSummary === true) {
-            let summary = "";
-            if (typeof content === "string") {
-                summary = stripInjectionTags(content);
-            }
-            else if (Array.isArray(content)) {
-                const parts = [];
-                for (const block of content) {
-                    if (block.type === "text" && typeof block.text === "string") {
-                        const cleaned = stripInjectionTags(block.text);
-                        if (cleaned)
-                            parts.push(cleaned);
-                    }
-                }
-                summary = parts.join("\n\n");
-            }
-            turns = summary
-                ? [{ role: "user", text: `[compact summary]\n${summary}` }]
-                : [];
-            return;
-        }
-        if (t === "user" && msg.role === "user") {
-            if (typeof content === "string") {
-                const text = stripInjectionTags(content);
-                if (text && !isBootstrapTurn(text, content.length)) {
-                    turns.push({ role: "user", text });
-                }
-            }
-        }
-        else if (t === "assistant" &&
-            msg.role === "assistant" &&
-            Array.isArray(content)) {
-            const parts = [];
-            for (const block of content) {
-                if (block.type === "text" && typeof block.text === "string") {
-                    const cleaned = stripInjectionTags(block.text);
-                    if (cleaned)
-                        parts.push(cleaned);
-                }
-            }
-            if (parts.length)
-                turns.push({ role: "assistant", text: parts.join("\n\n") });
-        }
-    });
-    return turns;
-}
-export function claudeSearch(s, kw) {
-    return searchInDialogue(claudeExtractDialogue(s), kw);
-}
-/** Find ALL `task.py create|start` invocations in a single Bash command
- * string. A real Bash invocation can contain several (e.g.
- * `SMOKE=$(task.py create …); task.py start "$SMOKE"; …`); the original
- * single-match `parseTaskPyCommand` only saw the first one and silently
- * dropped the rest, breaking pairing in any session that used such patterns.
- *
- * Returned in source order. Each entry's `restRaw` is bounded to the next
- * `task.py` invocation or end-of-line, whichever comes first, so multi-action
- * one-liners are split safely without leaking later args into earlier ones. */
-export function parseTaskPyCommandsAll(cmd) {
-    if (typeof cmd !== "string" || cmd.length === 0)
-        return [];
-    // Find every `task.py (create|start)` occurrence with a left boundary of
-    // start-of-string, whitespace, or path separator (forward or backward
-    // slash). This rejects flag-value embedding like `--slug=task.py-create-foo`.
-    const all = [];
-    const findRe = /(^|[\s/\\])task\.py\s+(create|start)(?:\s+|$)/g;
-    const matches = [];
-    for (const m of cmd.matchAll(findRe)) {
-        const action = m[2];
-        // bodyStart = right after the matched whitespace following the action verb
-        const bodyStart = m.index + m[0].length;
-        matches.push({ action, bodyStart });
-    }
-    for (let i = 0; i < matches.length; i++) {
-        const cur = matches[i];
-        if (!cur)
-            continue;
-        const next = matches[i + 1];
-        // restRaw stops at the next `task.py` invocation (so we don't claim args
-        // from later commands), or end-of-string otherwise. Take only up to the
-        // first newline — multi-line scripts have one task.py per line as the
-        // dominant pattern.
-        const slice = cmd.slice(cur.bodyStart, next?.bodyStart ?? cmd.length);
-        const restRaw = (slice.split("\n")[0] ?? "").trim();
-        // Reject prose-embedded matches. The pattern is: a bare alphanumeric word
-        // followed by another all-letters word with a single space gap — that's
-        // English prose like "task.py start exits with hint", not a real
-        // invocation (CLI args after the action are typically quoted titles,
-        // dashed flags, paths starting with `.` `/` `~` `$`, or followed by shell
-        // metacharacters like `2>&1` / `|` / `;`). A real `create my-task`
-        // (single bare positional with no trailing English) is kept.
-        if (/^[A-Za-z][A-Za-z0-9_-]*\s+[A-Za-z]{2,}\b/.test(restRaw))
-            continue;
-        const parsed = parseRestOfTaskPyCommand(cur.action, restRaw);
-        // Drop entries with no extractable info — likely prose with quote-like
-        // punctuation but no real arg.
-        if (cur.action === "create" &&
-            parsed.action === "create" &&
-            !parsed.slug &&
-            !parsed.titleArg)
-            continue;
-        if (cur.action === "start" && parsed.action === "start" && !parsed.taskDir)
-            continue;
-        all.push(parsed);
-    }
-    return all;
-}
-/** Single-result wrapper for backwards compatibility (returns the first
- * occurrence, or null if none). Existing tests that assume single-match
- * semantics still pass via this helper; new code should call
- * `parseTaskPyCommandsAll`. */
-export function parseTaskPyCommand(cmd) {
-    const all = parseTaskPyCommandsAll(cmd);
-    return all[0] ?? null;
-}
-function parseRestOfTaskPyCommand(action, restRaw) {
-    if (action === "create") {
-        const args = splitShellArgs(restRaw);
-        // First positional arg (skip any flags). For `task.py create`, the title
-        // is typically the first quoted positional; --slug FOO appears as a flag.
-        let slug;
-        let titleArg;
-        for (let i = 0; i < args.length; i++) {
-            const a = args[i];
-            if (a === undefined)
-                continue;
-            if (a === "--slug" || a === "-s") {
-                slug = args[i + 1];
-                i++;
-                continue;
-            }
-            if (a.startsWith("--slug=")) {
-                slug = a.slice("--slug=".length);
-                continue;
-            }
-            if (a.startsWith("-"))
-                continue;
-            titleArg ??= a;
-        }
-        return { action: "create", slug, titleArg };
-    }
-    // start
-    const args = splitShellArgs(restRaw);
-    let taskDir;
-    for (const a of args) {
-        if (a.startsWith("-"))
-            continue;
-        taskDir = a;
-        break;
-    }
-    return { action: "start", taskDir };
-}
-/** Best-effort shell-arg splitter: respects `"…"` and `'…'` quoting, splits on
- * whitespace, treats shell metacharacters `;`, `|`, `&`, `(`, `)`, `>` as
- * **token boundaries** (so `$(...)` substitution boundaries, command chains,
- * and redirects don't leak into the next positional arg). Also strips any
- * trailing shell-meta cruft from individual tokens — e.g. a `--slug` value
- * captured inside `$(... --slug FOO)` gets the closing `)` lopped off.
- * Sufficient for parsing slugs/paths out of `task.py create|start`
- * invocations; not a full POSIX parser. */
-function splitShellArgs(s) {
-    const out = [];
-    let cur = "";
-    let quote = null;
-    const flush = () => {
-        if (!cur)
-            return;
-        // Strip trailing shell metas that snuck in from $(...) substitution edges,
-        // command chains, redirects, etc. Keep leading chars (paths may start with
-        // `.` or `/`).
-        const cleaned = cur.replace(/[)};&|>]+$/, "");
-        if (cleaned)
-            out.push(cleaned);
-        cur = "";
-    };
-    for (const ch of s) {
-        if (quote) {
-            if (ch === quote) {
-                quote = null;
-                continue;
-            }
-            cur += ch;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            quote = ch;
-            continue;
-        }
-        if (/\s/.test(ch)) {
-            flush();
-            continue;
-        }
-        // Hard token boundaries — these never belong inside a slug or path arg.
-        // Drop them (don't keep as standalone token; the caller never wants them).
-        if (ch === ";" || ch === "|" || ch === "&" || ch === "(" || ch === ")") {
-            flush();
-            continue;
-        }
-        cur += ch;
-    }
-    flush();
-    return out;
-}
-/** Derive a slug from a `start` task-dir path like
- * `.trellis/tasks/05-08-mem-phase-slice/` → `mem-phase-slice` (the
- * `MM-DD-` date prefix is stripped so this matches the slug supplied via
- * `--slug` on the corresponding `task.py create` invocation). */
-function slugFromTaskDir(p) {
-    if (!p)
-        return undefined;
-    // Normalize separators and trim trailing slash + shell metas leaked from
-    // `$(...)` substitution / heredoc edges.
-    const norm = p.replace(/\\+/g, "/").replace(/\/+$/g, "");
-    const parts = norm.split("/").filter(Boolean);
-    const last = parts[parts.length - 1];
-    if (last === undefined)
-        return undefined;
-    // Strip leading `MM-DD-` (e.g. `05-08-`) added by task.py.
-    return last.replace(/^\d{2}-\d{2}-/, "");
-}
-/**
- * Single-pass scan of a Claude JSONL file that produces both:
- *   1. the cleaned dialogue turns (semantically identical to
- *      `claudeExtractDialogue`)
- *   2. the list of `task.py create|start` Bash tool_use events with their
- *      `turnIndex` (= turns.length AT THE TIME the tool_use was seen).
- *
- * Why one pass: we need the turnIndex to align with `claudeExtractDialogue`'s
- * output exactly, including compaction-reset behavior. A second pass would
- * have to re-derive turn indices from timestamps, which is fragile when
- * timestamps repeat or are missing.
- *
- * For non-Claude platforms this returns turns + an empty event list; callers
- * are expected to handle Codex/OpenCode boundary detection separately (or
- * gracefully degrade — see PRD MVP scope).
- */
-export function collectClaudeTurnsAndEvents(s) {
-    let turns = [];
-    let events = [];
-    readJsonl(s.filePath, ClaudeEventSchema, (obj) => {
-        const t = obj.type;
-        const msg = obj.message;
-        if (!msg)
-            return;
-        const content = msg.content;
-        if (t === "user" && obj.isCompactSummary === true) {
-            let summary = "";
-            if (typeof content === "string") {
-                summary = stripInjectionTags(content);
-            }
-            else if (Array.isArray(content)) {
-                const parts = [];
-                for (const block of content) {
-                    if (block.type === "text" && typeof block.text === "string") {
-                        const cleaned = stripInjectionTags(block.text);
-                        if (cleaned)
-                            parts.push(cleaned);
-                    }
-                }
-                summary = parts.join("\n\n");
-            }
-            turns = summary
-                ? [{ role: "user", text: `[compact summary]\n${summary}` }]
-                : [];
-            // Reset events too: pre-compact task.py events anchor to turnIndex
-            // values that no longer correspond to real turns (the underlying
-            // dialogue is collapsed into a single synthetic [compact summary]).
-            // Pairing pre-compact events to post-compact turns would produce
-            // incoherent windows.
-            events = [];
-            return;
-        }
-        if (t === "user" && msg.role === "user") {
-            if (typeof content === "string") {
-                const text = stripInjectionTags(content);
-                if (text && !isBootstrapTurn(text, content.length)) {
-                    turns.push({ role: "user", text });
-                }
-            }
-            return;
-        }
-        if (t === "assistant" &&
-            msg.role === "assistant" &&
-            Array.isArray(content)) {
-            // Walk blocks: text blocks contribute to the eventual cleaned turn;
-            // tool_use blocks with name="Bash" are scanned for task.py invocations.
-            const parts = [];
-            for (const block of content) {
-                if (block.type === "text" && typeof block.text === "string") {
-                    const cleaned = stripInjectionTags(block.text);
-                    if (cleaned)
-                        parts.push(cleaned);
-                }
-                else if (block.type === "tool_use") {
-                    // Schema is loose so we read fields off the block directly.
-                    const b = block;
-                    if (b.name !== "Bash")
-                        continue;
-                    const inp = b.input;
-                    if (!inp || typeof inp !== "object")
-                        continue;
-                    const command = inp.command;
-                    if (typeof command !== "string")
-                        continue;
-                    // A Bash command may invoke task.py multiple times (e.g.
-                    // `SMOKE=$(task.py create …); task.py start "$SMOKE"`). Capture
-                    // every occurrence — the original single-match version dropped
-                    // the second invocation and produced unpaired windows.
-                    const parsedAll = parseTaskPyCommandsAll(command);
-                    for (const parsed of parsedAll) {
-                        // turnIndex = current turns.length (the index this assistant turn
-                        // WILL occupy if its text parts are non-empty; either way, it's
-                        // the cut point for "everything before this Bash event"). For
-                        // assistant messages where text comes BEFORE tool_use blocks, the
-                        // assistant turn is appended AFTER this loop completes, so using
-                        // turns.length here means the boundary lies just before that turn.
-                        // We accept this small drift: brainstorm slicing is at granularity
-                        // of full turns, not intra-turn substrings.
-                        const ev = {
-                            action: parsed.action,
-                            timestamp: obj.timestamp ?? "",
-                            turnIndex: turns.length,
-                            ...(parsed.action === "create"
-                                ? { slug: parsed.slug }
-                                : { taskDir: parsed.taskDir }),
-                        };
-                        events.push(ev);
-                    }
-                }
-            }
-            if (parts.length)
-                turns.push({ role: "assistant", text: parts.join("\n\n") });
-        }
-    });
-    return { turns, events };
-}
-/**
- * Pair `create` → `start` events into brainstorm windows.
- *
- * Pairing strategy:
- *   1. Walk events in order.
- *   2. For each `create`, find the next unmatched `start` whose slug matches
- *      (slug derived from `start` taskDir's last path segment) — slug match
- *      wins regardless of position.
- *   3. If no slug match: pair with the next unmatched `start` by position
- *      (FIFO).
- *   4. Unmatched `create` (no following `start`): window = [create, totalTurns).
- *   5. Unmatched `start` (no preceding `create`): window = [0, start).
- *
- * Window labels: `<slug>` if known, else `window-N`.
- */
-export function buildBrainstormWindows(events, totalTurns) {
-    const creates = events
-        .map((e, i) => ({ e, i }))
-        .filter(({ e }) => e.action === "create");
-    const starts = events
-        .map((e, i) => ({ e, i }))
-        .filter(({ e }) => e.action === "start");
-    const usedStartIdx = new Set();
-    const windows = [];
-    let windowCounter = 0;
-    const usedCreateIdx = new Set();
-    // Pass 1: pair by slug match (slug present on the `create`, matches the
-    // last segment of the `start` taskDir). Slug match wins over position.
-    for (const { e: createEv, i: ci } of creates) {
-        if (!createEv.slug)
-            continue;
-        const matchIdx = starts.findIndex(({ e, i }) => !usedStartIdx.has(i) && slugFromTaskDir(e.taskDir) === createEv.slug);
-        if (matchIdx === -1)
-            continue;
-        const startEntry = starts[matchIdx];
-        if (!startEntry)
-            continue;
-        usedStartIdx.add(startEntry.i);
-        usedCreateIdx.add(ci);
-        pushWindow(windows, createEv.turnIndex, startEntry.e.turnIndex, createEv.slug, ++windowCounter);
-    }
-    // Pass 2: FIFO pair remaining creates with remaining starts that appear
-    // AFTER the create (by event order).
-    for (const { e: createEv, i: ci } of creates) {
-        if (usedCreateIdx.has(ci))
-            continue;
-        const pairedStart = starts.find(({ i }) => !usedStartIdx.has(i) && i > ci);
-        if (pairedStart) {
-            usedStartIdx.add(pairedStart.i);
-            usedCreateIdx.add(ci);
-            const slug = createEv.slug ?? slugFromTaskDir(pairedStart.e.taskDir);
-            pushWindow(windows, createEv.turnIndex, pairedStart.e.turnIndex, slug, ++windowCounter);
-        }
-        else {
-            // Fallback A: create with no start → [create, end).
-            usedCreateIdx.add(ci);
-            pushWindow(windows, createEv.turnIndex, totalTurns, createEv.slug, ++windowCounter);
-        }
-    }
-    // Pass 3: unmatched starts (start with no preceding create) → [0, start).
-    // Fallback B: task was created in an earlier session.
-    for (const { e: startEv, i } of starts) {
-        if (usedStartIdx.has(i))
-            continue;
-        pushWindow(windows, 0, startEv.turnIndex, slugFromTaskDir(startEv.taskDir), ++windowCounter);
-    }
-    // Sort windows by startTurn for stable output ordering.
-    windows.sort((a, b) => a.startTurn - b.startTurn);
-    return windows;
-}
-function pushWindow(windows, startTurn, endTurn, slug, counter) {
-    // Guard: if start > end (e.g., start before create due to event interleave),
-    // skip the malformed window rather than emit an empty / negative slice.
-    if (endTurn < startTurn)
-        return;
-    windows.push({
-        label: slug ?? `window-${counter}`,
-        startTurn,
-        endTurn,
-    });
-}
-// ---------- codex adapter ----------
-const CODEX_SESSIONS = path.join(HOME, ".codex", "sessions");
-function* walkDir(root) {
-    if (!fs.existsSync(root))
-        return;
-    const stack = [root];
-    while (stack.length) {
-        const cur = stack.pop();
-        if (cur === undefined)
-            break;
-        let entries;
-        try {
-            entries = fs.readdirSync(cur, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const e of entries) {
-            const p = path.join(cur, e.name);
-            if (e.isDirectory())
-                stack.push(p);
-            else if (e.isFile())
-                yield p;
-        }
-    }
-}
-export function codexListSessions(f) {
-    if (!fs.existsSync(CODEX_SESSIONS))
-        return [];
-    const out = [];
-    for (const file of walkDir(CODEX_SESSIONS)) {
-        if (!file.endsWith(".jsonl"))
-            continue;
-        const base = path.basename(file, ".jsonl");
-        const m = base.match(/^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-(.+)$/);
-        const tsFromName = m?.[1]
-            ? new Date(m[1].replace(/T(\d{2})-(\d{2})-(\d{2})/, "T$1:$2:$3") + "Z").toISOString()
-            : undefined;
-        // Note: we previously short-circuited on `!inRange(tsFromName, f)` here,
-        // but the filename ts is the session's creation time — a cross-day session
-        // that started before --since but was active inside it would be dropped.
-        // Filter at the same place as claude/opencode using interval overlap.
-        const first = readJsonlFirst(file, CodexEventSchema);
-        const meta = first?.payload;
-        const id = meta?.id ?? m?.[2] ?? base;
-        const cwd = meta?.cwd;
-        const created = first?.timestamp ?? tsFromName ?? "";
-        if (f.cwd && !sameProject(cwd, f.cwd))
-            continue;
-        const updated = fs.statSync(file).mtime.toISOString();
-        if (!inRangeOverlap(created, updated, f))
-            continue;
-        out.push(SessionInfoSchema.parse({
-            platform: "codex",
-            id,
-            cwd,
-            created,
-            updated,
-            filePath: file,
-        }));
-    }
-    return out;
-}
-export function codexExtractDialogue(s) {
-    // Codex events: payload.type=="message" with role in {user, assistant, developer, system}.
-    // Keep user/assistant only. Each content part is {type: "input_text"|"output_text", text}.
-    // Codex inlines a lot of system prompt as the first user message (AGENTS.md, permission
-    // blocks, etc.) — stripInjectionTags removes the bulk; turns that are pure boilerplate
-    // collapse to empty after strip and get dropped here.
-    // Compaction: a top-level event with type=="compacted" carries a payload.replacement_history
-    // array — the new authoritative history replacing everything before. We reset turns and
-    // re-seed from replacement_history.
-    let turns = [];
-    const buildTurnFromMessage = (role, parts) => {
-        const collected = [];
-        let totalRaw = 0;
-        for (const c of parts ?? []) {
-            const txt = c.text;
-            if (typeof txt !== "string")
-                continue;
-            if (c.type !== "input_text" && c.type !== "output_text")
-                continue;
-            totalRaw += txt.length;
-            const cleaned = stripInjectionTags(txt);
-            if (cleaned)
-                collected.push(cleaned);
-        }
-        if (!collected.length)
-            return null;
-        const merged = collected.join("\n\n");
-        if (isBootstrapTurn(merged, totalRaw))
-            return null;
-        return { role, text: merged };
-    };
-    readJsonl(s.filePath, CodexEventSchema, (obj) => {
-        if (obj.type === "compacted") {
-            const rh = obj.payload?.replacement_history;
-            turns = [];
-            if (!Array.isArray(rh))
-                return;
-            for (const item of rh) {
-                if (item.type !== "message")
-                    continue;
-                const r = DialogueRoleSchema.safeParse(item.role);
-                if (!r.success)
-                    continue;
-                const turn = buildTurnFromMessage(r.data, item.content);
-                if (turn)
-                    turns.push({ role: turn.role, text: `[compact]\n${turn.text}` });
-            }
-            return;
-        }
-        const p = obj.payload;
-        if (p?.type !== "message")
-            return;
-        const roleParsed = DialogueRoleSchema.safeParse(p.role);
-        if (!roleParsed.success)
-            return;
-        const turn = buildTurnFromMessage(roleParsed.data, p.content);
-        if (turn)
-            turns.push(turn);
-    });
-    return turns;
-}
-export function codexSearch(s, kw) {
-    return searchInDialogue(codexExtractDialogue(s), kw);
-}
-/** Codex twin of `collectClaudeTurnsAndEvents`. Single pass over the rollout
- * file; emits both the cleaned dialogue turns (semantically identical to
- * `codexExtractDialogue`) AND the list of `task.py create|start` invocations
- * found inside `function_call` events whose `name === "exec_command"` (Codex's
- * stable shell tool). Compaction resets both turns AND events for the same
- * reason as the Claude collector — pre-compact event indices stop pointing at
- * real turns once history is replaced. */
-export function collectCodexTurnsAndEvents(s) {
-    let turns = [];
-    let events = [];
-    const buildTurnFromMessage = (role, parts) => {
-        const collected = [];
-        let totalRaw = 0;
-        for (const c of parts ?? []) {
-            const txt = c.text;
-            if (typeof txt !== "string")
-                continue;
-            if (c.type !== "input_text" && c.type !== "output_text")
-                continue;
-            totalRaw += txt.length;
-            const cleaned = stripInjectionTags(txt);
-            if (cleaned)
-                collected.push(cleaned);
-        }
-        if (!collected.length)
-            return null;
-        const merged = collected.join("\n\n");
-        if (isBootstrapTurn(merged, totalRaw))
-            return null;
-        return { role, text: merged };
-    };
-    readJsonl(s.filePath, CodexEventSchema, (obj) => {
-        if (obj.type === "compacted") {
-            const rh = obj.payload?.replacement_history;
-            turns = [];
-            events = [];
-            if (!Array.isArray(rh))
-                return;
-            for (const item of rh) {
-                if (item.type !== "message")
-                    continue;
-                const r = DialogueRoleSchema.safeParse(item.role);
-                if (!r.success)
-                    continue;
-                const turn = buildTurnFromMessage(r.data, item.content);
-                if (turn)
-                    turns.push({ role: turn.role, text: `[compact]\n${turn.text}` });
-            }
-            return;
-        }
-        const p = obj.payload;
-        if (!p)
-            return;
-        // Function-call events (Codex's shell tool dispatch). The schema is loose
-        // so we read fields off the raw payload.
-        if (p.type === "function_call") {
-            const fnName = p.name;
-            if (fnName !== "exec_command" && fnName !== "shell")
-                return;
-            const argsRaw = p.arguments;
-            let cmd;
-            if (typeof argsRaw === "string") {
-                try {
-                    const parsed = JSON.parse(argsRaw);
-                    if (parsed && typeof parsed === "object") {
-                        const c = parsed.cmd;
-                        if (typeof c === "string")
-                            cmd = c;
-                        else {
-                            const c2 = parsed.command;
-                            if (typeof c2 === "string")
-                                cmd = c2;
-                        }
-                    }
-                }
-                catch {
-                    // arguments not JSON (some Codex versions inline a string) — try as
-                    // raw shell.
-                    cmd = argsRaw;
-                }
-            }
-            if (!cmd)
-                return;
-            const parsedAll = parseTaskPyCommandsAll(cmd);
-            for (const parsed of parsedAll) {
-                const ev = {
-                    action: parsed.action,
-                    timestamp: obj.timestamp ?? "",
-                    turnIndex: turns.length,
-                    ...(parsed.action === "create"
-                        ? { slug: parsed.slug }
-                        : { taskDir: parsed.taskDir }),
-                };
-                events.push(ev);
-            }
-            return;
-        }
-        // Real conversational turn.
-        if (p.type !== "message")
-            return;
-        const roleParsed = DialogueRoleSchema.safeParse(p.role);
-        if (!roleParsed.success)
-            return;
-        const turn = buildTurnFromMessage(roleParsed.data, p.content);
-        if (turn)
-            turns.push(turn);
-    });
-    return { turns, events };
-}
-// ---------- opencode adapter (temporarily unavailable) ----------
-//
-// OpenCode 1.2+ migrated to a SQLite database at
-// ~/.local/share/opencode/opencode.db. The previous SQLite reader required
-// `better-sqlite3` (a native dep). In 0.6.0-beta.4 we reverted that dep
-// because its prebuilt-tarball download from GitHub Releases was unreliable
-// in some networks (notably Windows + China), and the source-build fallback
-// requires a C compiler that most users don't have — `npm install` was
-// failing for the entire CLI, not just the OpenCode reader.
+// ---------- OpenCode reader notice ----------
 //
-// The three exported adapter functions are kept (callers in dispatch /
-// slicePhase rely on them) but degraded to no-ops with a one-shot stderr
-// warning. Re-enabled in a future release once a non-native fallback ships.
+// OpenCode 1.2+ moved to a SQLite store; the native dependency was reverted in
+// 0.6.0-beta.4 due to install failures. Core's OpenCode adapter is a silent
+// no-op — surfacing the degraded state is a CLI presentation concern, emitted
+// once per process whenever the OpenCode source is in scope.
 let opencodeWarned = false;
 function warnOpencodeUnavailable() {
     if (opencodeWarned)
@@ -1277,96 +100,12 @@ function warnOpencodeUnavailable() {
         "    OpenCode 1.2+ moved to SQLite; the native dependency was reverted in\n" +
         "    0.6.0-beta.4 due to install failures. Re-enabled in a future release.\n");
 }
-export function opencodeListSessions(_f) {
-    warnOpencodeUnavailable();
-    return [];
-}
-export function opencodeExtractDialogue(_s) {
-    warnOpencodeUnavailable();
-    return [];
-}
-function opencodeSearch(_s, kw) {
-    warnOpencodeUnavailable();
-    return searchInDialogue([], kw);
-}
-// ---------- dispatch ----------
-function listAll(f) {
-    const all = [];
-    if (f.platform === "all" || f.platform === "claude")
-        all.push(...claudeListSessions(f));
-    if (f.platform === "all" || f.platform === "codex")
-        all.push(...codexListSessions(f));
+function maybeWarnOpencode(f) {
     if (f.platform === "all" || f.platform === "opencode")
-        all.push(...opencodeListSessions(f));
-    all.sort((a, b) => (b.updated ?? b.created ?? "").localeCompare(a.updated ?? a.created ?? ""));
-    return all.slice(0, f.limit);
-}
-function extractDialogue(s) {
-    switch (s.platform) {
-        case "claude":
-            return claudeExtractDialogue(s);
-        case "codex":
-            return codexExtractDialogue(s);
-        case "opencode":
-            return opencodeExtractDialogue(s);
-    }
-}
-function searchSession(s, kw) {
-    switch (s.platform) {
-        case "claude":
-            return claudeSearch(s, kw);
-        case "codex":
-            return codexSearch(s, kw);
-        case "opencode":
-            return opencodeSearch(s, kw);
-    }
-}
-/** Build parent → descendants index for OpenCode (transitively flattened).
- * Other platforms have no native parent_id so they pass through unchanged. */
-function buildChildIndex(sessions) {
-    const directChildren = new Map();
-    for (const s of sessions) {
-        if (!s.parent_id)
-            continue;
-        const list = directChildren.get(s.parent_id) ?? [];
-        list.push(s);
-        directChildren.set(s.parent_id, list);
-    }
-    // Transitive flatten: each parent maps to *all* descendants.
-    const out = new Map();
-    for (const [pid] of directChildren) {
-        const stack = [...(directChildren.get(pid) ?? [])];
-        const flat = [];
-        while (stack.length) {
-            const cur = stack.pop();
-            if (cur === undefined)
-                break;
-            flat.push(cur);
-            for (const c of directChildren.get(cur.id) ?? [])
-                stack.push(c);
-        }
-        out.set(pid, flat);
-    }
-    return out;
-}
-function searchSessionWithChildren(s, kw, childIndex) {
-    const children = childIndex.get(s.id) ?? [];
-    if (children.length === 0)
-        return searchSession(s, kw);
-    // Concatenate parent + descendants' cleaned dialogue, then run a single
-    // search over the merged turn list. This way scores reflect total topic
-    // density across the sub-agent tree.
-    const merged = [...extractDialogue(s)];
-    for (const c of children)
-        merged.push(...extractDialogue(c));
-    return searchInDialogue(merged, kw);
-}
-function findSessionById(id, f) {
-    const wide = { ...f, cwd: undefined, limit: 1_000_000 };
-    const all = listAll(wide);
-    return all.find((s) => s.id === id) ?? all.find((s) => s.id.startsWith(id));
+        warnOpencodeUnavailable();
 }
 // ---------- formatting ----------
+const HOME = os.homedir();
 export function shortDate(iso) {
     if (!iso)
         return "         ";
@@ -1395,7 +134,8 @@ function printSessions(rows) {
 // ---------- commands ----------
 function cmdList(argv) {
     const f = buildFilter(argv.flags);
-    const rows = listAll(f);
+    maybeWarnOpencode(f);
+    const rows = listMemSessions({ filter: f });
     if (argv.flags.json) {
         console.log(JSON.stringify(rows, null, 2));
         return;
@@ -1411,52 +151,24 @@ function cmdSearch(argv) {
     if (!kw)
         die("usage: search <keyword>");
     const f = buildFilter(argv.flags);
-    const wide = { ...f, limit: 1_000_000 };
-    const candidates = listAll(wide);
+    maybeWarnOpencode(f);
     const includeChildren = argv.flags["include-children"] === true;
-    // When --include-children is set: search over the merged dialogue of each
-    // session plus its descendants (only OpenCode populates parent_id natively).
-    // Children whose parent is also in the candidate set are dropped from the
-    // result list — they get absorbed into the parent's hit.
-    const childIndex = includeChildren ? buildChildIndex(candidates) : new Map();
-    const candidateIds = new Set(candidates.map((s) => s.id));
-    const isAbsorbedChild = (s) => includeChildren &&
-        s.parent_id !== undefined &&
-        candidateIds.has(s.parent_id);
-    const matches = [];
-    for (const s of candidates) {
-        if (isAbsorbedChild(s))
-            continue;
-        const hit = includeChildren
-            ? searchSessionWithChildren(s, kw, childIndex)
-            : searchSession(s, kw);
-        if (hit.count === 0)
-            continue;
-        matches.push({ s, hit, descendants: childIndex.get(s.id)?.length ?? 0 });
-    }
-    // Rank by weighted-density relevance score: user hits matter ×3, normalized
-    // by total dialogue length so a tight 18-hit short session beats a sprawling
-    // 58-hit long one. Tie-break on raw count, then recency.
-    matches.sort((a, b) => {
-        const sa = relevanceScore(a.hit);
-        const sb = relevanceScore(b.hit);
-        if (sb !== sa)
-            return sb - sa;
-        if (b.hit.count !== a.hit.count)
-            return b.hit.count - a.hit.count;
-        return (b.s.updated ?? b.s.created ?? "").localeCompare(a.s.updated ?? a.s.created ?? "");
+    const result = searchMemSessions({
+        keyword: kw,
+        filter: f,
+        includeChildren,
     });
-    const top = matches.slice(0, f.limit);
+    const top = result.matches;
     if (argv.flags.json) {
-        console.log(JSON.stringify(top.map(({ s, hit, descendants }) => ({
-            session: s,
-            score: Number(relevanceScore(hit).toFixed(4)),
-            hit_count: hit.count,
-            user_count: hit.user_count,
-            asst_count: hit.asst_count,
-            total_turns: hit.total_turns,
-            descendants_merged: includeChildren ? descendants : 0,
-            excerpts: hit.excerpts,
+        console.log(JSON.stringify(top.map((m) => ({
+            session: m.session,
+            score: Number(m.score.toFixed(4)),
+            hit_count: m.hit.count,
+            user_count: m.hit.userCount,
+            asst_count: m.hit.asstCount,
+            total_turns: m.hit.totalTurns,
+            descendants_merged: includeChildren ? m.descendantsMerged : 0,
+            excerpts: m.hit.excerpts,
         })), null, 2));
         return;
     }
@@ -1466,49 +178,30 @@ function cmdSearch(argv) {
         console.log("(no matches)");
         return;
     }
-    for (const { s, hit, descendants } of top) {
+    for (const m of top) {
+        const s = m.session;
         const idShort = s.id.slice(0, 12);
-        const score = relevanceScore(hit).toFixed(3);
-        const childTag = includeChildren && descendants > 0 ? `  +${descendants} child` : "";
+        const score = m.score.toFixed(3);
+        const childTag = includeChildren && m.descendantsMerged > 0
+            ? `  +${m.descendantsMerged} child`
+            : "";
         console.log(`\n[${s.platform.padEnd(8)}] ${shortDate(s.updated ?? s.created)}  ${idShort}  ${shortPath(s.cwd)}` +
-            `  score=${score}  hits=${hit.count} (u=${hit.user_count},a=${hit.asst_count})  turns=${hit.total_turns}${childTag}` +
+            `  score=${score}  hits=${m.hit.count} (u=${m.hit.userCount},a=${m.hit.asstCount})  turns=${m.hit.totalTurns}${childTag}` +
             (s.title ? `  — ${s.title}` : ""));
-        for (const ex of hit.excerpts) {
+        for (const ex of m.hit.excerpts) {
             console.log(`    [${ex.role}] ${ex.snippet}`);
         }
     }
-    console.log(`\n${top.length} session(s)${matches.length > top.length ? ` (of ${matches.length})` : ""}`);
+    console.log(`\n${top.length} session(s)${result.totalMatches > top.length ? ` (of ${result.totalMatches})` : ""}`);
 }
 function cmdProjects(argv) {
-    // List distinct cwds across all platforms with last-active timestamp + per-platform
-    // session counts. Designed for AI consumption: AI calls this first to learn which
-    // "门牌号" (project paths) have recent activity, then picks one for `--cwd` in
-    // a follow-up `search`.
+    // Distinct cwds across all platforms with last-active timestamp + per-platform
+    // session counts. AI calls this first to learn which project paths have
+    // recent activity, then picks one for `--cwd` in a follow-up `search`.
     const f = buildFilter({ ...argv.flags, global: true });
-    const wide = { ...f, cwd: undefined, limit: 1_000_000 };
-    const all = listAll(wide);
-    const byCwd = new Map();
-    for (const s of all) {
-        if (!s.cwd)
-            continue;
-        const ts = s.updated ?? s.created ?? "";
-        let agg = byCwd.get(s.cwd);
-        if (!agg) {
-            agg = {
-                cwd: s.cwd,
-                last_active: ts,
-                sessions: 0,
-                by_platform: { claude: 0, codex: 0, opencode: 0 },
-            };
-            byCwd.set(s.cwd, agg);
-        }
-        agg.sessions++;
-        agg.by_platform[s.platform]++;
-        if (ts > agg.last_active)
-            agg.last_active = ts;
-    }
-    const rows = [...byCwd.values()].sort((a, b) => b.last_active.localeCompare(a.last_active));
-    const limit = typeof argv.flags.limit === "string" ? Number(argv.flags.limit) : 30;
+    maybeWarnOpencode(f);
+    const rows = listMemProjects({ filter: f });
+    const limit = parseOptionalNumberFlag(argv.flags.limit, "--limit", 30);
     const top = rows.slice(0, limit);
     if (argv.flags.json) {
         console.log(JSON.stringify(top, null, 2));
@@ -1531,137 +224,76 @@ function cmdProjects(argv) {
     console.log(`\n${top.length} project(s)${rows.length > top.length ? ` (of ${rows.length})` : ""}`);
 }
 function cmdContext(argv) {
-    // Drill-down step 2 in the search workflow:
-    //   1. `search <kw>` → pick a session
-    //   2. `context <id> --grep <kw> --turns N --around M` → top-N hit turns with M
-    //      turns of context on either side, token-budgeted for AI consumption
-    //
-    // Without --grep: returns the first N turns (lets AI inspect session opening).
-    // With --grep: ranks turns by (user-role first, then hit density), takes top-N,
-    // then expands each by --around turns of surrounding context.
+    // Drill-down step 2 in the search workflow: `search <kw>` picks a session,
+    // then `context <id> --grep <kw>` returns top-N hit turns with surrounding
+    // context, token-budgeted for AI consumption. Without --grep: first N turns.
     const id = argv.positional[0];
     if (!id)
         die("usage: context <session-id> [--grep KW] [--turns N] [--around M]");
     const f = buildFilter(argv.flags);
-    const s = findSessionById(id, f);
-    if (!s)
-        die(`session not found: ${id}`);
+    maybeWarnOpencode(f);
     const grepRaw = argv.flags.grep;
     const grep = typeof grepRaw === "string" ? grepRaw : undefined;
-    const nTurns = typeof argv.flags.turns === "string" ? Number(argv.flags.turns) : 3;
-    const around = typeof argv.flags.around === "string" ? Number(argv.flags.around) : 1;
-    const maxChars = typeof argv.flags["max-chars"] === "string"
-        ? Number(argv.flags["max-chars"])
-        : 6000;
-    let turns = extractDialogue(s);
-    let mergedChildren = 0;
-    if (argv.flags["include-children"] === true) {
-        const all = listAll({ ...f, cwd: undefined, limit: 1_000_000 });
-        const childIndex = buildChildIndex(all);
-        const kids = childIndex.get(s.id) ?? [];
-        mergedChildren = kids.length;
-        for (const c of kids)
-            turns = [...turns, ...extractDialogue(c)];
-    }
-    let hitIndices = [];
-    let totalHitTurns = 0;
-    if (grep) {
-        const tokens = grep.toLowerCase().split(/\s+/).filter(Boolean);
-        if (tokens.length === 0)
-            die("--grep requires non-empty value");
-        const matchCount = (text) => {
-            const hay = text.toLowerCase();
-            if (!tokens.every((tok) => hay.includes(tok)))
-                return 0;
-            let n = 0;
-            for (const tok of tokens) {
-                let from = 0;
-                while (true) {
-                    const idx = hay.indexOf(tok, from);
-                    if (idx === -1)
-                        break;
-                    n++;
-                    from = idx + tok.length;
-                }
-            }
-            return n;
-        };
-        const ranked = [];
-        for (let i = 0; i < turns.length; i++) {
-            const turn = turns[i];
-            if (!turn)
-                continue;
-            const h = matchCount(turn.text);
-            if (h > 0)
-                ranked.push({ idx: i, role: turn.role, hits: h });
-        }
-        totalHitTurns = ranked.length;
-        ranked.sort((a, b) => {
-            if (a.role !== b.role)
-                return a.role === "user" ? -1 : 1;
-            if (b.hits !== a.hits)
-                return b.hits - a.hits;
-            return a.idx - b.idx;
+    if (grep?.split(/\s+/).filter(Boolean).length === 0)
+        die("--grep requires non-empty value");
+    const nTurns = parseOptionalNumberFlag(argv.flags.turns, "--turns", 3);
+    const around = parseOptionalNumberFlag(argv.flags.around, "--around", 1);
+    const maxChars = parseOptionalNumberFlag(argv.flags["max-chars"], "--max-chars", 6000);
+    const includeChildren = argv.flags["include-children"] === true;
+    let result;
+    try {
+        result = readMemContext({
+            sessionId: id,
+            filter: f,
+            grep,
+            turns: nTurns,
+            around,
+            maxChars,
+            includeChildren,
         });
-        hitIndices = ranked.slice(0, nTurns).map((r) => r.idx);
     }
-    else {
-        hitIndices = [];
-        for (let i = 0; i < Math.min(nTurns, turns.length); i++)
-            hitIndices.push(i);
-    }
-    // Expand each hit by `around` turns on either side; dedupe via Set.
-    const display = new Set();
-    for (const idx of hitIndices) {
-        for (let j = Math.max(0, idx - around); j <= Math.min(turns.length - 1, idx + around); j++) {
-            display.add(j);
-        }
-    }
-    const ordered = [...display].sort((a, b) => a - b);
-    const hitSet = new Set(hitIndices);
-    const out = [];
-    let used = 0;
-    for (const i of ordered) {
-        const t = turns[i];
-        if (!t)
-            continue;
-        let text = t.text;
-        // Per-turn cap: if a single turn exceeds half the budget, truncate it so we
-        // still fit the rest of the requested context.
-        const cap = Math.floor(maxChars / 2);
-        if (text.length > cap)
-            text = text.slice(0, cap) + `\n…[+${t.text.length - cap} chars]`;
-        if (used + text.length > maxChars && out.length > 0)
-            break;
-        out.push({ idx: i, role: t.role, text, is_hit: hitSet.has(i) });
-        used += text.length;
+    catch (error) {
+        if (error instanceof MemSessionNotFoundError)
+            die(`session not found: ${id}`);
+        throw error;
     }
+    const s = result.session;
     if (argv.flags.json) {
         console.log(JSON.stringify({
             session: s,
-            query: grep,
-            total_turns: turns.length,
-            total_hit_turns: totalHitTurns,
-            merged_children: mergedChildren,
-            turns: out,
+            query: result.query,
+            total_turns: result.totalTurns,
+            total_hit_turns: result.totalHitTurns,
+            merged_children: result.mergedChildren,
+            turns: result.turns.map((t) => ({
+                idx: t.idx,
+                role: t.role,
+                text: t.text,
+                is_hit: t.isHit,
+            })),
         }, null, 2));
         return;
     }
+    // `hitIndices.length` from the legacy implementation — recomputed here for
+    // the human-readable header only.
+    const shown = grep
+        ? Math.min(result.totalHitTurns, nTurns)
+        : Math.min(nTurns, result.totalTurns);
     console.log(`# context: [${s.platform}] ${s.id}`);
     if (s.title)
         console.log(`# title: ${s.title}`);
     if (s.cwd)
         console.log(`# cwd:   ${shortPath(s.cwd)}`);
     if (grep)
-        console.log(`# query: "${grep}"  hit_turns=${totalHitTurns}  showing top ${hitIndices.length}`);
+        console.log(`# query: "${grep}"  hit_turns=${result.totalHitTurns}  showing top ${shown}`);
     else
-        console.log(`# no grep — showing first ${hitIndices.length} turns of ${turns.length}`);
-    if (mergedChildren > 0)
-        console.log(`# merged_children: ${mergedChildren}`);
-    console.log(`# turns shown: ${out.length}  budget_used: ${used}/${maxChars} chars`);
+        console.log(`# no grep — showing first ${shown} turns of ${result.totalTurns}`);
+    if (result.mergedChildren > 0)
+        console.log(`# merged_children: ${result.mergedChildren}`);
+    console.log(`# turns shown: ${result.turns.length}  budget_used: ${result.budgetUsed}/${result.maxChars} chars`);
     console.log("");
-    for (const t of out) {
-        const marker = t.is_hit ? "  ← hit" : "";
+    for (const t of result.turns) {
+        const marker = t.isHit ? "  ← hit" : "";
         console.log(`## turn ${t.idx} (${t.role})${marker}\n`);
         console.log(t.text);
         console.log("\n---\n");
@@ -1674,111 +306,35 @@ function parsePhaseFlag(raw) {
         return raw;
     die(`unknown --phase: ${String(raw)} (expected brainstorm|implement|all)`);
 }
-/** Slice cleaned dialogue by phase. Claude and Codex have native boundary
- * detection (via raw JSONL `task.py create|start` invocations in tool_use /
- * function_call events). OpenCode does not — its session storage doesn't
- * expose Bash tool calls in a comparable shape, so it degrades to "all turns
- * + warning". */
-function slicePhase(s, phase) {
-    const warnings = [];
-    if (phase === "all" || s.platform === "opencode") {
-        if (phase !== "all" && s.platform === "opencode") {
-            warnings.push(`--phase ${phase} on platform=opencode is not yet supported; ` +
-                `returning full dialogue.`);
-        }
-        const turns = extractDialogue(s);
-        return {
-            groups: [{ label: null, turns }],
-            windows: [],
-            totalTurns: turns.length,
-            warnings,
-        };
-    }
-    // Claude / Codex path: collect turns + task.py events in one raw-JSONL pass,
-    // then build brainstorm windows.
-    const { turns, events } = s.platform === "claude"
-        ? collectClaudeTurnsAndEvents(s)
-        : collectCodexTurnsAndEvents(s);
-    const windows = buildBrainstormWindows(events, turns.length);
-    if (phase === "brainstorm") {
-        if (windows.length === 0) {
-            warnings.push(`no task.py create/start boundary found in session — returning full dialogue.`);
-            return {
-                groups: [{ label: null, turns }],
-                windows: [],
-                totalTurns: turns.length,
-                warnings,
-            };
-        }
-        const groups = windows.map((w) => ({
-            label: w.label,
-            turns: turns.slice(w.startTurn, w.endTurn),
-        }));
-        return { groups, windows, totalTurns: turns.length, warnings };
-    }
-    // phase === "implement": all turns NOT inside any brainstorm window.
-    if (windows.length === 0) {
-        warnings.push(`no task.py create/start boundary found in session — implement phase is empty.`);
-        return {
-            groups: [{ label: null, turns: [] }],
-            windows: [],
-            totalTurns: turns.length,
-            warnings,
-        };
-    }
-    // Build set of indices covered by any brainstorm window.
-    const covered = new Set();
-    for (const w of windows) {
-        for (let i = w.startTurn; i < w.endTurn; i++)
-            covered.add(i);
-    }
-    const implementTurns = [];
-    for (let i = 0; i < turns.length; i++) {
-        if (!covered.has(i)) {
-            const t = turns[i];
-            if (t)
-                implementTurns.push(t);
-        }
-    }
-    return {
-        groups: [{ label: null, turns: implementTurns }],
-        windows,
-        totalTurns: turns.length,
-        warnings,
-    };
-}
 function cmdExtract(argv) {
     const id = argv.positional[0];
     if (!id)
         die("usage: extract <session-id>");
     const f = buildFilter(argv.flags);
-    const s = findSessionById(id, f);
-    if (!s)
-        die(`session not found: ${id}`);
+    maybeWarnOpencode(f);
     const phase = parsePhaseFlag(argv.flags.phase);
-    const slice = slicePhase(s, phase);
-    for (const w of slice.warnings)
-        console.error(`warning: ${w}`);
     const grepRaw = argv.flags.grep;
     const grep = typeof grepRaw === "string" ? grepRaw.toLowerCase() : undefined;
-    // Apply --grep AFTER phase slicing.
-    const filterTurns = (turns) => grep ? turns.filter((t) => t.text.toLowerCase().includes(grep)) : turns;
+    let result;
+    try {
+        result = extractMemDialogue({ sessionId: id, filter: f, phase, grep });
+    }
+    catch (error) {
+        if (error instanceof MemSessionNotFoundError)
+            die(`session not found: ${id}`);
+        throw error;
+    }
+    for (const w of result.warnings)
+        console.error(`warning: ${w.message}`);
+    const s = result.session;
     if (argv.flags.json) {
-        const groups = slice.groups.map((g) => ({
-            label: g.label,
-            turns: filterTurns(g.turns),
-        }));
-        // For backwards compat when phase=all (single unlabeled group), expose
-        // a flat `turns` field too. New `groups` / `windows` fields are added
-        // unconditionally so AI consumers can rely on them.
-        const flat = groups.flatMap((g) => g.turns);
         console.log(JSON.stringify({
             session: s,
-            phase,
-            windows: slice.windows,
-            total_turns: slice.totalTurns,
-            groups,
-            turns: flat,
+            phase: result.phase,
+            windows: result.windows,
+            total_turns: result.totalTurns,
+            groups: result.groups,
+            turns: result.turns,
         }, null, 2));
         return;
     }
@@ -1789,15 +345,14 @@ function cmdExtract(argv) {
         console.log(`# cwd:   ${shortPath(s.cwd)}`);
     if (s.created)
         console.log(`# date:  ${shortDate(s.created)}`);
-    const totalShown = slice.groups.reduce((n, g) => n + filterTurns(g.turns).length, 0);
-    console.log(`# phase: ${phase}  turns: ${totalShown}/${slice.totalTurns}` +
+    console.log(`# phase: ${result.phase}  turns: ${result.turns.length}/${result.totalTurns}` +
         (grep ? ` (filtered by /${grep}/)` : "") +
-        (slice.windows.length > 0 ? `  windows: ${slice.windows.length}` : ""));
+        (result.windows.length > 0 ? `  windows: ${result.windows.length}` : ""));
     console.log("");
-    for (const g of slice.groups) {
+    for (const g of result.groups) {
         if (g.label !== null)
             console.log(`--- task: ${g.label} ---\n`);
-        for (const t of filterTurns(g.turns)) {
+        for (const t of g.turns) {
             console.log(`## ${t.role === "user" ? "Human" : "Assistant"}\n`);
             console.log(t.text);
             console.log("\n---\n");
@@ -1826,7 +381,7 @@ flags:
   --grep KW                              extract / context: filter turns by keyword (multi-token AND)
   --phase brainstorm|implement|all       extract: slice by Trellis brainstorm windows
                                          (default all; brainstorm = [task.py create, task.py start);
-                                         Claude-only — Codex/OpenCode warn + return all)
+                                         Claude/Codex supported; OpenCode warns + returns all)
   --turns N                              context: number of hit turns to return (default 3)
   --around N                             context: turns of surrounding context per hit (default 1)
   --max-chars N                          context: total char budget (default 6000, ~1500 tokens)