@mindfoldhq/trellis 0.6.0-beta.2 → 0.6.0-beta.20

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,157 +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(),
-    messageDir: z.string().optional(),
-    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();
-// OpenCode session/message/part files.
-const OpenCodeSessionSchema = z
-    .object({
-    id: z.string(),
-    title: z.string().optional(),
-    directory: z.string().optional(),
-    parentID: z.string().optional(),
-    time: z
-        .object({
-        created: z.number().optional(),
-        updated: z.number().optional(),
-    })
-        .loose()
-        .optional(),
-})
-    .loose();
-const OpenCodeMessageSchema = z
-    .object({
-    id: z.string(),
-    role: z.string().optional(),
-    time: z.object({ created: z.number().optional() }).loose().optional(),
-})
-    .loose();
-const OpenCodePartSchema = z
-    .object({
-    type: z.string().optional(),
-    text: z.string().optional(),
-    synthetic: z.boolean().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 = [];
@@ -184,754 +40,72 @@ 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. */
-function readJsonl(file, schema, onLine) {
-    let data;
-    try {
-        data = fs.readFileSync(file, "utf8");
-    }
-    catch {
+// ---------- OpenCode reader notice ----------
+//
+// 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)
         return;
-    }
-    for (const line of data.split("\n")) {
-        if (!line.trim())
-            continue;
-        let raw;
-        try {
-            raw = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const parsed = schema.safeParse(raw);
-        if (!parsed.success)
-            continue;
-        if (onLine(parsed.data) === "stop")
-            return;
-    }
+    opencodeWarned = true;
+    process.stderr.write("⚠️  tl mem: OpenCode platform reader is temporarily unavailable in this build.\n" +
+        "    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");
 }
-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);
-}
-// ---------- 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);
-}
-// ---------- opencode adapter ----------
-const OC_ROOT = path.join(HOME, ".local", "share", "opencode", "storage");
-const OC_SESSION_DIR = path.join(OC_ROOT, "session");
-const OC_MESSAGE_DIR = path.join(OC_ROOT, "message");
-const OC_PART_DIR = path.join(OC_ROOT, "part");
-export function opencodeListSessions(f) {
-    if (!fs.existsSync(OC_SESSION_DIR))
-        return [];
-    const out = [];
-    for (const file of walkDir(OC_SESSION_DIR)) {
-        if (!file.endsWith(".json"))
-            continue;
-        const info = readJsonFile(file, OpenCodeSessionSchema);
-        if (!info)
-            continue;
-        const created = info.time?.created !== undefined
-            ? new Date(info.time.created).toISOString()
-            : undefined;
-        const updated = info.time?.updated !== undefined
-            ? new Date(info.time.updated).toISOString()
-            : undefined;
-        const cwd = info.directory;
-        if (f.cwd && !sameProject(cwd, f.cwd))
-            continue;
-        if (!inRangeOverlap(created, updated, f))
-            continue;
-        out.push(SessionInfoSchema.parse({
-            platform: "opencode",
-            id: info.id,
-            title: info.title,
-            cwd,
-            created,
-            updated,
-            filePath: file,
-            messageDir: path.join(OC_MESSAGE_DIR, info.id),
-            parent_id: info.parentID,
-        }));
-    }
-    return out;
-}
-function opencodeListMessageFiles(messageDir) {
-    try {
-        return fs.readdirSync(messageDir).filter((n) => n.endsWith(".json"));
-    }
-    catch {
-        return [];
-    }
-}
-export function opencodeExtractDialogue(s) {
-    // OpenCode: messages live at message/<sid>/msg_*.json, part bodies at part/<msgId>/prt_*.json.
-    // Keep parts with type=="text" && synthetic !== true; group by message; dialogue role
-    // comes from the message file's `role` field. Synthetic parts are platform-injected
-    // preamble (mode prompts, agent boilerplate) and are dropped as noise.
-    const turns = [];
-    if (!s.messageDir || !fs.existsSync(s.messageDir))
-        return turns;
-    const ordered = [];
-    for (const mf of opencodeListMessageFiles(s.messageDir)) {
-        const msg = readJsonFile(path.join(s.messageDir, mf), OpenCodeMessageSchema);
-        if (msg)
-            ordered.push({ msg, created: msg.time?.created ?? 0 });
-    }
-    ordered.sort((a, b) => a.created - b.created);
-    for (const { msg } of ordered) {
-        const roleParsed = DialogueRoleSchema.safeParse(msg.role);
-        if (!roleParsed.success)
-            continue;
-        const partDir = path.join(OC_PART_DIR, msg.id);
-        if (!fs.existsSync(partDir))
-            continue;
-        let parts;
-        try {
-            parts = fs.readdirSync(partDir).filter((n) => n.endsWith(".json"));
-        }
-        catch {
-            continue;
-        }
-        const collected = [];
-        let totalRaw = 0;
-        for (const pf of parts) {
-            const part = readJsonFile(path.join(partDir, pf), OpenCodePartSchema);
-            if (!part)
-                continue;
-            if (part.type !== "text" || part.synthetic)
-                continue;
-            if (typeof part.text !== "string")
-                continue;
-            totalRaw += part.text.length;
-            const cleaned = stripInjectionTags(part.text);
-            if (cleaned)
-                collected.push(cleaned);
-        }
-        if (!collected.length)
-            continue;
-        const merged = collected.join("\n\n");
-        if (isBootstrapTurn(merged, totalRaw))
-            continue;
-        turns.push({ role: roleParsed.data, text: merged });
-    }
-    return turns;
-}
-function opencodeSearch(s, kw) {
-    const turns = opencodeExtractDialogue(s);
-    if (s.title)
-        turns.unshift({ role: "user", text: s.title });
-    return searchInDialogue(turns, 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 "         ";
@@ -960,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;
@@ -976,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;
     }
@@ -1031,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));
@@ -1096,159 +224,117 @@ 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");
     }
 }
+function parsePhaseFlag(raw) {
+    if (raw === undefined || raw === false)
+        return "all";
+    if (raw === "brainstorm" || raw === "implement" || raw === "all")
+        return raw;
+    die(`unknown --phase: ${String(raw)} (expected brainstorm|implement|all)`);
+}
 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}`);
-    const turns = extractDialogue(s);
+    maybeWarnOpencode(f);
+    const phase = parsePhaseFlag(argv.flags.phase);
     const grepRaw = argv.flags.grep;
     const grep = typeof grepRaw === "string" ? grepRaw.toLowerCase() : undefined;
+    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) {
         console.log(JSON.stringify({
             session: s,
-            turns: grep
-                ? turns.filter((t) => t.text.toLowerCase().includes(grep))
-                : turns,
+            phase: result.phase,
+            windows: result.windows,
+            total_turns: result.totalTurns,
+            groups: result.groups,
+            turns: result.turns,
         }, null, 2));
         return;
     }
@@ -1259,14 +345,18 @@ function cmdExtract(argv) {
         console.log(`# cwd:   ${shortPath(s.cwd)}`);
     if (s.created)
         console.log(`# date:  ${shortDate(s.created)}`);
-    console.log(`# turns: ${turns.length}${grep ? ` (filtered by /${grep}/)` : ""}`);
+    console.log(`# phase: ${result.phase}  turns: ${result.turns.length}/${result.totalTurns}` +
+        (grep ? ` (filtered by /${grep}/)` : "") +
+        (result.windows.length > 0 ? `  windows: ${result.windows.length}` : ""));
     console.log("");
-    for (const t of turns) {
-        if (grep && !t.text.toLowerCase().includes(grep))
-            continue;
-        console.log(`## ${t.role === "user" ? "Human" : "Assistant"}\n`);
-        console.log(t.text);
-        console.log("\n---\n");
+    for (const g of result.groups) {
+        if (g.label !== null)
+            console.log(`--- task: ${g.label} ---\n`);
+        for (const t of g.turns) {
+            console.log(`## ${t.role === "user" ? "Human" : "Assistant"}\n`);
+            console.log(t.text);
+            console.log("\n---\n");
+        }
     }
 }
 function cmdHelp() {
@@ -1289,6 +379,9 @@ flags:
   --cwd <path>                           override the project cwd
   --limit N                              cap output (default 50)
   --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/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)
@@ -1301,6 +394,7 @@ examples:
   trellis mem list --global --platform claude --since 2026-04-01
   trellis mem search "session insight" --global
   trellis mem extract 5842592d --grep memory
+  trellis mem extract 5842592d --phase brainstorm
 `);
 }
 // ---------- entry ----------