@telora/daemon 0.16.33 → 0.16.42

package/dist/assembly-resolvers.js

@@ -1,1919 +1,19 @@
 /**
  * Source resolver implementations for the Context Assembly Engine.
  *
- * Each resolver fetches data from the Telora API or local git state
- * and formats it as markdown content. Resolvers are registered at
- * module load time.
- */
-import { execSync } from 'node:child_process';
-import { registerSourceResolver } from './assembly-engine.js';
-import { getFocusDeliveries, getFocusIssues, getProductDeploymentProfileSnapshot, getLatestCompletedFocusReview, } from './queries/focuses.js';
-import { getResolvedTransitionBlockForDelivery } from './queries/guards.js';
-import { fetchFocusWorkflow } from './queries/focuses.js';
-import { callApi } from './queries/shared.js';
-import { buildDeliveryListingSection, buildCloseLoopBookkeeperPersona, } from './team-prompt-base.js';
-const WIKI_RETRIEVAL_BUDGET_CHARS = 10_000;
-// Reserve a slice of the budget for the ancestors block. Empirically a few
-// hundred characters per ancestor (title + 1-line summary) is plenty.
-const WIKI_ANCESTORS_BUDGET_FRACTION = 0.25;
-async function searchWiki(productId, query, limit = 8) {
-    try {
-        const result = await callApi('wiki_search', {
-            productId,
-            query,
-            limit,
-        });
-        return result.pages ?? [];
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] wiki_search failed for query "${query}": ${err.message}`);
-        return [];
-    }
-}
-/**
- * Fetch the deduplicated union of ancestors for a list of hit page ids.
- * Returns root-first ordering (depthFromRoot ascending). Empty array on
- * failure or when no ancestors exist (all hits are roots).
- */
-async function fetchAncestorsForHits(productId, pageIds) {
-    if (pageIds.length === 0)
-        return [];
-    try {
-        const result = await callApi('wiki_ancestors_for_pages', {
-            productId,
-            pageIds,
-        });
-        return result.ancestors ?? [];
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] wiki_ancestors_for_pages failed: ${err.message}`);
-        return [];
-    }
-}
-/**
- * Render hits with their content. Performs a context_assemble call -- not
- * for layered assembly, but to surface page bodies via the same edge
- * function endpoint used by the human MCP profile. The caller supplies the
- * queries explicitly.
- */
-async function fetchPageBodies(productId, ids) {
-    const bodies = new Map();
-    if (ids.length === 0)
-        return bodies;
-    for (const id of ids) {
-        try {
-            const result = await callApi('wiki_page_get', {
-                productId,
-                pageId: id,
-            });
-            if (result.page)
-                bodies.set(result.page.id, result.page);
-        }
-        catch (err) {
-            console.warn(`[assembly-engine] wiki_page_get failed for ${id}: ${err.message}`);
-        }
-    }
-    return bodies;
-}
-/**
- * Render a wiki retrieval section. When `ancestors` is non-empty, prepend a
- * "Background Context" block (title + summary only, root-first) above the
- * leaf hits. The ancestors block consumes up to WIKI_ANCESTORS_BUDGET_FRACTION
- * of the total budget; the rest goes to leaf bodies.
- *
- * Design choice: ancestors render as a SEPARATE section above leaves rather
- * than inline with each hit. Inline duplicates ancestors when multiple hits
- * share them, and the agent can reason about the topical neighborhood once
- * rather than per-hit.
- */
-function renderWikiSection(heading, hits, bodies, budgetChars, ancestors = []) {
-    if (hits.length === 0)
-        return '';
-    const out = [`## ${heading}`];
-    let used = out[0].length;
-    // Ancestors block. Cumulative budget across the whole block (heading + all
-    // ancestor lines), not per-block — so a deep chain can't sneak past the cap
-    // by keeping each individual line small.
-    if (ancestors.length > 0) {
-        const ancestorBudget = Math.floor(budgetChars * WIKI_ANCESTORS_BUDGET_FRACTION);
-        const lines = ['\n\n### Background Context', ''];
-        let ancestorsUsed = lines[0].length + 1 + lines[1].length; // heading + join separator
-        for (const a of ancestors) {
-            const summary = (a.summary ?? '').trim();
-            const line = summary
-                ? `- **${a.title}** (${a.path}) — ${summary}`
-                : `- **${a.title}** (${a.path})`;
-            const next = lines.length === 2 ? line : '\n' + line;
-            if (ancestorsUsed + next.length > ancestorBudget)
-                break;
-            ancestorsUsed += next.length;
-            lines.push(next);
-        }
-        if (lines.length > 2) {
-            const block = lines.join('\n');
-            out.push(block);
-            used += block.length;
-        }
-    }
-    // Leaf bodies.
-    for (const hit of hits) {
-        const body = bodies.get(hit.id);
-        const content = body?.content?.trim() || hit.summary?.trim() || '';
-        const breadcrumb = hit.path && hit.path !== hit.slug ? `\n*path: ${hit.path}*` : '';
-        const block = `\n\n### ${hit.title}\n*slug: ${hit.slug}*${breadcrumb}\n\n${content || '_No content yet._'}`;
-        if (used + block.length > budgetChars && out.length > 1)
-            break;
-        out.push(block);
-        used += block.length;
-    }
-    return out.join('');
-}
-// ── Helpers ──────────────────────────────────────────────────────
-export const MAX_DIFF_BYTES = 50 * 1024; // 50 KB truncation limit for git diffs
-/** Format an issue status as a checkbox marker. */
-function statusCheckbox(status) {
-    const lower = status.toLowerCase();
-    if (lower === 'done')
-        return '[x]';
-    if (lower === 'verified')
-        return '[v]';
-    if (lower === 'in review')
-        return '[?]';
-    if (lower === 'in progress')
-        return '[-]';
-    return '[ ]';
-}
-/**
- * Run git diff in a worktree against the base branch.
- * Returns the raw diff output, or empty string on failure.
- */
-export function getGitDiff(worktreePath, baseBranch) {
-    try {
-        const diff = execSync(`git diff ${baseBranch}...HEAD`, { cwd: worktreePath, maxBuffer: 10 * 1024 * 1024, encoding: 'utf-8' });
-        return diff;
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Get a summary of files changed in a diff (for truncation header).
- */
-function getDiffStatSummary(worktreePath, baseBranch) {
-    try {
-        return execSync(`git diff --stat ${baseBranch}...HEAD`, { cwd: worktreePath, maxBuffer: 1024 * 1024, encoding: 'utf-8' });
-    }
-    catch {
-        return '';
-    }
-}
-// ── Resolvers ────────────────────────────────────────────────────
-/**
- * delivery.acceptance_criteria
- *
- * Fetches all deliveries for the focus and formats acceptance criteria.
- */
-registerSourceResolver('delivery.acceptance_criteria', async (context) => {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    if (deliveries.length === 0)
-        return '';
-    const sections = deliveries
-        .filter((d) => d.acceptanceCriteria)
-        .map((d) => `### ${d.name}\n\n${d.acceptanceCriteria}`);
-    if (sections.length === 0)
-        return '';
-    return `## Acceptance Criteria\n\n${sections.join('\n\n')}`;
-});
-/**
- * delivery.description
- *
- * Fetches all deliveries for the focus and formats descriptions.
- */
-registerSourceResolver('delivery.description', async (context) => {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    if (deliveries.length === 0)
-        return '';
-    const sections = deliveries
-        .filter((d) => d.description)
-        .map((d) => `### ${d.name}\n\n${d.description}`);
-    if (sections.length === 0)
-        return '';
-    return `## Delivery Descriptions\n\n${sections.join('\n\n')}`;
-});
-/**
- * delivery.issues
- *
- * Fetches all issues across deliveries and formats as a checklist.
- * Optional param: status (filter by issue status, e.g. "done").
- */
-registerSourceResolver('delivery.issues', async (context, params) => {
-    const issues = await getFocusIssues(context.focusId);
-    if (issues.length === 0)
-        return '';
-    const statusFilter = params.status?.toLowerCase();
-    // When filtering by 'done', also include 'Verified' issues — they are
-    // semantically closed (confirmed-addressed by a review agent) and should
-    // appear in review-context done-lists so the agent knows they were handled.
-    const filtered = statusFilter
-        ? issues.filter((i) => {
-            const s = i.status.toLowerCase();
-            return s === statusFilter || (statusFilter === 'done' && s === 'verified');
-        })
-        : issues;
-    if (filtered.length === 0)
-        return '';
-    // Group issues by delivery
-    const byDelivery = {};
-    for (const issue of filtered) {
-        const group = byDelivery[issue.deliveryId] ?? [];
-        group.push(issue);
-        byDelivery[issue.deliveryId] = group;
-    }
-    const sections = [];
-    for (const deliveryId of Object.keys(byDelivery)) {
-        const deliveryIssues = byDelivery[deliveryId];
-        const lines = deliveryIssues.map((i) => {
-            const check = statusCheckbox(i.status);
-            const typeTag = i.issueType !== 'task' ? ` [${i.issueType}]` : '';
-            return `- ${check} ${i.title}${typeTag} (${i.status})`;
-        });
-        sections.push(`### Delivery ${deliveryId.slice(0, 8)}\n\n${lines.join('\n')}`);
-    }
-    const header = statusFilter
-        ? `## Issues (${statusFilter})`
-        : '## Issues';
-    const hasVerified = filtered.some((i) => i.status.toLowerCase() === 'verified');
-    const hasInReview = filtered.some((i) => i.status.toLowerCase() === 'in review');
-    const legendLines = [];
-    if (hasVerified)
-        legendLines.push('`[v]` = Verified — confirmed-addressed in a prior review pass. Skip on re-review.');
-    if (hasInReview)
-        legendLines.push('`[?]` = In Review — dev-complete, awaiting review-agent confirmation. **This is the review agent\'s working set.**');
-    const legend = legendLines.length > 0
-        ? '\n\n' + legendLines.map(l => `> ${l}`).join('\n>\n> ')
-        : '';
-    return `${header}${legend}\n\n${sections.join('\n\n')}`;
-});
-/**
- * focus.context
- *
- * Pulls wiki pages relevant to the focus via wiki_search. Queries are
- * derived from the focus name + the first sentence of its description;
- * deliveries below the focus contribute additional queries when present.
- */
-registerSourceResolver('focus.context', async (context) => {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    const queries = [];
-    const seen = new Set();
-    const addQuery = (q) => {
-        const trimmed = (q ?? '').trim();
-        if (!trimmed || seen.has(trimmed))
-            return;
-        seen.add(trimmed);
-        queries.push(trimmed);
-    };
-    // Use the first delivery's name+description plus subsequent delivery
-    // names to seed the search. This keeps queries focused on the work in
-    // flight rather than dumping every delivery description.
-    for (const d of deliveries) {
-        addQuery(d.name);
-    }
-    if (queries.length === 0) {
-        addQuery(''); // recently-edited fallback
-    }
-    const aggregated = new Map();
-    for (const q of queries.slice(0, 4)) {
-        const hits = await searchWiki(context.productId, q, 4);
-        for (const hit of hits) {
-            const existing = aggregated.get(hit.id);
-            if (!existing || hit.rank > existing.rank)
-                aggregated.set(hit.id, hit);
-        }
-    }
-    const sorted = Array.from(aggregated.values()).sort((a, b) => b.rank - a.rank).slice(0, 8);
-    const [bodies, ancestors] = await Promise.all([
-        fetchPageBodies(context.productId, sorted.map((h) => h.id)),
-        fetchAncestorsForHits(context.productId, sorted.map((h) => h.id)),
-    ]);
-    return renderWikiSection('Wiki', sorted, bodies, WIKI_RETRIEVAL_BUDGET_CHARS, ancestors);
-});
-/**
- * focus.last_review_report
- *
- * Read the most recent completed review report for the focus and render it
- * as a markdown section. Returns an empty string when no completed report
- * exists yet.
- *
- * The dev-stage assembly directive (see migration
- * 20260512_*_add_last_review_report_to_dev_stage_assembly.sql) inserts this
- * resolver immediately after focus.context so remediation work is informed
- * by the reviewer's narrative, not just by individual issue descriptions.
- */
-const FOCUS_LAST_REVIEW_REPORT_BUDGET_CHARS = 10_000;
-registerSourceResolver('focus.last_review_report', async (context) => {
-    let review;
-    try {
-        review = await getLatestCompletedFocusReview(context.focusId);
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] focus.last_review_report failed: ${err.message}`);
-        return '';
-    }
-    if (!review || !review.completedAt)
-        return '';
-    const heading = '## Last Review Report';
-    const outcomeLine = `**Outcome:** ${review.outcome ?? 'unknown'}`;
-    const completedLine = `**Completed:** ${review.completedAt}`;
-    const fixedPrefix = `${heading}\n\n${outcomeLine}\n${completedLine}\n\n`;
-    const summary = (review.summary ?? '').trim();
-    if (!summary) {
-        return `${fixedPrefix}_No summary provided._`;
-    }
-    const remaining = FOCUS_LAST_REVIEW_REPORT_BUDGET_CHARS - fixedPrefix.length;
-    if (remaining <= 0) {
-        // Prefix alone exceeds the budget (unlikely with a fixed-size heading +
-        // outcome + ISO timestamp). Drop the summary to stay under the cap.
-        return fixedPrefix.trimEnd();
-    }
-    const body = summary.length > remaining
-        ? `${summary.slice(0, remaining)}\n\n_[truncated]_`
-        : summary;
-    return `${fixedPrefix}${body}`;
-});
-function pickString(payload, keys) {
-    for (const key of keys) {
-        const v = payload[key];
-        if (typeof v === 'string' && v.trim().length > 0)
-            return v.trim();
-    }
-    return null;
-}
-const ADVISORY_EVIDENCE_BUDGET = 500;
-const SECURITY_ADVISORY_SECTION_BUDGET_CHARS = 10_000;
-const SECURITY_ADVISORY_TRUNCATION_FOOTER = '\n\n_[truncated: section budget reached]_';
-function formatAdvisorySection(advisory) {
-    const payload = advisory.payload ?? {};
-    const lines = [];
-    lines.push(`### ${advisory.identifier}`);
-    lines.push('');
-    lines.push(`- **IOC class:** ${advisory.iocClass}`);
-    lines.push(`- **Severity:** ${advisory.severity}`);
-    const pkg = pickString(payload, ['package', 'affected_package']);
-    if (pkg) {
-        const currentVersion = pickString(payload, ['current_version', 'installed_version']);
-        lines.push(`- **Package:** ${pkg}${currentVersion ? ` @ ${currentVersion}` : ''}`);
-    }
-    const fixVersion = pickString(payload, ['fix_version', 'fixed_version', 'patched_version']);
-    if (fixVersion)
-        lines.push(`- **Fix version:** ${fixVersion}`);
-    const advisoryUrl = pickString(payload, ['advisory_url', 'url', 'reference']);
-    if (advisoryUrl)
-        lines.push(`- **Advisory:** ${advisoryUrl}`);
-    const exploitClass = pickString(payload, ['exploit_class', 'cwe', 'vulnerability_class']);
-    if (exploitClass)
-        lines.push(`- **Exploit class:** ${exploitClass}`);
-    if (advisory.firstSeenAt)
-        lines.push(`- **First seen:** ${advisory.firstSeenAt}`);
-    if (advisory.injectionStatement) {
-        lines.push('');
-        lines.push(`**Injection statement:** ${advisory.injectionStatement}`);
-    }
-    if (advisory.injectionEvidence) {
-        const ev = advisory.injectionEvidence.length > ADVISORY_EVIDENCE_BUDGET
-            ? `${advisory.injectionEvidence.slice(0, ADVISORY_EVIDENCE_BUDGET)}...`
-            : advisory.injectionEvidence;
-        lines.push('');
-        lines.push(`**Evidence:** ${ev}`);
-    }
-    return lines.join('\n');
-}
-registerSourceResolver('security.advisory', async (context) => {
-    if (context.deliveryIds.length === 0)
-        return '';
-    const header = '## Security Advisory\n\n';
-    // Reserve the footer length so that even the worst-case truncated output
-    // (header + body filled to sectionsBudget + footer) stays within the 10k cap.
-    const sectionsBudget = SECURITY_ADVISORY_SECTION_BUDGET_CHARS - header.length - SECURITY_ADVISORY_TRUNCATION_FOOTER.length;
-    const sections = [];
-    let used = 0;
-    let truncated = false;
-    for (const deliveryId of context.deliveryIds) {
-        if (used >= sectionsBudget) {
-            truncated = true;
-            break;
-        }
-        try {
-            const result = await callApi('daemon_get_security_advisory_for_delivery', { deliveryId });
-            const advisories = result.advisories ?? [];
-            if (advisories.length === 0)
-                continue;
-            let hitBudget = false;
-            for (const adv of advisories) {
-                const formatted = formatAdvisorySection(adv);
-                // Account for the inter-section separator that will be inserted.
-                const separator = sections.length > 0 ? 2 : 0;
-                if (used + separator + formatted.length > sectionsBudget) {
-                    truncated = true;
-                    hitBudget = true;
-                    break;
-                }
-                sections.push(formatted);
-                used += separator + formatted.length;
-            }
-            if (hitBudget)
-                break;
-        }
-        catch (err) {
-            console.warn(`[assembly-engine] security.advisory for delivery ${deliveryId} failed: ${err.message}`);
-        }
-    }
-    if (sections.length === 0)
-        return '';
-    const body = sections.join('\n\n');
-    return truncated
-        ? `${header}${body}${SECURITY_ADVISORY_TRUNCATION_FOOTER}`
-        : `${header}${body}`;
-});
-/**
- * wiki.search(query=...)
- *
- * Run a free-text wiki search and return ranked, body-included markdown.
- * Stage directives use this to pull in topic-specific pages.
- */
-registerSourceResolver('wiki.search', async (context, params) => {
-    const query = (params.query ?? '').trim();
-    const limit = params.limit ? Math.max(1, parseInt(params.limit, 10)) : 6;
-    if (!query)
-        return '';
-    const hits = await searchWiki(context.productId, query, limit);
-    if (hits.length === 0)
-        return '';
-    const [bodies, ancestors] = await Promise.all([
-        fetchPageBodies(context.productId, hits.map((h) => h.id)),
-        fetchAncestorsForHits(context.productId, hits.map((h) => h.id)),
-    ]);
-    return renderWikiSection(`Wiki: ${query}`, hits, bodies, WIKI_RETRIEVAL_BUDGET_CHARS, ancestors);
-});
-/**
- * wiki.topic(slug=...)
- *
- * Hard-pin a single wiki page by slug. No retrieval risk -- if the slug
- * exists, the page is included verbatim. Used by stage directives that
- * need a specific page (e.g., a security checklist).
- */
-registerSourceResolver('wiki.topic', async (context, params) => {
-    const slug = (params.slug ?? '').trim();
-    if (!slug)
-        return '';
-    try {
-        const result = await callApi('wiki_page_get', {
-            productId: context.productId,
-            slug,
-        });
-        if (!result.page)
-            return '';
-        const page = result.page;
-        return `## Wiki: ${page.title}\n*slug: ${page.slug}*\n\n${page.content || '_No content yet._'}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] wiki.topic(slug=${slug}) failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * git.diff_against_base
- *
- * Runs git diff against the integration branch in the worktree.
- * Truncates large diffs and includes a file change summary.
- */
-registerSourceResolver('git.diff_against_base', async (context) => {
-    if (!context.worktreePath) {
-        console.warn('[assembly-engine] git.diff_against_base: no worktree path available');
-        return '';
-    }
-    const baseBranch = context.config.integrationBranch;
-    const diff = getGitDiff(context.worktreePath, baseBranch);
-    if (!diff.trim())
-        return '';
-    if (diff.length > MAX_DIFF_BYTES) {
-        const stat = getDiffStatSummary(context.worktreePath, baseBranch);
-        const truncated = diff.slice(0, MAX_DIFF_BYTES);
-        return [
-            `## Git Diff (against ${baseBranch})`,
-            '',
-            `> **Truncated** -- diff is ${Math.round(diff.length / 1024)}KB, showing first ${Math.round(MAX_DIFF_BYTES / 1024)}KB.`,
-            '',
-            '### File Summary',
-            '',
-            '```',
-            stat.trim(),
-            '```',
-            '',
-            '```diff',
-            truncated,
-            '```',
-        ].join('\n');
-    }
-    return `## Git Diff (against ${baseBranch})\n\n\`\`\`diff\n${diff}\n\`\`\``;
-});
-/**
- * guards.evaluation_results
- *
- * Fetches the most recently resolved transition block for each delivery.
- */
-registerSourceResolver('guards.evaluation_results', async (context) => {
-    if (context.deliveryIds.length === 0)
-        return '';
-    const results = [];
-    for (const deliveryId of context.deliveryIds) {
-        try {
-            const resolved = await getResolvedTransitionBlockForDelivery(deliveryId);
-            if (!resolved)
-                continue;
-            const path = resolved.block.decision_path ?? 'none';
-            const directive = resolved.directive_template ?? 'No directive template';
-            results.push(`### Delivery ${deliveryId.slice(0, 8)}\n\n` +
-                `- **Decision path**: ${path}\n` +
-                `- **Directive**: ${directive}`);
-        }
-        catch (err) {
-            console.warn(`[assembly-engine] guards.evaluation_results: failed for delivery ${deliveryId.slice(0, 8)}: ${err.message}`);
-        }
-    }
-    if (results.length === 0)
-        return '';
-    return `## Guard Evaluation Results\n\n${results.join('\n\n')}`;
-});
-/**
- * workflow.stages
- *
- * Fetches the effective workflow for the focus and lists all stage metadata.
- */
-registerSourceResolver('workflow.stages', async (context) => {
-    try {
-        const workflow = await fetchFocusWorkflow(context.focusId);
-        if (!workflow || workflow.stages.length === 0)
-            return '';
-        const stageList = workflow.stages
-            .sort((a, b) => a.sort_order - b.sort_order)
-            .map((s) => {
-            const desc = s.description ? ` -- ${s.description}` : '';
-            return `- **${s.name}**${desc}`;
-        });
-        return `## Workflow Stages\n\nWorkflow: \`${workflow.id}\`\n\n${stageList.join('\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] workflow.stages: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * deployment.profile
- *
- * Fetches the deployment profile snapshot for the product and formats
- * the inception prompt and guidelines as markdown.
- */
-registerSourceResolver('deployment.profile', async (context) => {
-    try {
-        const snapshot = await getProductDeploymentProfileSnapshot(context.productId);
-        if (!snapshot)
-            return '';
-        const parts = [];
-        if (snapshot.inceptionPrompt) {
-            parts.push(`## Deployment Profile: Operational Context\n\n${snapshot.inceptionPrompt}`);
-        }
-        if (snapshot.guidelines) {
-            parts.push(`## Deployment Constraints\n\n${snapshot.guidelines}`);
-        }
-        return parts.join('\n\n');
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] deployment.profile: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * delivery.listing
- *
- * Fetches deliveries and issues for the focus and formats as a
- * detailed listing using the same format as the team prompt builder.
- *
- * Optional param: scope
- *   - "team" (default): queued + coding deliveries only (building phase)
- *   - "all": all deliveries with status
- *   - "verify": only verify deliveries (review phase)
- *   - "done_since_last_audit": deliveries with executionStatus=done whose
- *     updatedAt is at or after the previous audit cycle's completed_at.
- *     When no prior audit exists, returns all done deliveries.
- */
-registerSourceResolver('delivery.listing', async (context, params) => {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    if (deliveries.length === 0)
-        return '';
-    const issues = await getFocusIssues(context.focusId);
-    const scope = params.scope ?? 'team';
-    if (scope === 'verify') {
-        // Filter to only verify deliveries for review context
-        const verifyDeliveries = deliveries.filter(d => d.executionStatus === 'verify');
-        if (verifyDeliveries.length === 0)
-            return '';
-        const lines = buildDeliveryListingSection(verifyDeliveries, issues);
-        return lines.join('\n');
-    }
-    if (scope === 'done_since_last_audit') {
-        const since = await getAuditCycleLowerBound(context.focusId);
-        const doneDeliveries = deliveries.filter(d => {
-            if (d.executionStatus !== 'done')
-                return false;
-            if (!since)
-                return true;
-            // updatedAt is the closest proxy for "moved to done at" -- when the
-            // daemon advances a delivery to done, that bumps updated_at. Missing
-            // timestamps are included so we don't silently drop a real completion.
-            return !d.updatedAt || d.updatedAt >= since;
-        });
-        if (doneDeliveries.length === 0)
-            return '';
-        const lines = buildDeliveryListingSection(doneDeliveries, issues);
-        return lines.join('\n');
-    }
-    // Default: use buildDeliveryListingSection which partitions into team/other
-    const lines = buildDeliveryListingSection(deliveries, issues);
-    return lines.join('\n');
-});
-/**
- * focus.injections
- *
- * Renders the focus's reality-tree structure as the LEAD COORDINATION MAP --
- * the lead's planning surface. It is structure, not per-delivery detail: for
- * the whole focus it shows, per injection, a one-line Now->Target (the current
- * UDE and the desired effect it becomes); the dependency order to sequence
- * deliveries; shared-target collisions to avoid two workers changing the same
- * node; and the root-cause clusters. Per-delivery full differentials are pulled
- * on demand via telora_reality_tree_injection_context(seq).
- */
-registerSourceResolver('focus.injections', async (context) => {
-    try {
-        const result = await callApi('reality_tree_focus_injections', {
-            focusId: context.focusId,
-        });
-        if (!result.items || result.items.length === 0)
-            return '';
-        const structure = result.structure ?? {
-            dependencyOrder: [],
-            sharedTargetCollisions: [],
-            rootCauseClusters: [],
-        };
-        const lines = [
-            '## Focus Coordination Map',
-            '',
-            'The focus reality-tree structure -- your planning surface. Each injection moves a',
-            'Now (a current UDE) to a Target (its future desired effect). Use the dependency',
-            'order to sequence deliveries, the collisions to avoid two workers changing the same',
-            'node, and the clusters to see which root causes drive which problems. Pull a',
-            "delivery's full differential on demand with telora_reality_tree_injection_context",
-            '(by injection seq).',
-            '',
-            '### Injections (Now -> Target)',
-            '',
-        ];
-        for (const item of result.items) {
-            const inj = item.injection;
-            const statusTag = inj.injectionStatus ? ` [${inj.injectionStatus}]` : '';
-            lines.push(`- #${inj.seq} ${inj.statement}${statusTag}`);
-            for (const nt of item.nowTargets ?? []) {
-                const target = nt.target && nt.target.trim().length > 0 ? nt.target : '(no FRT overlay yet)';
-                lines.push(`  - Now: #${nt.seq} ${nt.now} -> Target: ${target}`);
-            }
-        }
-        if (structure.dependencyOrder.length > 0) {
-            lines.push('', '### Dependency Order (sequence deliveries this way)', '');
-            structure.dependencyOrder.forEach((d, i) => {
-                lines.push(`${i + 1}. #${d.seq} ${d.statement}`);
-            });
-        }
-        if (structure.sharedTargetCollisions.length > 0) {
-            lines.push('', '### Shared-Target Collisions (avoid two workers changing the same node)', '');
-            for (const c of structure.sharedTargetCollisions) {
-                const injList = c.injectionSeqs.map((s) => `#${s}`).join(', ');
-                lines.push(`- #${c.targetSeq} "${c.targetStatement}" <- injections ${injList}`);
-            }
-        }
-        if (structure.rootCauseClusters.length > 0) {
-            lines.push('', '### Root-Cause Clusters (which roots drive which UDEs)', '');
-            for (const cl of structure.rootCauseClusters) {
-                const udeList = cl.udeSeqs.map((s) => `#${s}`).join(', ');
-                lines.push(`- #${cl.rootSeq} ${cl.rootStatement} (${cl.rootNodeType}) drives UDEs: ${udeList}`);
-            }
-        }
-        return lines.join('\n');
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] focus.injections: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * review.outcomes
- *
- * Thin wrapper around the most recent completed focus_review row. Surfaces
- * outcome (approved / gaps_found) and the summary so the close_loop
- * bookkeeper can correlate review findings with the anchored injection
- * sweep. Fails soft -- returns empty string when no completed review
- * exists yet.
- */
-registerSourceResolver('review.outcomes', async (context) => {
-    try {
-        const review = await getLatestCompletedFocusReview(context.focusId);
-        if (!review || !review.completedAt)
-            return '';
-        const outcome = review.outcome ?? 'unknown';
-        const summary = (review.summary ?? '').trim();
-        const lines = [
-            '## Review Outcomes',
-            '',
-            `**Outcome:** ${outcome}`,
-            `**Completed:** ${review.completedAt}`,
-        ];
-        if (summary.length > 0) {
-            lines.push('', summary);
-        }
-        else {
-            lines.push('', '_No summary provided._');
-        }
-        return lines.join('\n');
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] review.outcomes: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * focus.anchoring_injections
- *
- * Per-delivery report of every injection anchored to a delivery in the
- * focus. Used by the close_loop stage assembly so the bookkeeper team
- * lead can sweep each injection on its own merits:
- *
- *   - the delivery the injection is anchored to (name + id)
- *   - the injection statement, lifecycle status, and seq number
- *   - the UDE(s) the injection targets (via `targets` edges)
- *   - the FRT overlay statement on each UDE (what it becomes once verified)
- *   - the FRT overlay node type (e.g., UDE -> DE flip)
- *   - "expected reality change" -- diff between current statement and FRT
- *     overlay statement, surfaced per target so the agent can check whether
- *     the worktree evidence supports the flip
- *
- * Query path:
- *   org_nodes (type=delivery, focus_id=X) -> injection_id ->
- *     reality_tree_nodes (injection) -> reality_tree_edges (targets) ->
- *       reality_tree_nodes (UDE / target)
- *
- * Returns empty string when the focus has no deliveries with injection
- * anchors. Fails soft on API errors.
- */
-registerSourceResolver('focus.anchoring_injections', async (context) => {
-    try {
-        const deliveries = await getFocusDeliveries(context.focusId);
-        const anchored = deliveries.filter((d) => typeof d.injectionId === 'string' && d.injectionId.length > 0);
-        if (anchored.length === 0)
-            return '';
-        const injectionIds = anchored.map((d) => d.injectionId);
-        const bundles = await fetchInjectionBundles(injectionIds);
-        if (bundles.size === 0)
-            return '';
-        // Cache nodes+edges per tree so we don't fetch them once per delivery
-        // when multiple injections share a tree.
-        const treeNodesCache = new Map();
-        const treeEdgesCache = new Map();
-        async function loadTree(treeId) {
-            let nodes = treeNodesCache.get(treeId);
-            let edges = treeEdgesCache.get(treeId);
-            if (!nodes || !edges) {
-                const [nodesResp, edgesResp] = await Promise.all([
-                    callApi('reality_tree_node_list', { treeId, status: 'active' }),
-                    callApi('reality_tree_edge_list', { treeId }),
-                ]);
-                nodes = nodesResp.items ?? [];
-                edges = edgesResp.items ?? [];
-                treeNodesCache.set(treeId, nodes);
-                treeEdgesCache.set(treeId, edges);
-            }
-            return { nodes, edges };
-        }
-        const sections = [];
-        for (const delivery of anchored) {
-            const injectionId = delivery.injectionId;
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            const inj = bundle.injection;
-            const treeId = inj.realityTreeId;
-            const { nodes, edges } = await loadTree(treeId);
-            const nodeById = new Map();
-            for (const n of nodes)
-                nodeById.set(n.id, n);
-            const statusTag = inj.injectionStatus ? ` [${inj.injectionStatus}]` : '';
-            const lines = [
-                `### ${delivery.name}`,
-                '',
-                `- **Anchored delivery:** ${delivery.name} (\`${delivery.id}\`)`,
-                `- **Injection:** #${inj.seq} ${inj.statement}${statusTag}`,
-                `- **Tree:** ${bundle.treeName}`,
-            ];
-            if (inj.dissolvesObstacle) {
-                lines.push(`- **Dissolves obstacle:** ${inj.dissolvesObstacle}`);
-            }
-            // Walk targets edges from this injection -> target UDE/entity nodes.
-            const targetIds = edges
-                .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionId)
-                .map((e) => e.toNodeId);
-            if (targetIds.length === 0) {
-                lines.push('', '_No target UDEs declared. Injection has no `targets` edges._');
-            }
-            else {
-                lines.push('', '**Target UDEs and expected reality change:**');
-                for (const targetId of targetIds) {
-                    const target = nodeById.get(targetId);
-                    if (!target)
-                        continue;
-                    const currentType = target.nodeType;
-                    const frtStatement = target.frtStatement?.trim() ?? '';
-                    const frtType = target.frtNodeType?.trim() ?? '';
-                    const targetHeader = `- **#${target.seq} Target UDE (${currentType}):** ${target.statement}`;
-                    lines.push(targetHeader);
-                    if (frtStatement.length > 0) {
-                        const overlayType = frtType.length > 0 ? frtType : currentType;
-                        lines.push(`  - **FRT overlay (${overlayType}):** ${frtStatement}`);
-                        lines.push(`  - **Expected reality change:** "${target.statement}" -> "${frtStatement}"`);
-                    }
-                    else if (frtType.length > 0) {
-                        lines.push(`  - **FRT overlay (${frtType}):** _(type flip only, no statement rewrite)_`);
-                    }
-                    else {
-                        lines.push('  - _No FRT overlay set on this target._');
-                    }
-                }
-            }
-            sections.push(lines.join('\n'));
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Anchoring Injections (close-loop sweep)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] focus.anchoring_injections: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * reality.metrics
- *
- * Fetches focus reality metrics + trajectory projections from the edge function.
- * Formats as markdown for agent consumption (Wire B of the differential pair).
- */
-registerSourceResolver('reality.metrics', async (context) => {
-    try {
-        const result = await callApi('reality_metrics_focus', {
-            focusId: context.focusId,
-        });
-        const m = result.metrics;
-        if (!m)
-            return '';
-        const parts = ['## Execution Reality\n'];
-        // Delivery status breakdown
-        parts.push('### Delivery Status');
-        parts.push(`- Planning: ${m.deliveries_planning} | Queued: ${m.deliveries_queued} | Coding: ${m.deliveries_coding} | Verify: ${m.deliveries_verify} | Done: ${m.deliveries_done} (${m.total_deliveries} total)`);
-        // Issue throughput
-        parts.push('\n### Issue Throughput');
-        parts.push(`- Total: ${m.total_issues} | To Do: ${m.issues_todo} | In Progress: ${m.issues_in_progress} | Done: ${m.issues_done} | Blocked: ${m.issues_blocked}`);
-        parts.push(`- Completed: ${m.issues_done_7d} (7d) | ${m.issues_done_14d} (14d) | ${m.issues_done_30d} (30d)`);
-        if (m.avg_cycle_time_days !== null) {
-            parts.push(`- Avg cycle time: ${m.avg_cycle_time_days} days`);
-        }
-        if (m.blocked_count > 0) {
-            parts.push(`- Blocked: ${m.blocked_count} issues${m.avg_blocked_duration_days !== null ? `, avg duration ${m.avg_blocked_duration_days} days` : ''}`);
-        }
-        // Agent cost
-        parts.push('\n### Agent Activity');
-        parts.push(`- Sessions: ${m.session_count} | Cost: $${m.total_agent_cost.toFixed(2)} | Escalations: ${m.escalation_count}`);
-        if (m.last_session_at) {
-            parts.push(`- Last session: ${m.last_session_at}`);
-        }
-        // Git merge metrics
-        if (m.merge_count !== undefined) {
-            parts.push('\n### Git Activity');
-            parts.push(`- Total merges: ${m.merge_count} | Last 7d: ${m.merges_7d ?? 0} | Last 30d: ${m.merges_30d ?? 0}`);
-            if (m.last_merge_at) {
-                parts.push(`- Last merge: ${m.last_merge_at}`);
-            }
-        }
-        // Trajectory projections
-        const comp = result.projections?.completion;
-        const cost = result.projections?.cost;
-        if (comp || cost) {
-            parts.push('\n## Trajectory Projections\n');
-        }
-        if (comp) {
-            parts.push('### Completion Forecast');
-            if (comp.status === 'complete') {
-                parts.push('- Status: **complete** (all issues done)');
-            }
-            else if (comp.status === 'stalled') {
-                parts.push(`- Status: **stalled** -- ${comp.stalledReason || 'no recent throughput'}`);
-                parts.push(`- Remaining issues: ${comp.remainingIssues}`);
-            }
-            else {
-                parts.push(`- Projected completion: ${comp.projectedCompletionDate ? new Date(comp.projectedCompletionDate).toISOString().split('T')[0] : 'unknown'}`);
-                parts.push(`- Days remaining: ${comp.daysRemaining}`);
-                parts.push(`- Velocity: ${comp.velocity} issues/day (${comp.windowDays}d window, ${comp.completedInWindow} completed)`);
-                parts.push(`- Confidence: ${comp.confidence}`);
-                parts.push(`- Remaining issues: ${comp.remainingIssues}`);
-            }
-        }
-        if (cost) {
-            parts.push('\n### Cost Forecast');
-            parts.push(`- Cost to date: $${cost.costToDate.toFixed(2)}`);
-            parts.push(`- Burn rate: $${cost.burnRatePerDay.toFixed(2)}/day`);
-            if (cost.avgCostPerIssue !== null) {
-                parts.push(`- Avg cost per issue: $${cost.avgCostPerIssue.toFixed(2)}`);
-            }
-            if (cost.projectedTotalCost !== null) {
-                parts.push(`- Projected total: $${cost.projectedTotalCost.toFixed(2)} ($${cost.projectedRemainingCost?.toFixed(2)} remaining)`);
-            }
-        }
-        return parts.join('\n');
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] reality.metrics: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * reality.projections
- *
- * Compact format: just the forecasted outcomes for quick delta computation.
- */
-registerSourceResolver('reality.projections', async (context) => {
-    try {
-        const result = await callApi('reality_metrics_focus', {
-            focusId: context.focusId,
-        });
-        const comp = result.projections?.completion;
-        const cost = result.projections?.cost;
-        if (!comp && !cost)
-            return '';
-        const lines = ['## Trajectory Projections\n'];
-        if (comp) {
-            if (comp.status === 'complete') {
-                lines.push('- Completion: **complete**');
-            }
-            else if (comp.status === 'stalled') {
-                lines.push(`- Completion: **stalled** (${comp.remainingIssues} remaining)`);
-            }
-            else {
-                lines.push(`- Completion: ${comp.projectedCompletionDate ? new Date(comp.projectedCompletionDate).toISOString().split('T')[0] : '?'} (${comp.daysRemaining}d, confidence ${comp.confidence})`);
-            }
-        }
-        if (cost) {
-            if (cost.projectedTotalCost !== null) {
-                lines.push(`- Cost: $${cost.costToDate.toFixed(2)} spent, $${cost.projectedTotalCost.toFixed(2)} projected total`);
-            }
-            else {
-                lines.push(`- Cost: $${cost.costToDate.toFixed(2)} spent (insufficient data to project)`);
-            }
-        }
-        return lines.join('\n');
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] reality.projections: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.documents
- *
- * Fetches force-ranked loop documents for the focus's entity layer.
- * Returns formatted markdown with ranked documents.
- * Optional param: count (limit to top N).
- */
-registerSourceResolver('loop.documents', async (context, params) => {
-    try {
-        const limit = params.count ? parseInt(params.count, 10) : 50;
-        const result = await callApi('loop_document_list', {
-            entityType: 'focus',
-            entityId: context.focusId,
-            detail: 'full',
-            limit,
-        });
-        const docs = result.items;
-        if (!docs || docs.length === 0)
-            return '';
-        const sections = docs.map((doc, i) => `### ${i + 1}. ${doc.title}\n\n${doc.content}`);
-        return `## Loop Documents\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] loop.documents: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.questions
- *
- * Fetches fixed + generated questions with current answers for the entity layer.
- * Returns formatted markdown: fixed questions first, then generated in rank order.
- */
-registerSourceResolver('loop.questions', async (context) => {
-    try {
-        const result = await callApi('loop_question_list', {
-            entityType: 'focus',
-            entityId: context.focusId,
-            detail: 'full',
-        });
-        const questions = result.items;
-        if (!questions || questions.length === 0)
-            return '';
-        const fixed = questions.filter((q) => q.questionType === 'fixed');
-        const generated = questions.filter((q) => q.questionType === 'generated');
-        const formatQuestion = async (q) => {
-            try {
-                const answerResult = await callApi('loop_answer_get', {
-                    questionId: q.id,
-                });
-                const answer = answerResult.answer?.content || '_No answer yet._';
-                return `**Q:** ${q.text}\n**A:** ${answer}`;
-            }
-            catch {
-                return `**Q:** ${q.text}\n**A:** _No answer yet._`;
-            }
-        };
-        const parts = [];
-        if (fixed.length > 0) {
-            const fixedLines = await Promise.all(fixed.map(formatQuestion));
-            parts.push(`### Fixed Questions\n\n${fixedLines.join('\n\n')}`);
-        }
-        if (generated.length > 0) {
-            const generatedLines = await Promise.all(generated.map(formatQuestion));
-            parts.push(`### Generated Questions\n\n${generatedLines.join('\n\n')}`);
-        }
-        return `## Loop Questions\n\n${parts.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] loop.questions: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.persona
- *
- * Fetches the active persona for the entity's loop layer.
- * Returns the raw "You are..." prompt text, or empty string if none set.
- *
- * Stage variants:
- *   - `loop.persona(variant=close_loop)` -- returns the close-loop bookkeeper
- *     persona (from team-prompt-base.buildCloseLoopBookkeeperPersona). This
- *     is a built-in variant; the stored persona on the focus is ignored so
- *     close_loop stage spawns always carry the asymmetric, no-third-option
- *     bookkeeper framing regardless of what the human persona on the focus
- *     looks like. The close_loop stage dispatcher composes its assembly
- *     recipe with `loop.persona(variant=close_loop)` so the team lead
- *     receives this exact text.
- *
- * No-variant call returns the human-authored persona stored on the focus.
- */
-registerSourceResolver('loop.persona', async (context, params) => {
-    if (params.variant === 'close_loop') {
-        return buildCloseLoopBookkeeperPersona();
-    }
-    try {
-        const result = await callApi('loop_persona_get', {
-            entityType: 'focus',
-            entityId: context.focusId,
-        });
-        if (!result.persona || !result.persona.content)
-            return '';
-        return result.persona.content;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] loop.persona: failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * Fetch loop data (persona + documents + Q&A) for a single layer.
- * Returns formatted markdown sections, or empty string if no data exists.
- */
-async function fetchLoopLayerContext(entityType, entityId, layerLabel) {
-    const parts = [];
-    // Persona
-    try {
-        const personaResult = await callApi('loop_persona_get', {
-            entityType,
-            entityId,
-        });
-        if (personaResult.persona?.content) {
-            parts.push(`**Persona:** ${personaResult.persona.content}`);
-        }
-    }
-    catch {
-        // No persona -- not an error
-    }
-    // Force-ranked documents
-    try {
-        const docsResult = await callApi('loop_document_list', {
-            entityType,
-            entityId,
-            detail: 'full',
-            limit: 50,
-        });
-        if (docsResult.items?.length > 0) {
-            const docLines = docsResult.items.map((doc, i) => `#### ${i + 1}. ${doc.title}\n\n${doc.content}`);
-            parts.push(`### Documents\n\n${docLines.join('\n\n')}`);
-        }
-    }
-    catch {
-        // No documents -- not an error
-    }
-    // Questions + answers
-    try {
-        const qResult = await callApi('loop_question_list', {
-            entityType,
-            entityId,
-            detail: 'full',
-        });
-        if (qResult.items?.length > 0) {
-            const fixed = qResult.items.filter((q) => q.questionType === 'fixed');
-            const generated = qResult.items.filter((q) => q.questionType === 'generated');
-            const formatQ = async (q) => {
-                try {
-                    const aResult = await callApi('loop_answer_get', { questionId: q.id });
-                    const answer = aResult.answer?.content || '_No answer yet._';
-                    return `**Q:** ${q.text}\n**A:** ${answer}`;
-                }
-                catch {
-                    return `**Q:** ${q.text}\n**A:** _No answer yet._`;
-                }
-            };
-            const qParts = [];
-            if (fixed.length > 0) {
-                const fixedLines = await Promise.all(fixed.map(formatQ));
-                qParts.push(`#### Fixed Questions\n\n${fixedLines.join('\n\n')}`);
-            }
-            if (generated.length > 0) {
-                const genLines = await Promise.all(generated.map(formatQ));
-                qParts.push(`#### Agent-Generated Questions\n\n${genLines.join('\n\n')}`);
-            }
-            if (qParts.length > 0) {
-                parts.push(`### Questions & Answers\n\n${qParts.join('\n\n')}`);
-            }
-        }
-    }
-    catch {
-        // No questions -- not an error
-    }
-    if (parts.length === 0)
-        return '';
-    return `## ${layerLabel} Loop\n\n${parts.join('\n\n')}`;
-}
-/**
- * loop.context
- *
- * Composite resolver that fetches persona + force-ranked documents + Q&A
- * for one or more loop layers. Provides complete loop context for agent
- * prompt injection.
- *
- * Optional param: layer
- *   - "product": product-level loop only
- *   - "focus": focus-level loop only
- *   - "delivery": delivery-level loop only
- *   - omitted: all three layers (product + focus + delivery)
- *
- * Loop data at focus and delivery layers is scoped to the product ID
- * (layer-based architecture, not per-record).
- */
-registerSourceResolver('loop.context', async (context, params) => {
-    const layerFilter = params.layer;
-    const layers = [];
-    if (!layerFilter || layerFilter === 'product') {
-        layers.push({ entityType: 'product', entityId: context.productId, label: 'Product' });
-    }
-    if (!layerFilter || layerFilter === 'focus') {
-        layers.push({ entityType: 'focus', entityId: context.productId, label: 'Focus' });
-    }
-    if (!layerFilter || layerFilter === 'delivery') {
-        layers.push({ entityType: 'delivery', entityId: context.productId, label: 'Delivery' });
-    }
-    const sections = await Promise.all(layers.map(l => fetchLoopLayerContext(l.entityType, l.entityId, l.label)));
-    const nonEmpty = sections.filter(s => s.trim());
-    if (nonEmpty.length === 0)
-        return '';
-    return nonEmpty.join('\n\n');
-});
-/**
- * delivery.tech_context
- *
- * Concatenates the techContext field of every delivery in the focus.
- */
-registerSourceResolver('delivery.tech_context', async (context) => {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    if (deliveries.length === 0)
-        return '';
-    const sections = deliveries
-        .filter((d) => d.techContext)
-        .map((d) => `### ${d.name}\n\n${d.techContext}`);
-    if (sections.length === 0)
-        return '';
-    return `## Technical Context\n\n${sections.join('\n\n')}`;
-});
-export const CRT_DUMP_BUDGET_CHARS = 10_000;
-const NODE_TYPE_HEADINGS = {
-    entity: 'Entities',
-    undesired_effect: 'Undesired Effects (UDEs)',
-    desired_effect: 'Desired Effects (FRT)',
-    injection: 'Injections (FRT)',
-};
-const NODE_TYPE_ORDER = [
-    'entity',
-    'undesired_effect',
-    'desired_effect',
-    'injection',
-];
-const INJECTION_STATUS_ORDER = [
-    'proposed',
-    'in_progress',
-    'realized',
-    'verified',
-];
-const INJECTION_STATUS_HEADINGS = {
-    proposed: 'Injections - Proposed',
-    in_progress: 'Injections - In Progress',
-    realized: 'Injections - Realized',
-    verified: 'Injections - Verified',
-};
-function renderNodeLine(n, opts = {}) {
-    const tags = [];
-    if (n.injectionStatus && !opts.suppressInjectionStatusTag)
-        tags.push(n.injectionStatus);
-    if (n.viewScope !== 'both')
-        tags.push(n.viewScope);
-    const tagSuffix = tags.length > 0 ? ` [${tags.join(', ')}]` : '';
-    const evidence = n.evidence ? `\n  evidence: ${n.evidence.replace(/\n/g, ' ')}` : '';
-    const dissolves = n.dissolvesObstacle ? `\n  dissolves: ${n.dissolvesObstacle.replace(/\n/g, ' ')}` : '';
-    const frtOverlay = n.frtStatement && n.frtStatement !== n.statement
-        ? `\n  frt: ${n.frtStatement.replace(/\n/g, ' ')}`
-        : '';
-    return `- #${n.seq} ${n.statement}${tagSuffix}${evidence}${dissolves}${frtOverlay}`;
-}
-function renderEdgeLine(e, nodeBySeq) {
-    const from = nodeBySeq.get(e.fromNodeId);
-    const to = nodeBySeq.get(e.toNodeId);
-    const fromRef = from ? `#${from.seq}` : '?';
-    const toRef = to ? `#${to.seq}` : '?';
-    return `- ${fromRef} →[${e.edgeType}]→ ${toRef}`;
-}
-export function renderRealityTreeDump(tree, nodes, edges, budgetChars) {
-    if (nodes.length === 0)
-        return '';
-    const nodeById = new Map();
-    for (const n of nodes)
-        nodeById.set(n.id, n);
-    const sections = [];
-    sections.push(`### Tree: ${tree.name}`);
-    if (tree.description)
-        sections.push(tree.description);
-    const grouped = {
-        entity: [], undesired_effect: [], desired_effect: [], injection: [],
-    };
-    for (const n of nodes)
-        grouped[n.nodeType].push(n);
-    for (const list of Object.values(grouped))
-        list.sort((a, b) => a.seq - b.seq);
-    for (const t of NODE_TYPE_ORDER) {
-        const list = grouped[t];
-        if (list.length === 0)
-            continue;
-        if (t === 'injection') {
-            const byStatus = new Map();
-            const unstatused = [];
-            for (const inj of list) {
-                if (inj.injectionStatus) {
-                    const bucket = byStatus.get(inj.injectionStatus) ?? [];
-                    bucket.push(inj);
-                    byStatus.set(inj.injectionStatus, bucket);
-                }
-                else {
-                    unstatused.push(inj);
-                }
-            }
-            for (const status of INJECTION_STATUS_ORDER) {
-                const bucket = byStatus.get(status);
-                if (!bucket || bucket.length === 0)
-                    continue;
-                sections.push(`\n#### ${INJECTION_STATUS_HEADINGS[status]} (${bucket.length})`);
-                sections.push(bucket.map((n) => renderNodeLine(n, { suppressInjectionStatusTag: true })).join('\n'));
-            }
-            if (unstatused.length > 0) {
-                sections.push(`\n#### Injections - Unstatused (${unstatused.length})`);
-                sections.push(unstatused.map((n) => renderNodeLine(n)).join('\n'));
-            }
-            continue;
-        }
-        sections.push(`\n#### ${NODE_TYPE_HEADINGS[t]} (${list.length})`);
-        sections.push(list.map((n) => renderNodeLine(n)).join('\n'));
-    }
-    if (edges.length > 0) {
-        const causal = edges.filter((e) => e.edgeType === 'sufficient' || e.edgeType === 'and' || e.edgeType === 'targets');
-        if (causal.length > 0) {
-            sections.push(`\n#### Causal Edges (${causal.length})`);
-            sections.push(causal.map((e) => renderEdgeLine(e, nodeById)).join('\n'));
-        }
-    }
-    // Truncate to budget — preserve the heading + at least one section.
-    let acc = '';
-    for (const section of sections) {
-        const candidate = acc.length === 0 ? section : `${acc}\n${section}`;
-        if (candidate.length > budgetChars && acc.length > 0) {
-            acc += '\n\n_(truncated for token budget)_';
-            break;
-        }
-        acc = candidate;
-    }
-    return acc;
-}
-/**
- * focus.reality_tree
- *
- * Renders the focus's reality tree(s) as markdown for static-inspection
- * agents (ai_inspection verification, drift detectors). Groups nodes by
- * type, lists causal edges, surfaces injection lifecycle status. Token
- * budget ~10k chars; truncates with a marker if exceeded.
- *
- * This is the CRT dump the ai_inspection runner consumes alongside the
- * injection's frt_statement and the delivery diff. It is intentionally
- * verbose so the runner can reason about which CRT statements are at
- * stake without re-querying.
- */
-export const FOCUS_REALITY_TREE_EMPTY_STATE = '## Focus Reality Tree\n\n_No active reality tree for this focus._ ' +
-    'The intent-vs-reality graph (CRT + FRT overlays) has not been built yet -- ' +
-    'walk the focus statement and capture UDEs + entities before scoping further work.';
-registerSourceResolver('focus.reality_tree', async (context) => {
-    try {
-        const treesResp = await callApi('reality_tree_list', {
-            focusId: context.focusId,
-        });
-        const trees = (treesResp.items ?? []).filter((t) => t.status === 'active');
-        if (trees.length === 0)
-            return FOCUS_REALITY_TREE_EMPTY_STATE;
-        const sections = [];
-        let used = 0;
-        for (const tree of trees) {
-            if (used >= CRT_DUMP_BUDGET_CHARS)
-                break;
-            const remaining = CRT_DUMP_BUDGET_CHARS - used;
-            const [nodesResp, edgesResp] = await Promise.all([
-                callApi('reality_tree_node_list', { treeId: tree.id, status: 'active' }),
-                callApi('reality_tree_edge_list', { treeId: tree.id }),
-            ]);
-            const dump = renderRealityTreeDump(tree, nodesResp.items ?? [], edgesResp.items ?? [], remaining);
-            if (dump.length === 0)
-                continue;
-            sections.push(dump);
-            used += dump.length;
-        }
-        if (sections.length === 0)
-            return FOCUS_REALITY_TREE_EMPTY_STATE;
-        return `## Focus Reality Tree (CRT + FRT overlays)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly-engine] focus.reality_tree: failed: ${err.message}`);
-        return '';
-    }
-});
-// ── Per-delivery FRT context resolvers (loop.*) ─────────────────────
-//
-// These resolvers operate per-delivery: they look up each delivery in
-// context.deliveryIds, follow its delivery.injection_id to the
-// reality-tree injection node, and render the surrounding FRT context
-// the agent needs to know "what FRT statement this delivery is meant
-// to flip, and which UDEs flip upstream as a result."
-//
-// All resolvers fail-soft: errors return '' and log to console.warn.
-// When a delivery has no injection link (injectionId is null/empty),
-// it contributes nothing to the output -- the resolver returns ''
-// rather than rendering an empty section.
-/** Maximum BFS depth for upstream UDE walk in loop.upstream_udes. */
-const MAX_UPSTREAM_DEPTH = 3;
-/**
- * Walk context.deliveryIds, return [deliveryId, injectionId] pairs for those
- * with non-empty injection links. Empty array on lookup failure.
- */
-async function getDeliveryInjectionPairs(context) {
-    const deliveries = await getFocusDeliveries(context.focusId);
-    const wantedIds = new Set(context.deliveryIds);
-    return deliveries
-        .filter((d) => wantedIds.has(d.id))
-        .filter((d) => typeof d.injectionId === 'string' && d.injectionId.length > 0)
-        .map((d) => ({ deliveryId: d.id, deliveryName: d.name, injectionId: d.injectionId }));
-}
-/**
- * Fetch a batch of injection nodes by their IDs via reality_tree_injection_context.
- * Returns a Map keyed by injection node id.
- */
-async function fetchInjectionBundles(injectionIds) {
-    const out = new Map();
-    if (injectionIds.length === 0)
-        return out;
-    const resp = await callApi('reality_tree_injection_context', {
-        nodeIds: injectionIds,
-    });
-    for (const item of resp.items ?? []) {
-        out.set(item.injection.id, item);
-    }
-    return out;
-}
-/**
- * loop.injection
- *
- * For each delivery in context.deliveryIds with a linked injection, render
- * the injection node: statement, lifecycle status, what obstacle it
- * dissolves. Plain markdown; no upstream/downstream walk (that lives in
- * loop.upstream_udes / loop.expected_effects).
- */
-registerSourceResolver('loop.injection', async (context) => {
-    try {
-        const pairs = await getDeliveryInjectionPairs(context);
-        if (pairs.length === 0)
-            return '';
-        const bundles = await fetchInjectionBundles(pairs.map((p) => p.injectionId));
-        if (bundles.size === 0)
-            return '';
-        const sections = [];
-        for (const { deliveryName, injectionId } of pairs) {
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            const inj = bundle.injection;
-            const statusTag = inj.injectionStatus ? ` [${inj.injectionStatus}]` : '';
-            const dissolvesLine = inj.dissolvesObstacle
-                ? `- **Dissolves obstacle:** ${inj.dissolvesObstacle}`
-                : null;
-            const lines = [
-                `### ${deliveryName}`,
-                '',
-                `- **Injection:** ${inj.statement}${statusTag}`,
-                `- **Injection status:** ${inj.injectionStatus ?? '_not set_'}`,
-            ];
-            if (dissolvesLine)
-                lines.push(dissolvesLine);
-            sections.push(lines.join('\n'));
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Loop Injection (per delivery)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] loop.injection failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.frt_statement
- *
- * Returns the linked injection's frt_statement field as plain text
- * (no markdown headers). When multiple deliveries are in scope, the
- * statements are joined with blank lines so the agent sees each
- * delivery's target state. Empty string when no delivery has an
- * injection link or no injection has an FRT statement set.
- */
-registerSourceResolver('loop.frt_statement', async (context) => {
-    try {
-        const pairs = await getDeliveryInjectionPairs(context);
-        if (pairs.length === 0)
-            return '';
-        const bundles = await fetchInjectionBundles(pairs.map((p) => p.injectionId));
-        if (bundles.size === 0)
-            return '';
-        const lines = [];
-        for (const { injectionId } of pairs) {
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            const frt = bundle.injection.frtStatement;
-            if (typeof frt !== 'string' || frt.trim().length === 0)
-                continue;
-            lines.push(frt.trim());
-        }
-        if (lines.length === 0)
-            return '';
-        return lines.join('\n\n');
-    }
-    catch (err) {
-        console.warn(`[assembly] loop.frt_statement failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.expected_effects
- *
- * For each delivery with a linked injection, walk the 'targets' edges
- * from injection -> targeted UDE/obstacle nodes; for each target with an
- * FRT overlay (frt_statement and/or frt_node_type), render its current
- * statement and what it becomes in the FRT. Targets lacking overlays are
- * skipped (no expected effect to advertise).
- */
-registerSourceResolver('loop.expected_effects', async (context) => {
-    try {
-        const pairs = await getDeliveryInjectionPairs(context);
-        if (pairs.length === 0)
-            return '';
-        const bundles = await fetchInjectionBundles(pairs.map((p) => p.injectionId));
-        if (bundles.size === 0)
-            return '';
-        const sections = [];
-        for (const { deliveryName, injectionId } of pairs) {
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            // Fetch nodes + edges for this injection's tree so we can walk
-            // targets edges and inspect the targeted nodes' overlays.
-            const treeId = bundle.injection.realityTreeId;
-            const [nodesResp, edgesResp] = await Promise.all([
-                callApi('reality_tree_node_list', { treeId, status: 'active' }),
-                callApi('reality_tree_edge_list', { treeId }),
-            ]);
-            const nodes = nodesResp.items ?? [];
-            const edges = edgesResp.items ?? [];
-            const nodeById = new Map();
-            for (const n of nodes)
-                nodeById.set(n.id, n);
-            const targetIds = edges
-                .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionId)
-                .map((e) => e.toNodeId);
-            const targetLines = [];
-            for (const targetId of targetIds) {
-                const node = nodeById.get(targetId);
-                if (!node)
-                    continue;
-                const hasOverlay = (node.frtStatement && node.frtStatement.trim().length > 0)
-                    || (node.frtNodeType && node.frtNodeType.trim().length > 0);
-                if (!hasOverlay)
-                    continue;
-                const currentType = node.nodeType;
-                const frtType = node.frtNodeType ?? currentType;
-                const frtStatement = node.frtStatement ?? node.statement;
-                targetLines.push(`- #${node.seq} **Current (${currentType}):** ${node.statement}\n  **FRT (${frtType}):** ${frtStatement}`);
-            }
-            if (targetLines.length === 0)
-                continue;
-            sections.push(`### ${deliveryName}\n\n${targetLines.join('\n')}`);
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Expected Effects (per delivery)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] loop.expected_effects failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.upstream_udes
- *
- * For each delivery's injection, find the nodes that the injection
- * targets (via 'targets' edges), then BFS upstream from those targets
- * along causal edges ('sufficient' and 'and' edge kinds) up to
- * MAX_UPSTREAM_DEPTH hops. Returns a markdown list of upstream UDE/
- * entity nodes the injection is indirectly meant to address. Cycle-safe.
- */
-registerSourceResolver('loop.upstream_udes', async (context) => {
-    try {
-        const pairs = await getDeliveryInjectionPairs(context);
-        if (pairs.length === 0)
-            return '';
-        const bundles = await fetchInjectionBundles(pairs.map((p) => p.injectionId));
-        if (bundles.size === 0)
-            return '';
-        const sections = [];
-        for (const { deliveryName, injectionId } of pairs) {
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            const treeId = bundle.injection.realityTreeId;
-            const [nodesResp, edgesResp] = await Promise.all([
-                callApi('reality_tree_node_list', { treeId, status: 'active' }),
-                callApi('reality_tree_edge_list', { treeId }),
-            ]);
-            const nodes = nodesResp.items ?? [];
-            const edges = edgesResp.items ?? [];
-            const nodeById = new Map();
-            for (const n of nodes)
-                nodeById.set(n.id, n);
-            // Seed: the nodes the injection targets directly.
-            const seeds = edges
-                .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionId)
-                .map((e) => e.toNodeId);
-            if (seeds.length === 0)
-                continue;
-            // BFS upstream along causal edges: walk edges where to_node_id is
-            // in the current frontier; the from_node_id of those edges is the
-            // upstream node. Bounded by MAX_UPSTREAM_DEPTH and cycle-safe via
-            // visited set. Seeds themselves are excluded from output (we want
-            // their upstream, not the seeds).
-            const visited = new Set(seeds);
-            const collected = [];
-            let frontier = new Set(seeds);
-            for (let depth = 0; depth < MAX_UPSTREAM_DEPTH; depth++) {
-                if (frontier.size === 0)
-                    break;
-                const next = new Set();
-                for (const edge of edges) {
-                    if (edge.edgeType !== 'sufficient' && edge.edgeType !== 'and')
-                        continue;
-                    if (!frontier.has(edge.toNodeId))
-                        continue;
-                    const upId = edge.fromNodeId;
-                    if (visited.has(upId))
-                        continue;
-                    visited.add(upId);
-                    next.add(upId);
-                    const upNode = nodeById.get(upId);
-                    if (upNode)
-                        collected.push(upNode);
-                }
-                frontier = next;
-            }
-            if (collected.length === 0)
-                continue;
-            collected.sort((a, b) => a.seq - b.seq);
-            const lines = collected.map((n) => {
-                const typeTag = n.nodeType !== 'entity' ? ` [${n.nodeType}]` : '';
-                return `- #${n.seq} ${n.statement}${typeTag}`;
-            });
-            sections.push(`### ${deliveryName}\n\n${lines.join('\n')}`);
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Upstream UDEs (per delivery, max depth ${MAX_UPSTREAM_DEPTH})\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] loop.upstream_udes failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * loop.delivery_index
- *
- * The lead's per-delivery INDEX: one line per in-focus delivery with a linked
- * injection, of the form
- *   - <delivery> -> injection #<seq> -> Now: <ude> -> Target: <frt> -> pull: <call>
- * where the pull handle names telora_reality_tree_injection_context(seq=<seq>),
- * the on-demand call that returns the delivery's full differential.
- *
- * This REPLACES the bulk per-delivery push (loop.injection / loop.expected_effects /
- * loop.upstream_udes, each of which renders a full section per delivery-injection
- * pair) so the lead's context is flat in focus size -- one line per delivery, not
- * N full differentials. It is also the structural guarantee for the worker handoff:
- * the lead is always staring at each delivery's slice handle.
- */
-registerSourceResolver('loop.delivery_index', async (context) => {
-    try {
-        const pairs = await getDeliveryInjectionPairs(context);
-        if (pairs.length === 0)
-            return '';
-        const bundles = await fetchInjectionBundles(pairs.map((p) => p.injectionId));
-        if (bundles.size === 0)
-            return '';
-        const lines = [];
-        for (const { deliveryName, injectionId } of pairs) {
-            const bundle = bundles.get(injectionId);
-            if (!bundle)
-                continue;
-            const seq = bundle.injection.seq;
-            const nowTargets = bundle.nowTargets ?? [];
-            let nowTarget;
-            if (nowTargets.length > 0) {
-                const first = nowTargets[0];
-                const target = first.target && first.target.trim().length > 0
-                    ? first.target
-                    : '(no FRT overlay yet)';
-                nowTarget = `Now: ${first.now} -> Target: ${target}`;
-                if (nowTargets.length > 1)
-                    nowTarget += ` (+${nowTargets.length - 1} more)`;
-            }
-            else {
-                nowTarget = `(injection: ${bundle.injection.statement})`;
-            }
-            lines.push(`- ${deliveryName} -> injection #${seq} -> ${nowTarget} ` +
-                `-> pull: telora_reality_tree_injection_context(seq=${seq})`);
-        }
-        if (lines.length === 0)
-            return '';
-        const header = [
-            '## Per-Delivery Index',
-            '',
-            'One line per delivery: the injection it materializes, its Now->Target, and the',
-            'pull handle that returns the full differential on demand. This is your handoff',
-            'surface: when you spawn a worker for a delivery, call its pull handle',
-            '(telora_reality_tree_injection_context with the injection seq) and embed the',
-            "returned Now->Target in the worker's task prompt so the worker begins holding",
-            "its delivery's start->end context.",
-            '',
-        ];
-        return header.concat(lines).join('\n');
-    }
-    catch (err) {
-        console.warn(`[assembly] loop.delivery_index failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * Best-effort cycle window. Returns the previous cycle's completed_at as
- * the lower bound for "things that happened in the current cycle". Null
- * means "no prior cycle, include everything since focus start". Failures
- * fall back to null so a missing audit_runs table or transient API error
- * does not blank out the resolver output.
- */
-async function getAuditCycleLowerBound(focusId) {
-    try {
-        const result = await callApi('daemon_get_recent_audit_run_for_focus', { focusId });
-        return result.auditRun?.completedAt ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * retired_injections
- *
- * Lists injections retired in the focus's current audit cycle. Each entry
- * includes the dissolvesObstacle text and the UDE statements the injection
- * targeted (via 'targets' edges, looked up from the retired-injection's
- * tree). Failures fail soft -- return ''.
- */
-registerSourceResolver('retired_injections', async (context) => {
-    try {
-        const treesResp = await callApi('reality_tree_list', {
-            focusId: context.focusId,
-        });
-        const trees = (treesResp.items ?? []).filter((t) => t.status === 'active');
-        if (trees.length === 0)
-            return '';
-        const since = await getAuditCycleLowerBound(context.focusId);
-        const sections = [];
-        for (const tree of trees) {
-            const [retiredResp, edgesResp, nodesResp] = await Promise.all([
-                callApi('reality_tree_node_list', {
-                    treeId: tree.id, nodeType: 'injection', status: 'retired',
-                }),
-                callApi('reality_tree_edge_list', { treeId: tree.id }),
-                // Pull the active node universe so we can resolve target statements
-                // even if a target was itself retired alongside the injection.
-                callApi('reality_tree_node_list', { treeId: tree.id, status: 'active' }),
-            ]);
-            const retired = retiredResp.items ?? [];
-            if (retired.length === 0)
-                continue;
-            const filtered = since
-                ? retired.filter((n) => {
-                    // updated_at is not on the typed surface but the row carries it;
-                    // fall back to including the node if the field isn't present so
-                    // we don't accidentally drop a real retirement.
-                    const updatedAt = n.updatedAt;
-                    return !updatedAt || updatedAt >= since;
-                })
-                : retired;
-            if (filtered.length === 0)
-                continue;
-            const allNodes = [...(nodesResp.items ?? []), ...retired];
-            const nodeById = new Map();
-            for (const n of allNodes)
-                nodeById.set(n.id, n);
-            const targetsBySource = new Map();
-            for (const e of edgesResp.items ?? []) {
-                if (e.edgeType !== 'targets')
-                    continue;
-                const list = targetsBySource.get(e.fromNodeId) ?? [];
-                list.push(e.toNodeId);
-                targetsBySource.set(e.fromNodeId, list);
-            }
-            const lines = [`### Tree: ${tree.name}`];
-            for (const inj of filtered.sort((a, b) => a.seq - b.seq)) {
-                lines.push('', `- **#${inj.seq} ${inj.statement}**`);
-                if (inj.dissolvesObstacle) {
-                    lines.push(`  - dissolves: ${inj.dissolvesObstacle.replace(/\n/g, ' ')}`);
-                }
-                const targetIds = targetsBySource.get(inj.id) ?? [];
-                for (const tid of targetIds) {
-                    const t = nodeById.get(tid);
-                    if (!t)
-                        continue;
-                    lines.push(`  - target: #${t.seq} (${t.nodeType}) ${t.statement.replace(/\n/g, ' ')}`);
-                }
-            }
-            sections.push(lines.join('\n'));
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Retired Injections (current cycle)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] retired_injections failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * agent_session_summaries
- *
- * Returns the most recent agent_sessions.last_narration per delivery
- * within the focus, grouped by delivery name. Fails soft.
- */
-registerSourceResolver('agent_session_summaries', async (context) => {
-    try {
-        const result = await callApi('daemon_get_agent_session_summaries_for_focus', { focusId: context.focusId });
-        const summaries = result.summaries ?? [];
-        if (summaries.length === 0)
-            return '';
-        summaries.sort((a, b) => a.deliveryName.localeCompare(b.deliveryName));
-        const sections = summaries.map((s) => {
-            const at = s.lastNarrationAt ? ` (${s.lastNarrationAt})` : '';
-            const narration = s.lastNarration.trim() || '_no narration captured_';
-            return `### ${s.deliveryName}${at}\n\n${narration}`;
-        });
-        return `## Team Narrations (per delivery)\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] agent_session_summaries failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * agent_escalations
- *
- * Escalations filed against the focus's deliveries in the current cycle.
- * Window lower bound is the prior audit_runs.completed_at (best effort).
- */
-registerSourceResolver('agent_escalations', async (context) => {
-    try {
-        const since = await getAuditCycleLowerBound(context.focusId);
-        const params = { focusId: context.focusId };
-        if (since)
-            params.sinceIso = since;
-        const result = await callApi('daemon_get_agent_escalations_for_focus', params);
-        const escalations = result.escalations ?? [];
-        if (escalations.length === 0)
-            return '';
-        const lines = escalations.map((e) => {
-            const kindLabel = e.escalationKind ?? e.reasonType;
-            const description = e.description.replace(/\n/g, ' ');
-            const truncated = description.length > 240 ? `${description.slice(0, 237)}...` : description;
-            return `- **${kindLabel}** [${e.status}] (${e.createdAt}): ${truncated}`;
-        });
-        return `## Agent Escalations (current cycle)\n\n${lines.join('\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] agent_escalations failed: ${err.message}`);
-        return '';
-    }
-});
-/**
- * reality_tree.snapshot
- *
- * Returns the focus's reality tree(s) as a structured text dump for the
- * audit assessor. Same shape as focus.reality_tree but with the "CRT Dump"
- * heading renamed to "Snapshot" so the audit prompt distinguishes its
- * "current graph" input from other tree-related sections. Fails soft.
- */
-registerSourceResolver('reality_tree.snapshot', async (context) => {
-    try {
-        const treesResp = await callApi('reality_tree_list', {
-            focusId: context.focusId,
-        });
-        const trees = (treesResp.items ?? []).filter((t) => t.status === 'active');
-        if (trees.length === 0)
-            return '';
-        const sections = [];
-        let used = 0;
-        for (const tree of trees) {
-            if (used >= CRT_DUMP_BUDGET_CHARS)
-                break;
-            const remaining = CRT_DUMP_BUDGET_CHARS - used;
-            const [nodesResp, edgesResp] = await Promise.all([
-                callApi('reality_tree_node_list', { treeId: tree.id, status: 'active' }),
-                callApi('reality_tree_edge_list', { treeId: tree.id }),
-            ]);
-            const dump = renderRealityTreeDump(tree, nodesResp.items ?? [], edgesResp.items ?? [], remaining);
-            if (dump.length === 0)
-                continue;
-            sections.push(dump);
-            used += dump.length;
-        }
-        if (sections.length === 0)
-            return '';
-        return `## Reality Tree Snapshot\n\n${sections.join('\n\n')}`;
-    }
-    catch (err) {
-        console.warn(`[assembly] reality_tree.snapshot failed: ${err.message}`);
-        return '';
-    }
-});
+ * This module is now a thin shim. The resolver bodies live in `resolvers/`
+ * (one module per resolver) with cross-resolver helpers in `resolvers/shared/`.
+ * Importing this module loads `resolvers/index.js`, whose side-effect imports
+ * register ALL resolvers at module load time -- exactly as before.
+ *
+ * The named public surface (helpers + types consumed by other source files and
+ * tests) is re-exported from the barrel so existing imports of
+ * `assembly-resolvers.js` keep working unchanged:
+ *   - values: MAX_DIFF_BYTES, getGitDiff, CRT_DUMP_BUDGET_CHARS,
+ *     renderRealityTreeDump, FOCUS_REALITY_TREE_EMPTY_STATE
+ *   - types: RealityTreeRow, RealityTreeListResponse, RealityNodeRow,
+ *     RealityEdgeRow, NodeListResponse, EdgeListResponse
+ */
+import './resolvers/index.js';
+export * from './resolvers/index.js';
 //# sourceMappingURL=assembly-resolvers.js.map