memarium 0.13.1

package/dist/src/sources/vscode-copilot.js

@@ -0,0 +1,400 @@
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { deriveSlug } from "../slug.js";
+import { cachedProjectSlug } from "../project-identity.js";
+import { sanitizeMessageText } from "./claude-code.js";
+function defaultStorageRoot() {
+    if (process.platform === "darwin")
+        return join(homedir(), "Library", "Application Support", "Code", "User", "workspaceStorage");
+    if (process.platform === "win32")
+        return join(homedir(), "AppData", "Roaming", "Code", "User", "workspaceStorage");
+    return join(homedir(), ".config", "Code", "User", "workspaceStorage");
+}
+export class VSCodeCopilotAdapter {
+    root;
+    name = "copilot";
+    constructor(root = defaultStorageRoot()) {
+        this.root = root;
+    }
+    async *discover() {
+        if (!existsSync(this.root))
+            return;
+        let workspaces;
+        try {
+            workspaces = readdirSync(this.root, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const w of workspaces) {
+            if (!w.isDirectory())
+                continue;
+            const wsDir = join(this.root, w.name);
+            const wsPath = readWorkspacePath(join(wsDir, "workspace.json"));
+            // Within a single workspace, the SAME conversation can land in BOTH
+            // `chatSessions/<id>.jsonl` (the rolling-window state log, schema fixed
+            // in 0.7.0) and `GitHub.copilot-chat/transcripts/<id>.jsonl` (an
+            // older event-stream format). Letting both through produces twin .md
+            // files at different paths because the two formats extract different
+            // first-user prompts and different startedAt timestamps — same
+            // sessionId, two filenames, only one of them indexed (audit on Yue's
+            // 2026-05-23 sync surfaced 83 orphan files repo-wide). Prefer
+            // chatSessions/ as the authoritative source; transcripts/ runs only
+            // as a fallback when chatSessions/ doesn't have the id.
+            const chatDir = join(wsDir, "chatSessions");
+            const chatSessionIds = new Set();
+            // Legacy format (pre-2026-04): workspaceStorage/<hash>/chatSessions/<id>.json
+            // Newer append-log format (2026-03+): workspaceStorage/<hash>/chatSessions/<id>.jsonl
+            if (existsSync(chatDir)) {
+                let files = [];
+                try {
+                    files = readdirSync(chatDir, { withFileTypes: true });
+                }
+                catch {
+                    files = [];
+                }
+                for (const f of files) {
+                    if (!f.isFile())
+                        continue;
+                    const isJson = f.name.endsWith(".json");
+                    const isJsonl = f.name.endsWith(".jsonl");
+                    if (!isJson && !isJsonl)
+                        continue;
+                    const p = join(chatDir, f.name);
+                    const st = statSync(p);
+                    if (st.size === 0)
+                        continue;
+                    chatSessionIds.add(basename(f.name, isJsonl ? ".jsonl" : ".json"));
+                    const buf = readFileSync(p);
+                    const sha = createHash("sha256").update(buf).digest("hex");
+                    yield {
+                        sourcePath: p,
+                        sourceMtimeMs: st.mtimeMs,
+                        sourceSha256: sha,
+                        load: async () => isJsonl
+                            ? parseCopilotChatSessionsJsonl(p, buf.toString("utf8"), wsPath)
+                            : parseCopilotJson(p, buf.toString("utf8"), wsPath),
+                    };
+                }
+            }
+            // New format (2026-04+): workspaceStorage/<hash>/GitHub.copilot-chat/transcripts/<id>.jsonl
+            const transcriptsDir = join(wsDir, "GitHub.copilot-chat", "transcripts");
+            if (existsSync(transcriptsDir)) {
+                let tfiles = [];
+                try {
+                    tfiles = readdirSync(transcriptsDir, { withFileTypes: true });
+                }
+                catch {
+                    tfiles = [];
+                }
+                for (const f of tfiles) {
+                    if (!f.isFile() || !f.name.endsWith(".jsonl"))
+                        continue;
+                    const id = basename(f.name, ".jsonl");
+                    if (chatSessionIds.has(id))
+                        continue; // chatSessions/ wins for same workspace+sessionId
+                    const p = join(transcriptsDir, f.name);
+                    const st = statSync(p);
+                    if (st.size === 0)
+                        continue;
+                    const buf = readFileSync(p);
+                    const sha = createHash("sha256").update(buf).digest("hex");
+                    yield {
+                        sourcePath: p,
+                        sourceMtimeMs: st.mtimeMs,
+                        sourceSha256: sha,
+                        load: async () => parseCopilotTranscript(p, buf.toString("utf8"), wsPath),
+                    };
+                }
+            }
+        }
+    }
+}
+function readWorkspacePath(workspaceJsonPath) {
+    if (!existsSync(workspaceJsonPath))
+        return "";
+    try {
+        const obj = JSON.parse(readFileSync(workspaceJsonPath, "utf8"));
+        const u = obj.folder ?? obj.workspace ?? "";
+        if (!u)
+            return "";
+        return u.startsWith("file://") ? decodeURIComponent(u.slice("file://".length)) : u;
+    }
+    catch {
+        return "";
+    }
+}
+function parseCopilotJson(sourcePath, content, workspacePath) {
+    const obj = JSON.parse(content);
+    const fileBase = basename(sourcePath, ".json");
+    const sessionId = fileBase;
+    const requests = Array.isArray(obj.requests) ? obj.requests : [];
+    return buildSessionFromRequests(sourcePath, sessionId, requests, workspacePath);
+}
+/**
+ * chatSessions/<id>.jsonl is a *live state log* with a rolling-window snapshot
+ * pattern, NOT a complete conversation transcript. We discovered this on
+ * 2026-05-22 after vibebook 0.5/0.6 was found to only capture the LAST turn
+ * (~5–8% of the actual conversation) on multi-turn Copilot agent sessions.
+ *
+ * Event schema:
+ *   - kind=0 (first line): initial state with v.requests (usually `[]`).
+ *   - kind=1: replace top-level state path (e.g. inputState, responderUsername).
+ *     Not relevant to conversation turns; we ignore.
+ *   - kind=2 with k=["requests"]: VS Code's snapshot is a 1-element array
+ *     containing only the *latest* turn. But the conceptual `requests` array
+ *     grows monotonically across turns — subsequent patches reference
+ *     k=["requests", N, ...] where N is the chronological turn index (0, 1, 2…).
+ *     So we APPEND v[0] to our growing turns list rather than replacing.
+ *   - kind=2 with k=["requests", N, "response"]: REPLACE the response array of
+ *     turn N. Each patch is a full replacement (not a delta), so the last
+ *     such patch for any given N wins.
+ *   - kind=2 with k=["requests", N]: replace turn N entirely.
+ *   - kind=2 with k=["requests", N, ...deep path]: deep-set into turn N.
+ */
+function parseCopilotChatSessionsJsonl(sourcePath, content, workspacePath) {
+    const fileBase = basename(sourcePath, ".jsonl");
+    let sessionId = fileBase;
+    const turns = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        if (obj?.kind === 0 && obj?.v) {
+            if (typeof obj.v.sessionId === "string" && obj.v.sessionId)
+                sessionId = obj.v.sessionId;
+            if (Array.isArray(obj.v.requests)) {
+                // Initial state — seed turns from whatever was already in v.requests
+                for (const r of obj.v.requests)
+                    turns.push(r);
+            }
+            continue;
+        }
+        if (obj?.kind !== 2 || !Array.isArray(obj.k) || obj.k[0] !== "requests")
+            continue;
+        if (obj.k.length === 1 && Array.isArray(obj.v)) {
+            // Snapshot event. v is a rolling window (typically a single element).
+            // Append each element to grow our chronological turn list.
+            for (const r of obj.v)
+                turns.push(r);
+        }
+        else if (obj.k.length >= 2 && typeof obj.k[1] === "number") {
+            const idx = obj.k[1];
+            // Grow sparsely if the patch references a turn we haven't seen yet
+            // (defensive — in well-formed logs the snapshot precedes the patch).
+            while (turns.length <= idx)
+                turns.push({});
+            if (obj.k.length === 2) {
+                turns[idx] = obj.v;
+            }
+            else {
+                let cur = turns[idx];
+                if (cur === undefined || cur === null) {
+                    cur = {};
+                    turns[idx] = cur;
+                }
+                for (let i = 2; i < obj.k.length - 1; i++) {
+                    const seg = obj.k[i];
+                    if (cur[seg] === undefined)
+                        cur[seg] = typeof obj.k[i + 1] === "number" ? [] : {};
+                    cur = cur[seg];
+                }
+                cur[obj.k[obj.k.length - 1]] = obj.v;
+            }
+        }
+    }
+    return buildSessionFromRequests(sourcePath, sessionId, turns, workspacePath);
+}
+function buildSessionFromRequests(sourcePath, sessionId, requests, workspacePath) {
+    const messages = [];
+    let startedAt = "";
+    let endedAt = "";
+    for (const r of requests) {
+        if (!r)
+            continue;
+        const ts = typeof r.timestamp === "number" ? new Date(r.timestamp).toISOString() : undefined;
+        if (ts) {
+            if (!startedAt)
+                startedAt = ts;
+            endedAt = ts;
+        }
+        const userTextRaw = r?.message?.text;
+        if (typeof userTextRaw === "string" && userTextRaw) {
+            const userText = sanitizeMessageText(userTextRaw);
+            if (userText)
+                messages.push({ role: "user", text: userText, timestamp: ts, raw: r.message });
+        }
+        const respParts = Array.isArray(r.response) ? r.response : [];
+        const { text: rawText, reasoning: rawReasoning, contentBlocks } = extractCopilotResponseParts(respParts);
+        const text = sanitizeMessageText(rawText);
+        const reasoning = sanitizeMessageText(rawReasoning);
+        if (text || reasoning || contentBlocks.length > 0) {
+            const msg = { role: "assistant", text, timestamp: ts, raw: respParts };
+            if (reasoning)
+                msg.reasoning = reasoning;
+            if (contentBlocks.length > 0)
+                msg.contentBlocks = contentBlocks;
+            messages.push(msg);
+        }
+    }
+    const firstUser = messages.find((m) => m.role === "user")?.text ?? "";
+    const { slug, display } = deriveSlug(firstUser);
+    const shortId = sessionId.slice(0, 8);
+    return {
+        tool: "copilot",
+        sessionId,
+        shortId,
+        project: cachedProjectSlug(workspacePath),
+        projectRaw: workspacePath,
+        startedAt: startedAt || new Date(0).toISOString(),
+        endedAt: endedAt || new Date(0).toISOString(),
+        nameSlug: slug,
+        displayName: display,
+        messages,
+        sourcePath,
+    };
+}
+/**
+ * Pull text + reasoning + tool calls out of a Copilot response parts array.
+ *
+ * Response part kinds observed (chatSessions format):
+ *   - markdownContent → visible assistant text (.content.value)
+ *   - thinking        → reasoning (.value)
+ *   - toolInvocationSerialized → tool call (.toolId + .pastTenseMessage / .invocationMessage)
+ *   - textEditGroup, inlineReference, mcpServersStarting, progressTaskSerialized → UI noise, drop
+ *   - null / no-kind  → drop
+ *
+ * Tool *results* are NOT captured by VS Code in chatSessions — only the
+ * invocation marker. So tool blocks carry a placeholder result indicating
+ * the result is unavailable from the source.
+ */
+function extractCopilotResponseParts(parts) {
+    const texts = [];
+    const reasonings = [];
+    const blocks = [];
+    for (const p of parts) {
+        if (!p || typeof p !== "object")
+            continue;
+        const k = p.kind;
+        if (k === "markdownContent") {
+            const v = typeof p?.content?.value === "string" ? p.content.value : "";
+            if (v) {
+                texts.push(v);
+                blocks.push({ type: "text", text: v });
+            }
+        }
+        else if (k === "thinking") {
+            const v = typeof p?.value === "string" ? p.value : "";
+            if (v) {
+                reasonings.push(v);
+                blocks.push({ type: "thinking", thinking: v });
+            }
+        }
+        else if (k === "toolInvocationSerialized") {
+            const toolId = typeof p?.toolId === "string" ? p.toolId : "tool";
+            const past = p?.pastTenseMessage?.value;
+            const cur = p?.invocationMessage?.value;
+            const label = (typeof past === "string" && past) || (typeof cur === "string" && cur) || "";
+            const input = p?.toolSpecificData ?? {};
+            const block = { type: "tool_use", name: toolId, input };
+            if (typeof p?.toolCallId === "string")
+                block.id = p.toolCallId;
+            blocks.push(block);
+            if (label)
+                blocks.push({ type: "tool_result", content: label });
+        }
+        // textEditGroup / inlineReference / mcpServersStarting / progressTaskSerialized
+        // are UI / streaming-state noise and intentionally dropped.
+    }
+    return {
+        text: texts.join("\n"),
+        reasoning: reasonings.join("\n"),
+        contentBlocks: blocks,
+    };
+}
+function parseCopilotTranscript(sourcePath, content, workspacePath) {
+    const fileBase = basename(sourcePath, ".jsonl");
+    let sessionId = fileBase;
+    const messages = [];
+    let startedAt = "";
+    let endedAt = "";
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        const t = obj?.type;
+        const ts = typeof obj?.timestamp === "string" ? obj.timestamp : undefined;
+        if (ts) {
+            if (!startedAt)
+                startedAt = ts;
+            endedAt = ts;
+        }
+        if (t === "session.start") {
+            const sid = obj?.data?.sessionId;
+            if (typeof sid === "string" && sid)
+                sessionId = sid;
+            continue;
+        }
+        if (t === "user.message") {
+            const raw = typeof obj?.data?.content === "string" ? obj.data.content : "";
+            const text = sanitizeMessageText(raw);
+            if (text)
+                messages.push({ role: "user", text, timestamp: ts, raw: obj });
+            continue;
+        }
+        if (t === "assistant.message") {
+            const rawText = typeof obj?.data?.content === "string" ? obj.data.content : "";
+            const rawReasoning = typeof obj?.data?.reasoningText === "string" ? obj.data.reasoningText : "";
+            const text = sanitizeMessageText(rawText);
+            const reasoning = sanitizeMessageText(rawReasoning);
+            // tool requests are intentionally NOT included — memarium summarizes
+            // intent + outcome, not tool traces. Drop the message only when both
+            // text AND reasoning are empty.
+            if (text || reasoning) {
+                const msg = { role: "assistant", text, timestamp: ts, raw: obj };
+                if (reasoning)
+                    msg.reasoning = reasoning;
+                messages.push(msg);
+            }
+            continue;
+        }
+        if (t === "tool.execution_start" || t === "tool.execution_complete") {
+            // Drop tool execution events entirely — same rationale as above.
+            continue;
+        }
+    }
+    const firstUser = messages.find((m) => m.role === "user")?.text ?? "";
+    const { slug, display } = deriveSlug(firstUser);
+    const shortId = sessionId.slice(0, 8);
+    return {
+        tool: "copilot",
+        sessionId,
+        shortId,
+        project: cachedProjectSlug(workspacePath),
+        projectRaw: workspacePath,
+        startedAt: startedAt || new Date(0).toISOString(),
+        endedAt: endedAt || new Date(0).toISOString(),
+        nameSlug: slug,
+        displayName: display,
+        messages,
+        sourcePath,
+    };
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/writer.js

@@ -0,0 +1,240 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractManifest } from "./digest/manifest.js";
+import { buildTocEntries, renderTocMarkdown } from "./digest/toc.js";
+/** Threshold above which tool_result.content / tool_use.input gets truncated.
+ *  Empirical: a 20 KB code-fence in markdown is already large; tool outputs
+ *  bigger than this usually mean Claude Read a long file or Bash dumped a
+ *  build log — neither is high-value context for resume. The truncation
+ *  preserves first 30 + last 10 lines + a footer noting the original size. */
+export const TRUNCATE_THRESHOLD_BYTES = 20 * 1024;
+export function writeSession(repoRoot, s, opts = {}) {
+    const date = s.startedAt.slice(0, 10); // YYYY-MM-DD
+    const dirRel = join("raw_sessions", s.tool, s.project, date);
+    const absDir = join(repoRoot, dirRel);
+    mkdirSync(absDir, { recursive: true });
+    const base = `${s.nameSlug}__${s.shortId}`;
+    const mdRel = join(dirRel, `${base}.md`);
+    const includeReasoning = opts.includeReasoning ?? true;
+    const fullToolResults = opts.fullToolResults ?? process.env.MEMARIUM_FULL_TOOL_RESULTS === "1";
+    writeFileSync(join(repoRoot, mdRel), renderMarkdown(s, { includeReasoning, fullToolResults }));
+    return { md: mdRel };
+}
+/**
+ * Two-pass renderer:
+ *   Pass 1 — render each message to its own string, track per-message line
+ *     offsets RELATIVE TO body start.
+ *   Pass 2 — build the manifest (mechanical facts) and importance-based TOC
+ *     using those relative offsets. Compute the line count of the
+ *     `frontmatter + TOC + separator` prefix. Patch every `line:` field in
+ *     manifest + TOC by adding the prefix length so consumers can
+ *     `Read offset:line` into the final file and land on the right turn.
+ *   Emit: `<frontmatter incl. manifest>` → `<TOC block>` → `<body>`.
+ */
+function renderMarkdown(s, ctx) {
+    // Filter out messages that render to empty (keeps body indices aligned
+    // with what the consumer will actually see).
+    const renderedPerMessage = [];
+    for (const m of s.messages) {
+        const md = renderMessageBlock(m, ctx);
+        if (!md)
+            continue;
+        renderedPerMessage.push({ md, src: m });
+    }
+    // Body assembly + per-message line offsets relative to body start (1-based,
+    // matching how the `Read` tool reports line numbers).
+    //
+    // Math: a rendered message of `numLines` (split by `\n`) lines does NOT
+    // end with a trailing newline. After writing it the cursor sits at the
+    // end of line (currentLine + numLines - 1). Joining the next message with
+    // "\n\n" advances by 2 newlines: cursor → start of (currentLine + numLines)
+    // → empty line + start of (currentLine + numLines + 1). So the next
+    // message begins at currentLine + numLines + 1.
+    const bodyParts = [];
+    const messageLineOffsetsRelative = [];
+    let currentLine = 1;
+    for (let i = 0; i < renderedPerMessage.length; i++) {
+        messageLineOffsetsRelative.push(currentLine);
+        const md = renderedPerMessage[i].md;
+        bodyParts.push(md);
+        if (i < renderedPerMessage.length - 1) {
+            currentLine += md.split("\n").length + 1;
+        }
+    }
+    const body = bodyParts.join("\n\n");
+    // Build manifest + TOC against relative offsets.
+    const renderedMessages = renderedPerMessage.map((r) => r.src);
+    const manifestRel = extractManifest(renderedMessages, messageLineOffsetsRelative);
+    const tocRel = buildTocEntries(renderedMessages, messageLineOffsetsRelative);
+    // Render the prefix (frontmatter + TOC) with RELATIVE line numbers first so
+    // we can measure its true line count. Then re-render with offset-patched
+    // line numbers and emit.
+    const tocMdRel = renderTocMarkdown(tocRel);
+    const frontmatterRel = renderFrontmatter(s, manifestRel);
+    const tocSection = tocMdRel ? `\n\n${tocMdRel}` : "";
+    const prefixRel = frontmatterRel + tocSection + "\n\n";
+    const prefixLineCount = prefixRel.split("\n").length - 1;
+    // -1 because the trailing "\n\n" puts the body's first line at the line
+    // *after* the empty separator line; the body's "line 1" sits at exactly
+    // `prefixLineCount + 1` in the final file.
+    const manifest = patchManifestLines(manifestRel, prefixLineCount);
+    const toc = tocRel.map((e) => ({ ...e, line: e.line + prefixLineCount }));
+    const frontmatter = renderFrontmatter(s, manifest);
+    const tocMd = renderTocMarkdown(toc);
+    return [frontmatter, tocMd, body].filter(Boolean).join("\n\n");
+}
+function patchManifestLines(m, offset) {
+    return {
+        ...m,
+        commits: m.commits.map((c) => ({ ...c, line: c.line + offset })),
+        candidate_decisions: m.candidate_decisions.map((d) => ({ ...d, line: d.line + offset })),
+    };
+}
+function renderFrontmatter(s, m) {
+    const lines = [
+        "---",
+        `sessionId: ${s.sessionId}`,
+        `tool: ${s.tool}`,
+        `project: ${s.project}`,
+        `projectRaw: ${s.projectRaw}`,
+        `startedAt: ${s.startedAt}`,
+        `endedAt: ${s.endedAt}`,
+        `displayName: ${yamlSafeString(s.displayName)}`,
+        `manifest_version: 1`,
+        `user_turns: ${m.user_turns}`,
+        `assistant_turns: ${m.assistant_turns}`,
+        ...renderToolsUsed(m.tools_used),
+        ...renderCommits(m.commits),
+        ...renderFilesTouched(m.files_touched),
+        ...renderCandidateDecisions(m.candidate_decisions),
+        "---",
+    ];
+    return lines.join("\n");
+}
+function renderToolsUsed(t) {
+    const entries = Object.entries(t).sort((a, b) => b[1] - a[1]);
+    if (entries.length === 0)
+        return ["tools_used: {}"];
+    return ["tools_used:", ...entries.map(([k, v]) => `  ${yamlSafeKey(k)}: ${v}`)];
+}
+function renderCommits(commits) {
+    if (commits.length === 0)
+        return ["commits: []"];
+    return [
+        "commits:",
+        ...commits.map((c) => `  - { sha: ${yamlSafeString(c.sha)}, msg: ${yamlSafeString(c.msg)}, line: ${c.line} }`),
+    ];
+}
+function renderFilesTouched(files) {
+    if (files.length === 0)
+        return ["files_touched: []"];
+    return [
+        "files_touched:",
+        ...files.map((f) => `  - ${yamlSafeString(f)}`),
+    ];
+}
+function renderCandidateDecisions(decisions) {
+    if (decisions.length === 0)
+        return ["candidate_decisions: []"];
+    return [
+        "candidate_decisions:",
+        ...decisions.map((d) => `  - { line: ${d.line}, preview: ${yamlSafeString(d.preview)} }`),
+    ];
+}
+/** YAML-safe one-line string. If the value contains anything quoting-hostile
+ *  (colons, hash, special chars, leading/trailing whitespace, or any quote),
+ *  wrap in single quotes and escape internal single quotes by doubling them
+ *  (YAML 1.2 spec). */
+function yamlSafeString(s) {
+    if (/^[A-Za-z0-9_一-鿿　-〿 -]+$/.test(s) && s === s.trim())
+        return s;
+    const escaped = s.replace(/'/g, "''");
+    return `'${escaped}'`;
+}
+/** YAML-safe object key. Tool names contain only letters/digits/`_`, but be
+ *  defensive: anything outside the safe set gets single-quoted. */
+function yamlSafeKey(s) {
+    if (/^[A-Za-z0-9_-]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, "''")}'`;
+}
+function renderMessageBlock(m, ctx) {
+    const heading = m.role === "user" ? "## User" :
+        m.role === "assistant" ? "## Assistant" :
+            `## ${m.role}`;
+    const ts = m.timestamp ? ` _(${m.timestamp})_` : "";
+    const rendered = renderMessageContent(m.contentBlocks, m.text, m.reasoning, ctx);
+    if (!rendered.trim())
+        return "";
+    return `${heading}${ts}\n\n${rendered}`;
+}
+function renderMessageContent(blocks, fallbackText, fallbackReasoning, ctx) {
+    // Path 1: rich content blocks available (Claude source, post-Task 2)
+    if (blocks && blocks.length > 0) {
+        const out = [];
+        for (const b of blocks) {
+            if (b.type === "thinking") {
+                if (!ctx.includeReasoning)
+                    continue;
+                out.push(renderThinking(b.thinking));
+            }
+            else if (b.type === "text") {
+                if (b.text.trim())
+                    out.push(b.text);
+            }
+            else if (b.type === "tool_use") {
+                out.push(renderToolUse(b, ctx));
+            }
+            else if (b.type === "tool_result") {
+                out.push(renderToolResult(b, ctx));
+            }
+        }
+        return out.join("\n\n");
+    }
+    // Path 2: legacy text-only message (Copilot source, or pre-Task 2 callers)
+    const out = [];
+    if (ctx.includeReasoning && fallbackReasoning) {
+        out.push(renderThinking(fallbackReasoning));
+    }
+    if (fallbackText)
+        out.push(fallbackText);
+    return out.join("\n\n");
+}
+function renderThinking(text) {
+    const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
+    return `> 💭 _thinking_\n${quoted}`;
+}
+function renderToolUse(b, ctx) {
+    const inputStr = JSON.stringify(b.input, null, 2);
+    const truncated = ctx.fullToolResults
+        ? inputStr
+        : maybeTruncate(inputStr, "input");
+    return `### 🔧 tool_use: ${b.name}\n\n\`\`\`json\n${truncated}\n\`\`\``;
+}
+function renderToolResult(b, ctx) {
+    const truncated = ctx.fullToolResults
+        ? b.content
+        : maybeTruncate(b.content, "output");
+    return `### ✅ tool_result\n\n\`\`\`\n${truncated}\n\`\`\``;
+}
+/** Truncate strings above TRUNCATE_THRESHOLD_BYTES. Preserves first 30 lines
+ *  + last 10 lines so the LLM still gets enough signal about what was read /
+ *  output, without dragging multi-MB file dumps into the context.
+ *
+ *  Returns the original string unchanged if under threshold. */
+function maybeTruncate(s, kind) {
+    if (Buffer.byteLength(s, "utf8") <= TRUNCATE_THRESHOLD_BYTES)
+        return s;
+    const lines = s.split("\n");
+    if (lines.length <= 50) {
+        // Single long line — truncate by character count
+        const head = s.slice(0, 4000);
+        const tail = s.slice(-1000);
+        return `${head}\n\n[... truncated: ${(Buffer.byteLength(s, "utf8") / 1024).toFixed(1)} KB total, showing first 4000 + last 1000 chars ...]\n\n${tail}`;
+    }
+    const head = lines.slice(0, 30).join("\n");
+    const tail = lines.slice(-10).join("\n");
+    const omitted = lines.length - 40;
+    const sizeKb = (Buffer.byteLength(s, "utf8") / 1024).toFixed(1);
+    return `${head}\n\n[... truncated: ${sizeKb} KB ${kind}, omitting ${omitted} middle lines ...]\n\n${tail}`;
+}