byterover-cli 3.5.1 → 3.6.0

package/dist/server/infra/dream/operations/prune.js

@@ -0,0 +1,362 @@
+/**
+ * Prune operation — identifies and archives stale/low-value context tree files.
+ *
+ * Flow:
+ * 1. Find candidates via two signals:
+ *    A) Archive service importance decay (draft files with importance < 35)
+ *    B) Mtime staleness (draft: 60 days, validated: 120 days, core: never)
+ * 2. Merge + dedup candidates, cap at 20 (stalest first)
+ * 3. Single LLM call to review candidates (ARCHIVE / KEEP / MERGE_INTO)
+ * 4. Execute decisions: archive, bump mtime, or defer merge
+ *
+ * Never throws — returns empty array on errors.
+ */
+import { readdir, readFile, stat, utimes } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isExcludedFromSync } from '../../context-tree/derived-artifact.js';
+import { toUnixPath } from '../../context-tree/path-utils.js';
+import { PruneResponseSchema } from '../dream-response-schemas.js';
+import { parseDreamResponse } from '../parse-dream-response.js';
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const MAX_CANDIDATES = 20;
+const DRAFT_STALE_DAYS = 60;
+const VALIDATED_STALE_DAYS = 120;
+/**
+ * Run pruning on the context tree.
+ * Returns DreamOperation results (never throws).
+ */
+export async function prune(deps) {
+    if (deps.signal?.aborted)
+        return [];
+    try {
+        // Step 1: Find candidates from both signals
+        const candidates = await findCandidates(deps);
+        if (candidates.length === 0)
+            return [];
+        // Step 2: LLM review
+        const decisions = await llmReview(candidates, deps);
+        if (decisions.length === 0)
+            return [];
+        // Step 3: Execute decisions
+        return await executeDecisions(decisions, candidates, deps);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Step 1: Find candidates ────────────────────────────────────────────────
+async function findCandidates(deps) {
+    const candidateMap = new Map();
+    const now = Date.now();
+    // Signal A: archive service importance decay
+    try {
+        const importancePaths = await deps.archiveService.findArchiveCandidates(deps.projectRoot);
+        const infoResults = await Promise.all(importancePaths.map(async (path) => ({ info: await readCandidateInfo(deps.contextTreeDir, path, now), path })));
+        for (const { info, path } of infoResults) {
+            if (info && info.maturity !== 'core') {
+                candidateMap.set(path, { ...info, signal: 'importance' });
+            }
+        }
+    }
+    catch {
+        // Archive service failure — continue with Signal B only
+    }
+    // Signal B: mtime staleness
+    try {
+        const stalePaths = await findStaleFiles(deps.contextTreeDir, now);
+        for (const { info, path } of stalePaths) {
+            if (candidateMap.has(path)) {
+                // Already found by Signal A — mark as both
+                const existing = candidateMap.get(path);
+                if (existing)
+                    candidateMap.set(path, { ...existing, signal: 'both' });
+            }
+            else {
+                candidateMap.set(path, { ...info, signal: 'mtime' });
+            }
+        }
+    }
+    catch {
+        // Walk failure — continue with whatever Signal A found
+    }
+    // Cap at 20, stalest first
+    const candidates = [...candidateMap.values()];
+    candidates.sort((a, b) => b.daysSinceModified - a.daysSinceModified);
+    return candidates.slice(0, MAX_CANDIDATES);
+}
+async function readCandidateInfo(contextTreeDir, relativePath, now) {
+    try {
+        const fullPath = join(contextTreeDir, relativePath);
+        const content = await readFile(fullPath, 'utf8');
+        const fileStat = await stat(fullPath);
+        const daysSinceModified = (now - fileStat.mtimeMs) / MS_PER_DAY;
+        return {
+            daysSinceModified,
+            importance: extractImportance(content),
+            maturity: extractMaturity(content),
+            path: relativePath,
+            signal: 'importance',
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function findStaleFiles(contextTreeDir, now) {
+    const results = [];
+    await walkMdFiles(contextTreeDir, async (relativePath, fullPath) => {
+        try {
+            const content = await readFile(fullPath, 'utf8');
+            const maturity = extractMaturity(content);
+            // core files NEVER pruned
+            if (maturity === 'core')
+                return;
+            const threshold = maturity === 'validated' ? VALIDATED_STALE_DAYS : DRAFT_STALE_DAYS;
+            const fileStat = await stat(fullPath);
+            const daysSinceModified = (now - fileStat.mtimeMs) / MS_PER_DAY;
+            if (daysSinceModified >= threshold) {
+                results.push({
+                    info: {
+                        daysSinceModified,
+                        importance: extractImportance(content),
+                        maturity,
+                        path: relativePath,
+                        signal: 'mtime',
+                    },
+                    path: relativePath,
+                });
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    });
+    return results;
+}
+/** Walk active .md files in the context tree, skipping _/. dirs, _ prefixed files, and derived artifacts. */
+async function walkMdFiles(contextTreeDir, callback) {
+    async function walk(currentDir) {
+        let entries;
+        try {
+            entries = (await readdir(currentDir, { withFileTypes: true })).map((e) => ({
+                isDirectory: () => e.isDirectory(),
+                isFile: () => e.isFile(),
+                name: String(e.name),
+            }));
+        }
+        catch {
+            return;
+        }
+        /* eslint-disable no-await-in-loop */
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('_') || entry.name.startsWith('.'))
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md') && !entry.name.startsWith('_')) {
+                const relativePath = toUnixPath(fullPath.slice(contextTreeDir.length + 1));
+                if (isExcludedFromSync(relativePath))
+                    continue;
+                await callback(relativePath, fullPath);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+    }
+    await walk(contextTreeDir);
+}
+// ── Step 2: LLM review ────────────────────────────────────────────────────
+async function llmReview(candidates, deps) {
+    const { agent, signal, taskId } = deps;
+    let sessionId;
+    try {
+        sessionId = await agent.createTaskSession(taskId, 'dream-prune');
+    }
+    catch {
+        return [];
+    }
+    try {
+        // Build candidate payload (content preview inlined directly in the prompt)
+        const payload = await buildCandidatePayload(candidates, deps.contextTreeDir);
+        const totalFileCount = await countActiveFiles(deps.contextTreeDir);
+        const prompt = buildPrompt(candidates.length, totalFileCount, payload);
+        const response = await agent.executeOnSession(sessionId, prompt, {
+            executionContext: { commandType: 'curate', maxIterations: 10 },
+            signal,
+            taskId,
+        });
+        const parsed = parseDreamResponse(response, PruneResponseSchema);
+        return parsed?.decisions ?? [];
+    }
+    catch {
+        return [];
+    }
+    finally {
+        await agent.deleteTaskSession(sessionId).catch(() => { });
+    }
+}
+async function buildCandidatePayload(candidates, contextTreeDir) {
+    return Promise.all(candidates.map(async (c) => {
+        let contentPreview = '';
+        try {
+            const content = await readFile(join(contextTreeDir, c.path), 'utf8');
+            contentPreview = content.slice(0, 1000);
+        }
+        catch {
+            // Skip
+        }
+        return {
+            contentPreview,
+            daysSinceModified: Math.round(c.daysSinceModified),
+            importance: c.importance,
+            maturity: c.maturity,
+            path: c.path,
+            signal: c.signal,
+        };
+    }));
+}
+async function countActiveFiles(contextTreeDir) {
+    let count = 0;
+    await walkMdFiles(contextTreeDir, async () => { count++; });
+    return count;
+}
+function buildPrompt(candidateCount, totalFileCount, payload) {
+    const marker = '━'.repeat(60);
+    const candidateBlocks = payload.map((c) => `\n${marker}\nPATH: ${c.path}\nmaturity: ${c.maturity} | ${c.daysSinceModified}d old | importance: ${c.importance} | signal: ${c.signal}\n${marker}\n${c.contentPreview}`);
+    return [
+        'You are reviewing files in a knowledge base for potential archival.',
+        'These files were flagged as potentially stale or low-value based on metadata signals.',
+        '',
+        'For each file, decide:',
+        '- ARCHIVE: File content is a placeholder, TODO, explicitly superseded, or has no actionable information.',
+        '- KEEP: File has real, actionable knowledge even if older.',
+        '- MERGE_INTO: Content clearly belongs in another specific file.',
+        '',
+        'Rules:',
+        '- A draft file with importance < 35 whose body is a placeholder/TODO/"safe to delete" SHOULD be archived.',
+        '- If the body explicitly says the content is obsolete, superseded, or never-filled-in, ARCHIVE.',
+        '- Default to KEEP only when content is useful but stale, not when content is genuinely worthless.',
+        '- MERGE_INTO should only be used when the content clearly belongs in another specific file that you can name.',
+        '',
+        'Context:',
+        `- The context tree currently contains ${totalFileCount} active files.`,
+        `- These ${candidateCount} files were flagged by staleness detection.`,
+        '',
+        'Candidates (full previews below):',
+        ...candidateBlocks,
+        '',
+        'Respond IMMEDIATELY with JSON — do NOT use code_exec:',
+        '```',
+        '{ "decisions": [{ "file": "...", "decision": "ARCHIVE|KEEP|MERGE_INTO", "reason": "...", "mergeTarget": "path (only for MERGE_INTO)" }] }',
+        '```',
+    ].join('\n');
+}
+// ── Step 3: Execute decisions ──────────────────────────────────────────────
+async function executeDecisions(decisions, candidates, deps) {
+    const candidateSet = new Set(candidates.map((c) => c.path));
+    const results = [];
+    for (const decision of decisions) {
+        // Skip hallucinated paths — only process decisions for actual candidates
+        if (!candidateSet.has(decision.file))
+            continue;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const op = await executeDecision(decision, deps);
+            if (op)
+                results.push(op);
+        }
+        catch {
+            // Skip failed decision — continue with others
+        }
+    }
+    return results;
+}
+async function executeDecision(decision, deps) {
+    switch (decision.decision) {
+        case 'ARCHIVE': {
+            // Create review backup before destructive archive (read content → save to review-backups/)
+            if (deps.reviewBackupStore) {
+                try {
+                    const content = await readFile(join(deps.contextTreeDir, decision.file), 'utf8');
+                    await deps.reviewBackupStore.save(decision.file, content);
+                }
+                catch {
+                    // Best-effort: backup failure must not block archive
+                }
+            }
+            const archiveResult = await deps.archiveService.archiveEntry(decision.file, deps.agent, deps.projectRoot);
+            return {
+                action: 'ARCHIVE',
+                file: decision.file,
+                needsReview: true,
+                reason: decision.reason,
+                stubPath: archiveResult.stubPath,
+                type: 'PRUNE',
+            };
+        }
+        case 'KEEP': {
+            // Bump mtime to reset staleness clock
+            const absPath = join(deps.contextTreeDir, decision.file);
+            const now = new Date();
+            await utimes(absPath, now, now).catch(() => { });
+            return {
+                action: 'KEEP',
+                file: decision.file,
+                needsReview: false,
+                reason: decision.reason,
+                type: 'PRUNE',
+            };
+        }
+        case 'MERGE_INTO': {
+            if (!decision.mergeTarget)
+                return undefined;
+            await writePendingMerge(decision, deps);
+            return {
+                action: 'SUGGEST_MERGE',
+                file: decision.file,
+                mergeTarget: decision.mergeTarget,
+                needsReview: false,
+                reason: decision.reason,
+                type: 'PRUNE',
+            };
+        }
+        default: {
+            return undefined;
+        }
+    }
+}
+async function writePendingMerge(decision, deps) {
+    if (!decision.mergeTarget)
+        return;
+    const { mergeTarget } = decision;
+    // Use update() instead of read()+write() so a concurrent
+    // incrementCurationCount isn't overwritten by a stale spread.
+    await deps.dreamStateService.update((state) => {
+        const pendingMerges = state.pendingMerges ?? [];
+        const alreadySuggested = pendingMerges.some((m) => m.sourceFile === decision.file && m.mergeTarget === mergeTarget);
+        if (alreadySuggested)
+            return state;
+        return {
+            ...state,
+            pendingMerges: [
+                ...pendingMerges,
+                {
+                    mergeTarget,
+                    reason: decision.reason,
+                    sourceFile: decision.file,
+                    suggestedByDreamId: deps.dreamLogId,
+                },
+            ],
+        };
+    });
+}
+// ── Frontmatter helpers ────────────────────────────────────────────────────
+function extractMaturity(content) {
+    const match = /^maturity:\s*['"]?(core|draft|validated)['"]?/m.exec(content);
+    return match?.[1] ?? 'draft';
+}
+function extractImportance(content) {
+    const match = /^importance:\s*(\d+(?:\.\d+)?)/m.exec(content);
+    return match ? Number.parseFloat(match[1]) : 50;
+}

package/dist/server/infra/dream/operations/synthesize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Synthesize operation — detects cross-domain patterns from domain summaries.
+ *
+ * Flow:
+ * 1. Collect domain summaries from _index.md files
+ * 2. Collect existing synthesis files (to avoid duplicates)
+ * 3. Single LLM call for cross-domain analysis
+ * 4. Deduplicate candidates against existing files via BM25
+ * 5. Write new synthesis files as regular draft context entries
+ *
+ * Never throws — returns empty array on errors.
+ */
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { DreamOperation } from '../dream-log-schema.js';
+export type SynthesizeDeps = {
+    agent: ICipherAgent;
+    contextTreeDir: string;
+    searchService: {
+        search(query: string, options?: {
+            limit?: number;
+            scope?: string;
+        }): Promise<{
+            results: Array<{
+                path: string;
+                score: number;
+                title: string;
+            }>;
+        }>;
+    };
+    signal?: AbortSignal;
+    taskId: string;
+};
+/**
+ * Run synthesis on the context tree.
+ * Returns DreamOperation results (never throws).
+ */
+export declare function synthesize(deps: SynthesizeDeps): Promise<DreamOperation[]>;

package/dist/server/infra/dream/operations/synthesize.js

@@ -0,0 +1,278 @@
+/**
+ * Synthesize operation — detects cross-domain patterns from domain summaries.
+ *
+ * Flow:
+ * 1. Collect domain summaries from _index.md files
+ * 2. Collect existing synthesis files (to avoid duplicates)
+ * 3. Single LLM call for cross-domain analysis
+ * 4. Deduplicate candidates against existing files via BM25
+ * 5. Write new synthesis files as regular draft context entries
+ *
+ * Never throws — returns empty array on errors.
+ */
+import { dump as yamlDump, load as yamlLoad } from 'js-yaml';
+import { randomUUID } from 'node:crypto';
+import { access, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { isDescendantOf } from '../../../utils/path-utils.js';
+import { SynthesizeResponseSchema } from '../dream-response-schemas.js';
+import { parseDreamResponse } from '../parse-dream-response.js';
+const DEDUP_THRESHOLD = 0.5;
+/**
+ * Run synthesis on the context tree.
+ * Returns DreamOperation results (never throws).
+ */
+export async function synthesize(deps) {
+    const { agent, contextTreeDir, searchService, taskId } = deps;
+    if (deps.signal?.aborted)
+        return [];
+    // Step 1: Collect domain summaries
+    const domains = await collectDomainSummaries(contextTreeDir);
+    if (domains.length < 2)
+        return [];
+    // Step 2: Collect existing synthesis files
+    const existingSyntheses = await collectExistingSyntheses(contextTreeDir, domains);
+    // Step 3: LLM cross-domain analysis
+    let sessionId;
+    try {
+        sessionId = await agent.createTaskSession(taskId, 'dream-synthesize');
+    }
+    catch {
+        return [];
+    }
+    try {
+        const prompt = buildPrompt(domains, existingSyntheses);
+        const response = await agent.executeOnSession(sessionId, prompt, {
+            executionContext: { commandType: 'curate', maxIterations: 10 },
+            signal: deps.signal,
+            taskId,
+        });
+        const parsed = parseDreamResponse(response, SynthesizeResponseSchema);
+        if (!parsed || parsed.syntheses.length === 0)
+            return [];
+        // Step 4: Deduplicate against existing synthesis files only — the whole tree
+        // will naturally score high since synthesis derives from domain summaries
+        const novel = [];
+        for (const candidate of parsed.syntheses) {
+            // eslint-disable-next-line no-await-in-loop
+            const isDuplicate = await isDuplicateCandidate(candidate, existingSyntheses, searchService);
+            if (!isDuplicate)
+                novel.push(candidate);
+        }
+        if (novel.length === 0)
+            return [];
+        // Step 5: Write synthesis files (per-candidate error handling to preserve partial results)
+        const results = [];
+        for (const candidate of novel) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const op = await writeSynthesisFile(candidate, contextTreeDir);
+                if (op)
+                    results.push(op);
+            }
+            catch {
+                // Skip failed candidate — don't discard already-written results
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        await agent.deleteTaskSession(sessionId).catch(() => { });
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+async function collectDomainSummaries(contextTreeDir) {
+    let dirNames;
+    try {
+        const entries = await readdir(contextTreeDir, { withFileTypes: true });
+        dirNames = entries
+            .filter((e) => e.isDirectory())
+            .map((e) => String(e.name))
+            .filter((n) => !n.startsWith('_') && !n.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+    const loaded = await Promise.all(dirNames.map(async (name) => {
+        try {
+            const content = await readFile(join(contextTreeDir, name, '_index.md'), 'utf8');
+            return { content, name };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return loaded.filter((item) => item !== null);
+}
+async function collectExistingSyntheses(contextTreeDir, domains) {
+    const syntheses = [];
+    const domainResults = await Promise.all(domains.map(async (domain) => {
+        const domainDir = join(contextTreeDir, domain.name);
+        let files;
+        try {
+            const entries = await readdir(domainDir);
+            files = entries.filter((f) => f.endsWith('.md') && !f.startsWith('_'));
+        }
+        catch {
+            return [];
+        }
+        const found = [];
+        const checks = files.map(async (file) => {
+            try {
+                const content = await readFile(join(domainDir, file), 'utf8');
+                const fm = parseFrontmatterType(content);
+                if (fm === 'synthesis') {
+                    return `${domain.name}/${file}`;
+                }
+            }
+            catch {
+                // skip
+            }
+            return null;
+        });
+        const results = await Promise.all(checks);
+        for (const r of results) {
+            if (r)
+                found.push(r);
+        }
+        return found;
+    }));
+    for (const paths of domainResults)
+        syntheses.push(...paths);
+    return syntheses;
+}
+/** Extract the `type` field from YAML frontmatter, or undefined. */
+function parseFrontmatterType(content) {
+    if (!content.startsWith('---\n') && !content.startsWith('---\r\n'))
+        return undefined;
+    const endIndex = content.indexOf('\n---\n', 4);
+    const endIndexCrlf = content.indexOf('\r\n---\r\n', 5);
+    const actualEnd = endIndex === -1 ? endIndexCrlf : endIndex;
+    if (actualEnd < 0)
+        return undefined;
+    try {
+        const yamlBlock = content.slice(4, actualEnd);
+        const raw = yamlLoad(yamlBlock);
+        if (raw !== null && typeof raw === 'object' && !Array.isArray(raw) && 'type' in raw && typeof raw.type === 'string') {
+            return raw.type;
+        }
+    }
+    catch {
+        // Invalid YAML
+    }
+    return undefined;
+}
+async function isDuplicateCandidate(candidate, existingSyntheses, searchService) {
+    if (existingSyntheses.length === 0)
+        return false;
+    try {
+        const query = `${candidate.title} ${candidate.claim}`;
+        const results = await searchService.search(query, { limit: 5 });
+        // Only consider matches against existing synthesis files — the whole tree
+        // will naturally score high since synthesis derives from domain summaries
+        const synthesisMatch = results.results.find((r) => existingSyntheses.includes(r.path));
+        const topScore = synthesisMatch?.score ?? 0;
+        return topScore >= DEDUP_THRESHOLD;
+    }
+    catch {
+        return false; // Search failure → assume novel
+    }
+}
+async function writeSynthesisFile(candidate, contextTreeDir) {
+    const slug = slugify(candidate.title);
+    const relativePath = `${candidate.placement}/${slug}.md`;
+    const absPath = resolve(contextTreeDir, relativePath);
+    // Guard against LLM-supplied path traversal (e.g. placement = "../../etc")
+    if (!isDescendantOf(absPath, contextTreeDir)) {
+        return undefined;
+    }
+    // Name collision check
+    try {
+        await access(absPath);
+        return undefined; // File exists — skip
+    }
+    catch {
+        // ENOENT — good, proceed
+    }
+    const sources = candidate.evidence.map((e) => `${e.domain}/_index.md`);
+    /* eslint-disable camelcase */
+    const frontmatter = {
+        confidence: candidate.confidence,
+        maturity: 'draft',
+        sources,
+        synthesized_at: new Date().toISOString(),
+        type: 'synthesis',
+    };
+    /* eslint-enable camelcase */
+    const yaml = yamlDump(frontmatter, { lineWidth: -1, sortKeys: true }).trimEnd();
+    const body = [
+        `# ${candidate.title}`,
+        '',
+        candidate.claim,
+        '',
+        '## Evidence',
+        '',
+        ...candidate.evidence.map((e) => `- **${e.domain}**: ${e.fact}`),
+        '',
+    ].join('\n');
+    const content = `---\n${yaml}\n---\n\n${body}`;
+    await atomicWrite(absPath, content);
+    return {
+        action: 'CREATE',
+        confidence: candidate.confidence,
+        needsReview: candidate.confidence < 0.7,
+        outputFile: relativePath,
+        sources,
+        type: 'SYNTHESIZE',
+    };
+}
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9]+/g, '-')
+        .replaceAll(/^-|-$/g, '')
+        .slice(0, 80);
+}
+async function atomicWrite(filePath, content) {
+    await mkdir(dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+    await writeFile(tmpPath, content, 'utf8');
+    await rename(tmpPath, filePath);
+}
+function buildPrompt(domains, existingSyntheses) {
+    const existingList = existingSyntheses.length > 0
+        ? `Existing synthesis files (do NOT recreate these):\n${existingSyntheses.map((s) => `- ${s}`).join('\n')}`
+        : 'No existing synthesis files.';
+    const marker = '━'.repeat(60);
+    const domainBlocks = domains
+        .map((d) => `\n${marker}\nDOMAIN: ${d.name}\n${marker}\n${d.content}`)
+        .join('\n');
+    return [
+        'You are analyzing a knowledge base organized into domains. The full _index.md content for every domain is included below — read them directly. Do NOT use code_exec.',
+        '',
+        `Domains: ${domains.map((d) => d.name).join(', ')}`,
+        '',
+        existingList,
+        '',
+        'Domain summaries:',
+        domainBlocks,
+        '',
+        'Your job is to find cross-cutting patterns — concepts, concerns, or conflicts that span multiple domains.',
+        '',
+        'Rules:',
+        '- Report genuinely useful insights that a developer would benefit from knowing.',
+        '- Any named abstraction, component, or concept that appears in 2+ domains is worth synthesizing.',
+        '- Do NOT report trivial or obvious connections (e.g., "both domains use TypeScript").',
+        '- Each synthesis must reference at least 2 domains with specific evidence.',
+        '- For "placement", choose the domain where this insight is MOST actionable.',
+        '- If nothing meaningful is found, return an empty array. That is fine — but missing a clear cross-domain pattern is a failure.',
+        '',
+        'Respond with JSON:',
+        '```',
+        '{ "syntheses": [{ "title": "...", "claim": "...", "evidence": [{"domain": "...", "fact": "..."}], "confidence": 0.0-1.0, "placement": "..." }] }',
+        '```',
+    ].join('\n');
+}

package/dist/server/infra/dream/parse-dream-response.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+/**
+ * Extract and validate a JSON response from LLM output.
+ *
+ * Tries two strategies in order:
+ * 1. JSON inside a ```json code fence (first match, non-greedy)
+ * 2. Raw JSON (first { to last })
+ *
+ * Returns null if no valid JSON matching the schema is found.
+ */
+export declare function parseDreamResponse<T>(response: string, schema: z.ZodType<T>): null | T;