gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.9bafd68

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -0,0 +1,130 @@
+/**
+ * Expand dependency shorthand into individual slice IDs.
+ *
+ * Handles two common LLM-generated patterns that the roadmap parser
+ * previously treated as single literal IDs (silently blocking slices):
+ *
+ *   "S01-S04"  → ["S01", "S02", "S03", "S04"]  (range syntax)
+ *   "S01..S04" → ["S01", "S02", "S03", "S04"]  (dot-range syntax)
+ *
+ * Plain IDs ("S01", "S02") and empty strings pass through unchanged.
+ */
+export function expandDependencies(deps) {
+    const result = [];
+    for (const dep of deps) {
+        const trimmed = dep.trim();
+        if (!trimmed)
+            continue;
+        // Match range syntax: S01-S04 or S01..S04 (case-insensitive prefix)
+        const rangeMatch = trimmed.match(/^([A-Za-z]+)(\d+)(?:-|\.\.)+([A-Za-z]+)(\d+)$/);
+        if (rangeMatch) {
+            const prefixA = rangeMatch[1].toUpperCase();
+            const startNum = parseInt(rangeMatch[2], 10);
+            const prefixB = rangeMatch[3].toUpperCase();
+            const endNum = parseInt(rangeMatch[4], 10);
+            // Only expand when both prefixes match and range is valid
+            if (prefixA === prefixB && startNum <= endNum) {
+                const width = rangeMatch[2].length; // preserve zero-padding (S01 not S1)
+                for (let i = startNum; i <= endNum; i++) {
+                    result.push(`${prefixA}${String(i).padStart(width, "0")}`);
+                }
+                continue;
+            }
+        }
+        result.push(trimmed);
+    }
+    return result;
+}
+function extractSlicesSection(content) {
+    const headingMatch = /^## Slices\b.*$/m.exec(content);
+    if (!headingMatch || headingMatch.index == null)
+        return "";
+    const start = headingMatch.index + headingMatch[0].length;
+    const rest = content.slice(start).replace(/^\r?\n/, "");
+    const nextHeading = /^##\s+/m.exec(rest);
+    return (nextHeading ? rest.slice(0, nextHeading.index) : rest).trimEnd();
+}
+export function parseRoadmapSlices(content) {
+    const slicesSection = extractSlicesSection(content);
+    const slices = [];
+    if (!slicesSection) {
+        // Fallback: detect prose-style slice headers (## Slice S01: Title)
+        // when the LLM writes freeform prose instead of the ## Slices checklist.
+        // This prevents a permanent "No slice eligible" block (#807).
+        return parseProseSliceHeaders(content);
+    }
+    const checkboxItems = slicesSection.split("\n");
+    let currentSlice = null;
+    for (const line of checkboxItems) {
+        const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
+        if (cbMatch) {
+            if (currentSlice)
+                slices.push(currentSlice);
+            const done = cbMatch[1].toLowerCase() === "x";
+            const id = cbMatch[2];
+            const title = cbMatch[3];
+            const rest = cbMatch[4] ?? "";
+            const riskMatch = rest.match(/`risk:(\w+)`/);
+            const risk = (riskMatch ? riskMatch[1] : "low");
+            const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
+            const depends = depsMatch && depsMatch[1].trim()
+                ? expandDependencies(depsMatch[1].split(",").map(s => s.trim()))
+                : [];
+            currentSlice = { id, title, risk, depends, done, demo: "" };
+            continue;
+        }
+        if (currentSlice && line.trim().startsWith(">")) {
+            currentSlice.demo = line.trim().replace(/^>\s*/, "").replace(/^After this:\s*/i, "");
+        }
+    }
+    if (currentSlice)
+        slices.push(currentSlice);
+    return slices;
+}
+/**
+ * Fallback parser for prose-style roadmaps where the LLM wrote
+ * slice headers instead of the machine-readable `## Slices` checklist.
+ * Extracts slice IDs and titles so auto-mode can at least identify
+ * slices and plan them.
+ *
+ * Handles these LLM-generated variants:
+ *   ## S01: Title           (H2, colon separator)
+ *   ### S01: Title          (H3)
+ *   #### S01: Title         (H4)
+ *   ## Slice S01: Title     (with "Slice" prefix)
+ *   ## S01 — Title          (em dash)
+ *   ## S01 – Title          (en dash)
+ *   ## S01 - Title          (hyphen)
+ *   ## S01. Title           (dot separator)
+ *   ## S01 Title            (space only, no separator)
+ *   ## **S01: Title**       (bold-wrapped)
+ *   ## **S01**: Title       (bold ID only)
+ *   ## S1: Title            (non-zero-padded ID)
+ */
+function parseProseSliceHeaders(content) {
+    const slices = [];
+    // Match H1–H4 headers containing S<digits> with optional "Slice" prefix and bold markers.
+    // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
+    const headerPattern = /^#{1,4}\s+\*{0,2}(?:Slice\s+)?(S\d+)\*{0,2}[:\s.—–-]*\s*(.+)/gm;
+    let match;
+    while ((match = headerPattern.exec(content)) !== null) {
+        const id = match[1];
+        let title = match[2].trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
+        if (!title)
+            continue; // skip if we only matched the ID with no title
+        // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
+        const afterHeader = content.slice(match.index + match[0].length);
+        const nextHeader = afterHeader.search(/^#{1,4}\s/m);
+        const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
+        const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
+        let depends = [];
+        if (depsMatch) {
+            const rawDeps = depsMatch[1].replace(/none/i, "").trim();
+            if (rawDeps) {
+                depends = expandDependencies(rawDeps.split(/[,;]/).map(s => s.trim().replace(/[^A-Za-z0-9]/g, "")).filter(Boolean));
+            }
+        }
+        slices.push({ id, title, risk: "medium", depends, done: false, demo: "" });
+    }
+    return slices;
+}

package/dist/resources/extensions/gsd/routing-history.js

@@ -0,0 +1,210 @@
+// GSD Extension — Routing History (Adaptive Learning)
+// Tracks success/failure per tier per unit-type pattern to improve
+// classification accuracy over time.
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { loadJsonFile, saveJsonFile } from "./json-persistence.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+const HISTORY_FILE = "routing-history.json";
+const ROLLING_WINDOW = 50; // only consider last N entries per pattern
+const FAILURE_THRESHOLD = 0.20; // >20% failure rate triggers tier bump
+const FEEDBACK_WEIGHT = 2; // feedback signals count 2x vs automatic
+// ─── In-Memory State ─────────────────────────────────────────────────────────
+let history = null;
+let historyBasePath = "";
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Initialize routing history for a project.
+ */
+export function initRoutingHistory(base) {
+    historyBasePath = base;
+    history = loadHistory(base);
+}
+/**
+ * Reset routing history state.
+ */
+export function resetRoutingHistory() {
+    history = null;
+    historyBasePath = "";
+}
+/**
+ * Record the outcome of a unit dispatch.
+ *
+ * @param unitType  The unit type (e.g. "execute-task")
+ * @param tier      The tier that was used
+ * @param success   Whether the unit completed successfully
+ * @param tags      Optional tags from task metadata (e.g. ["docs", "test"])
+ */
+export function recordOutcome(unitType, tier, success, tags) {
+    if (!history)
+        return;
+    // Record for the base unit type
+    const basePattern = unitType;
+    ensurePattern(basePattern);
+    const outcome = history.patterns[basePattern][tier];
+    if (success)
+        outcome.success++;
+    else
+        outcome.fail++;
+    // Record for tag-specific patterns (e.g. "execute-task:docs")
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            const tagPattern = `${unitType}:${tag}`;
+            ensurePattern(tagPattern);
+            const tagOutcome = history.patterns[tagPattern][tier];
+            if (success)
+                tagOutcome.success++;
+            else
+                tagOutcome.fail++;
+        }
+    }
+    // Apply rolling window — cap total entries per tier per pattern
+    for (const pattern of Object.keys(history.patterns)) {
+        const p = history.patterns[pattern];
+        for (const t of ["light", "standard", "heavy"]) {
+            const total = p[t].success + p[t].fail;
+            if (total > ROLLING_WINDOW) {
+                const scale = ROLLING_WINDOW / total;
+                p[t].success = Math.round(p[t].success * scale);
+                p[t].fail = Math.round(p[t].fail * scale);
+            }
+        }
+    }
+    history.updatedAt = new Date().toISOString();
+    saveHistory(historyBasePath, history);
+}
+/**
+ * Record user feedback for the last completed unit.
+ */
+export function recordFeedback(unitType, unitId, tier, rating) {
+    if (!history)
+        return;
+    history.feedback.push({
+        unitType,
+        unitId,
+        tier,
+        rating,
+        timestamp: new Date().toISOString(),
+    });
+    // Cap feedback array at 200 entries
+    if (history.feedback.length > 200) {
+        history.feedback = history.feedback.slice(-200);
+    }
+    // Apply feedback as weighted outcome
+    const pattern = unitType;
+    ensurePattern(pattern);
+    if (rating === "over") {
+        // User says this could have used a simpler model → record as success at current tier
+        // and also as success at one tier lower (encourages more downgrading)
+        const lower = tierBelow(tier);
+        if (lower) {
+            const outcomes = history.patterns[pattern][lower];
+            outcomes.success += FEEDBACK_WEIGHT;
+        }
+    }
+    else if (rating === "under") {
+        // User says this needed a better model → record as failure at current tier
+        const outcomes = history.patterns[pattern][tier];
+        outcomes.fail += FEEDBACK_WEIGHT;
+    }
+    // "ok" = no adjustment needed
+    history.updatedAt = new Date().toISOString();
+    saveHistory(historyBasePath, history);
+}
+/**
+ * Get the recommended tier adjustment for a given pattern.
+ * Returns the tier to bump to if the failure rate exceeds threshold,
+ * or null if no adjustment is needed.
+ */
+export function getAdaptiveTierAdjustment(unitType, currentTier, tags) {
+    if (!history)
+        return null;
+    // Check tag-specific patterns first (more specific)
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            const tagPattern = `${unitType}:${tag}`;
+            const adjustment = checkPatternFailureRate(tagPattern, currentTier);
+            if (adjustment)
+                return adjustment;
+        }
+    }
+    // Fall back to base pattern
+    return checkPatternFailureRate(unitType, currentTier);
+}
+/**
+ * Clear all routing history (user-triggered reset).
+ */
+export function clearRoutingHistory(base) {
+    history = createEmptyHistory();
+    saveHistory(base, history);
+}
+/**
+ * Get current history data (for display/debugging).
+ */
+export function getRoutingHistory() {
+    return history;
+}
+// ─── Internal ────────────────────────────────────────────────────────────────
+function checkPatternFailureRate(pattern, tier) {
+    if (!history?.patterns[pattern])
+        return null;
+    const outcomes = history.patterns[pattern][tier];
+    const total = outcomes.success + outcomes.fail;
+    if (total < 3)
+        return null; // Not enough data
+    const failureRate = outcomes.fail / total;
+    if (failureRate > FAILURE_THRESHOLD) {
+        // Bump to next tier
+        return tierAbove(tier);
+    }
+    return null;
+}
+function tierAbove(tier) {
+    switch (tier) {
+        case "light": return "standard";
+        case "standard": return "heavy";
+        case "heavy": return null;
+    }
+}
+function tierBelow(tier) {
+    switch (tier) {
+        case "light": return null;
+        case "standard": return "light";
+        case "heavy": return "standard";
+    }
+}
+function ensurePattern(pattern) {
+    if (!history)
+        return;
+    if (!history.patterns[pattern]) {
+        history.patterns[pattern] = {
+            light: { success: 0, fail: 0 },
+            standard: { success: 0, fail: 0 },
+            heavy: { success: 0, fail: 0 },
+        };
+    }
+}
+function createEmptyHistory() {
+    return {
+        version: 1,
+        patterns: {},
+        feedback: [],
+        updatedAt: new Date().toISOString(),
+    };
+}
+function historyPath(base) {
+    return join(gsdRoot(base), HISTORY_FILE);
+}
+function isRoutingHistoryData(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        data.version === 1 &&
+        typeof data.patterns === "object" &&
+        data.patterns !== null);
+}
+function loadHistory(base) {
+    return loadJsonFile(historyPath(base), isRoutingHistoryData, createEmptyHistory);
+}
+function saveHistory(base, data) {
+    saveJsonFile(historyPath(base), data);
+}

package/dist/resources/extensions/gsd/safe-fs.js

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, cpSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Safely creates a directory. Returns true if successful, false on error.
+ * Logs to stderr when GSD_DEBUG is set.
+ */
+export function safeMkdir(dirPath) {
+    try {
+        mkdirSync(dirPath, { recursive: true });
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] mkdir failed: ${dirPath}`, err);
+        return false;
+    }
+}
+/**
+ * Safely copies src to dst. Returns true if successful, false if src doesn't exist or copy fails.
+ * Logs to stderr when GSD_DEBUG is set.
+ */
+export function safeCopy(src, dst, opts) {
+    if (!existsSync(src))
+        return false;
+    try {
+        cpSync(src, dst, opts);
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] copy failed: ${src} → ${dst}`, err);
+        return false;
+    }
+}
+/**
+ * Safely copies a directory recursively, creating the parent of dst if needed.
+ * Returns true if successful.
+ */
+export function safeCopyRecursive(src, dst, opts) {
+    if (!existsSync(src))
+        return false;
+    try {
+        mkdirSync(dirname(dst), { recursive: true });
+        cpSync(src, dst, { ...opts, recursive: true });
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] recursive copy failed: ${src} → ${dst}`, err);
+        return false;
+    }
+}

package/dist/resources/extensions/gsd/semantic-chunker.js

@@ -0,0 +1,254 @@
+// GSD Extension — Semantic Chunker with TF-IDF Relevance Scoring
+// Splits code/text into semantic chunks and selects the most relevant ones for a given task.
+// Pure TypeScript — no external dependencies.
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CODE_BOUNDARY_RE = /^(export\s+)?(async\s+)?(function|class|interface|type|const|enum)\s/;
+const MARKDOWN_HEADING_RE = /^#{1,6}\s/;
+const STOP_WORDS = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "to", "of", "in",
+    "for", "on", "with", "at", "by", "from", "this", "that", "it", "as",
+    "or", "and", "not", "but", "if", "do", "no", "so", "up", "its", "has",
+    "had", "get", "set", "can", "may", "all", "use", "new", "one", "two",
+    "also", "each", "than", "been", "into", "most", "only", "over", "such",
+    "how", "some", "any", "our", "his", "her", "out", "did", "let", "say", "she",
+]);
+const DEFAULT_MIN_LINES = 3;
+const DEFAULT_MAX_LINES = 80;
+const DEFAULT_MAX_CHUNKS = 5;
+const DEFAULT_MIN_SCORE = 0.1;
+function detectContentType(lines) {
+    let codeSignals = 0;
+    let mdSignals = 0;
+    const sampleSize = Math.min(lines.length, 50);
+    for (let i = 0; i < sampleSize; i++) {
+        const line = lines[i];
+        if (CODE_BOUNDARY_RE.test(line) || /^\s*import\s/.test(line)) {
+            codeSignals++;
+        }
+        if (MARKDOWN_HEADING_RE.test(line)) {
+            mdSignals++;
+        }
+    }
+    if (mdSignals >= 2 && mdSignals > codeSignals)
+        return "markdown";
+    if (codeSignals >= 2)
+        return "code";
+    return "text";
+}
+// ─── Tokenizer ──────────────────────────────────────────────────────────────
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[\s\W]+/)
+        .filter((w) => w.length >= 2 && !STOP_WORDS.has(w));
+}
+// ─── splitIntoChunks ────────────────────────────────────────────────────────
+export function splitIntoChunks(content, options) {
+    if (!content || content.trim().length === 0)
+        return [];
+    const minLines = options?.minLines ?? DEFAULT_MIN_LINES;
+    const maxLines = options?.maxLines ?? DEFAULT_MAX_LINES;
+    const lines = content.split("\n");
+    if (lines.length === 0)
+        return [];
+    const contentType = detectContentType(lines);
+    let boundaries;
+    switch (contentType) {
+        case "code":
+            boundaries = findCodeBoundaries(lines);
+            break;
+        case "markdown":
+            boundaries = findMarkdownBoundaries(lines);
+            break;
+        default:
+            boundaries = findTextBoundaries(lines);
+            break;
+    }
+    // Always include 0 as first boundary
+    if (boundaries.length === 0 || boundaries[0] !== 0) {
+        boundaries.unshift(0);
+    }
+    // Build raw chunks from boundaries
+    const rawChunks = [];
+    for (let i = 0; i < boundaries.length; i++) {
+        const start = boundaries[i];
+        const end = i + 1 < boundaries.length ? boundaries[i + 1] - 1 : lines.length - 1;
+        const chunkLines = lines.slice(start, end + 1);
+        rawChunks.push({
+            content: chunkLines.join("\n"),
+            startLine: start + 1, // 1-based
+            endLine: end + 1, // 1-based
+            score: 0,
+        });
+    }
+    // Split oversized chunks at maxLines
+    const splitChunks = [];
+    for (const chunk of rawChunks) {
+        const chunkLineCount = chunk.endLine - chunk.startLine + 1;
+        if (chunkLineCount <= maxLines) {
+            splitChunks.push(chunk);
+        }
+        else {
+            const chunkLines = chunk.content.split("\n");
+            for (let offset = 0; offset < chunkLines.length; offset += maxLines) {
+                const slice = chunkLines.slice(offset, offset + maxLines);
+                splitChunks.push({
+                    content: slice.join("\n"),
+                    startLine: chunk.startLine + offset,
+                    endLine: chunk.startLine + offset + slice.length - 1,
+                    score: 0,
+                });
+            }
+        }
+    }
+    // Merge tiny chunks into predecessor
+    const merged = [];
+    for (const chunk of splitChunks) {
+        const chunkLineCount = chunk.endLine - chunk.startLine + 1;
+        if (chunkLineCount < minLines && merged.length > 0) {
+            const prev = merged[merged.length - 1];
+            prev.content += "\n" + chunk.content;
+            prev.endLine = chunk.endLine;
+        }
+        else {
+            merged.push({ ...chunk });
+        }
+    }
+    return merged;
+}
+function findCodeBoundaries(lines) {
+    const boundaries = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (CODE_BOUNDARY_RE.test(lines[i])) {
+            // Also consider a blank line before a boundary marker
+            if (i > 0 && lines[i - 1].trim() === "" && !boundaries.includes(i)) {
+                boundaries.push(i);
+            }
+            else if (!boundaries.includes(i)) {
+                boundaries.push(i);
+            }
+        }
+    }
+    return boundaries;
+}
+function findMarkdownBoundaries(lines) {
+    const boundaries = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (MARKDOWN_HEADING_RE.test(lines[i])) {
+            boundaries.push(i);
+        }
+    }
+    return boundaries;
+}
+function findTextBoundaries(lines) {
+    const boundaries = [0];
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i - 1].trim() === "" && lines[i].trim() !== "") {
+            boundaries.push(i);
+        }
+    }
+    return boundaries;
+}
+// ─── scoreChunks ────────────────────────────────────────────────────────────
+export function scoreChunks(chunks, query) {
+    if (chunks.length === 0)
+        return [];
+    const queryTerms = tokenize(query);
+    if (queryTerms.length === 0) {
+        return chunks.map((c) => ({ ...c, score: 0 }));
+    }
+    const totalChunks = chunks.length;
+    // Pre-compute IDF for each query term
+    const termChunkCounts = new Map();
+    const chunkTokenSets = [];
+    for (const chunk of chunks) {
+        const tokens = new Set(tokenize(chunk.content));
+        chunkTokenSets.push(tokens);
+        for (const term of queryTerms) {
+            if (tokens.has(term)) {
+                termChunkCounts.set(term, (termChunkCounts.get(term) ?? 0) + 1);
+            }
+        }
+    }
+    const idf = new Map();
+    for (const term of queryTerms) {
+        const df = termChunkCounts.get(term) ?? 0;
+        idf.set(term, Math.log(1 + totalChunks / (1 + df)));
+    }
+    // Score each chunk
+    const scored = chunks.map((chunk, idx) => {
+        const chunkTokens = tokenize(chunk.content);
+        const totalTerms = chunkTokens.length;
+        if (totalTerms === 0)
+            return { ...chunk, score: 0 };
+        // Count term frequencies
+        const termFreq = new Map();
+        for (const token of chunkTokens) {
+            termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+        }
+        let score = 0;
+        for (const term of queryTerms) {
+            const tf = (termFreq.get(term) ?? 0) / totalTerms;
+            const termIdf = idf.get(term) ?? 0;
+            score += tf * termIdf;
+        }
+        return { ...chunk, score };
+    });
+    // Normalize to 0-1
+    const maxScore = Math.max(...scored.map((c) => c.score));
+    if (maxScore > 0) {
+        for (const chunk of scored) {
+            chunk.score = chunk.score / maxScore;
+        }
+    }
+    return scored;
+}
+// ─── chunkByRelevance ───────────────────────────────────────────────────────
+export function chunkByRelevance(content, query, options) {
+    const maxChunks = options?.maxChunks ?? DEFAULT_MAX_CHUNKS;
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const minLines = options?.minChunkLines ?? DEFAULT_MIN_LINES;
+    const maxLines = options?.maxChunkLines ?? DEFAULT_MAX_LINES;
+    const rawChunks = splitIntoChunks(content, { minLines, maxLines });
+    if (rawChunks.length === 0) {
+        return { chunks: [], totalChunks: 0, omittedChunks: 0, savingsPercent: 0 };
+    }
+    const scored = scoreChunks(rawChunks, query);
+    // Filter by minScore and take top maxChunks by score
+    const qualifying = scored
+        .filter((c) => c.score >= minScore)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxChunks);
+    // Return in original document order (by startLine)
+    const selected = qualifying.sort((a, b) => a.startLine - b.startLine);
+    const totalChars = content.length;
+    const selectedChars = selected.reduce((sum, c) => sum + c.content.length, 0);
+    const savingsPercent = totalChars > 0
+        ? Math.round(((totalChars - selectedChars) / totalChars) * 100)
+        : 0;
+    return {
+        chunks: selected,
+        totalChunks: rawChunks.length,
+        omittedChunks: rawChunks.length - selected.length,
+        savingsPercent: Math.max(0, savingsPercent),
+    };
+}
+// ─── formatChunks ───────────────────────────────────────────────────────────
+export function formatChunks(result, filePath) {
+    if (result.chunks.length === 0) {
+        return `[${filePath}: empty or no relevant chunks]`;
+    }
+    const parts = [];
+    let lastEndLine = 0;
+    for (const chunk of result.chunks) {
+        // Show omission gap
+        if (lastEndLine > 0 && chunk.startLine > lastEndLine + 1) {
+            const gapLines = chunk.startLine - lastEndLine - 1;
+            parts.push(`[...${gapLines} lines omitted...]`);
+        }
+        parts.push(`[Lines ${chunk.startLine}-${chunk.endLine}]`);
+        parts.push(chunk.content);
+        lastEndLine = chunk.endLine;
+    }
+    return parts.join("\n");
+}