sidecar-cli 0.1.4 → 0.1.5-beta.2

package/dist/lib/banner.js

@@ -3,7 +3,23 @@ export const SIDECAR_TAGLINE = 'project memory for your work';
 export function bannerDisabled(argv = process.argv) {
     return process.env.SIDECAR_NO_BANNER === '1' || argv.includes('--no-banner');
 }
-export function renderBanner(includeTagline = true) {
+export function renderBanner(variant = 'compact', includeTagline = true) {
+    if (variant === 'block') {
+        const blockLines = [
+            '  [■]─[▪]',
+            '  ███████╗██╗██████╗ ███████╗ ██████╗ █████╗ ██████╗',
+            '  ██╔════╝██║██╔══██╗██╔════╝██╔════╝██╔══██╗██╔══██╗',
+            '  ███████╗██║██║  ██║█████╗  ██║     ███████║██████╔╝',
+            '  ╚════██║██║██║  ██║██╔══╝  ██║     ██╔══██║██╔══██╗',
+            '  ███████║██║██████╔╝███████╗╚██████╗██║  ██║██║  ██║',
+            '  ╚══════╝╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝',
+        ];
+        if (includeTagline) {
+            blockLines.push('');
+            blockLines.push(SIDECAR_TAGLINE);
+        }
+        return blockLines.join('\n');
+    }
     const lines = [SIDECAR_MARK, ''];
     if (includeTagline) {
         lines.push(SIDECAR_TAGLINE);

package/dist/lib/color.js

@@ -0,0 +1,30 @@
+export function isColorEnabled() {
+    const forced = process.env.FORCE_COLOR === '1' || process.env.FORCE_COLOR === 'true';
+    const hasTty = Boolean(process.stdout.isTTY) || forced;
+    return hasTty && !process.env.NO_COLOR && !process.argv.includes('--json');
+}
+const codes = {
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+    reset: '\x1b[0m',
+};
+// Evaluate isColorEnabled() on every call so late changes to NO_COLOR,
+// FORCE_COLOR, or --json (e.g. tests flipping env vars) take effect.
+// Cheap: two env-var reads plus an argv scan.
+function wrap(code) {
+    return (s) => (isColorEnabled() ? code + s + codes.reset : s);
+}
+export const c = {
+    bold: wrap(codes.bold),
+    dim: wrap(codes.dim),
+    red: wrap(codes.red),
+    green: wrap(codes.green),
+    yellow: wrap(codes.yellow),
+    cyan: wrap(codes.cyan),
+    magenta: wrap(codes.magenta),
+};

package/dist/lib/format.js

@@ -2,7 +2,13 @@ export function nowIso() {
     return new Date().toISOString();
 }
 export function humanTime(iso) {
-    return new Date(iso).toLocaleString();
+    const date = new Date(iso);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}`;
 }
 export function splitCsv(input) {
     if (!input)

package/dist/lib/table.js

@@ -0,0 +1,97 @@
+import { isColorEnabled, c } from './color.js';
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function visibleLength(s) {
+    return stripAnsi(s).length;
+}
+function ellipsizeMiddle(s, maxLen) {
+    const stripped = stripAnsi(s);
+    if (stripped.length <= maxLen)
+        return s;
+    const half = Math.floor((maxLen - 1) / 2);
+    return stripped.slice(0, half) + '…' + stripped.slice(stripped.length - half);
+}
+function pad(s, width, align = 'left') {
+    const visLen = visibleLength(s);
+    const padding = Math.max(0, width - visLen);
+    if (align === 'left') {
+        return s + ' '.repeat(padding);
+    }
+    return ' '.repeat(padding) + s;
+}
+export function renderTable(columns, rows, opts = {}) {
+    const indent = opts.indent || '';
+    const isTty = isColorEnabled();
+    if (rows.length === 0) {
+        return;
+    }
+    // Compute natural widths
+    const widths = {};
+    for (const col of columns) {
+        let w = col.label.length;
+        for (const row of rows) {
+            const val = row[col.key] || '';
+            w = Math.max(w, visibleLength(val));
+        }
+        widths[col.key] = w;
+    }
+    // Clamp by min/max
+    for (const col of columns) {
+        if (col.minWidth)
+            widths[col.key] = Math.max(widths[col.key], col.minWidth);
+        if (col.maxWidth)
+            widths[col.key] = Math.min(widths[col.key], col.maxWidth);
+    }
+    // If total > terminal width, reduce widest flexible column via middle-ellipsis
+    const terminalWidth = process.stdout.columns || 120;
+    const maxContentWidth = Math.max(0, terminalWidth - indent.length - (columns.length - 1) * 2);
+    let totalWidth = columns.reduce((sum, col) => sum + widths[col.key], 0) + (columns.length - 1) * 2;
+    if (totalWidth > maxContentWidth) {
+        // Find widest flexible column
+        let widestIdx = -1;
+        let widestWidth = -1;
+        for (let i = 0; i < columns.length; i++) {
+            const col = columns[i];
+            if (!col.maxWidth || widths[col.key] < col.maxWidth) {
+                if (widths[col.key] > widestWidth) {
+                    widestWidth = widths[col.key];
+                    widestIdx = i;
+                }
+            }
+        }
+        if (widestIdx >= 0) {
+            const col = columns[widestIdx];
+            const reductionNeeded = totalWidth - maxContentWidth;
+            widths[col.key] = Math.max(col.minWidth || 1, widths[col.key] - reductionNeeded);
+        }
+    }
+    // Render header
+    const headerParts = columns.map((col) => pad(col.label, widths[col.key], col.align));
+    const headerLine = indent + headerParts.join('  ');
+    if (isTty) {
+        console.log(c.bold(headerLine));
+        const ruleWidth = visibleLength(stripAnsi(headerLine));
+        console.log(indent + '─'.repeat(ruleWidth));
+    }
+    else {
+        console.log(headerLine);
+        const ruleWidth = visibleLength(stripAnsi(headerLine));
+        console.log(indent + '-'.repeat(ruleWidth));
+    }
+    // Render rows
+    for (const row of rows) {
+        const parts = columns.map((col) => {
+            let val = row[col.key] || '';
+            if (col.format) {
+                val = col.format(val, row);
+            }
+            // Apply ellipsis if needed
+            if (visibleLength(val) > widths[col.key]) {
+                val = ellipsizeMiddle(val, widths[col.key]);
+            }
+            return pad(val, widths[col.key], col.align);
+        });
+        console.log(indent + parts.join('  '));
+    }
+}

package/dist/prompts/packet-sections.js

@@ -0,0 +1,203 @@
+// Adapter from TaskPacket → CompileSectionsInput. Mirrors the legacy packet
+// layout exactly so `sidecar run <task-id>` produces byte-identical prompts
+// after the compiler refactor. Snapshot-guarded in `prompts.compat.test`.
+import { nowIso } from '../lib/format.js';
+import { PROMPT_PREFERENCE_DEFAULTS } from '../runners/config.js';
+function finalResponseFormat(runner) {
+    if (runner === 'codex') {
+        return [
+            '- Start with a one-line outcome summary.',
+            '- List files changed with concise reasons.',
+            '- Include validation commands run and their results.',
+            '- Note risks, blockers, or follow-up tasks.',
+        ];
+    }
+    return [
+        '- Use a brief plan -> implementation -> summary structure.',
+        '- Call out assumptions and tradeoffs explicitly.',
+        '- List changed files and validation results.',
+        '- End with remaining risks and next steps if any.',
+    ];
+}
+function runnerGuidance(runner) {
+    if (runner === 'codex') {
+        return [
+            'Work directly in this repository and keep changes tightly scoped to the task.',
+            'Prefer existing project helpers and patterns over introducing new abstractions.',
+            'Keep final reporting concise and implementation-focused.',
+        ];
+    }
+    return [
+        'Begin with a short plan, then execute changes in small coherent steps.',
+        'Explain implementation choices and tradeoffs briefly as you go.',
+        'Provide a clear summary with validation and follow-up notes at the end.',
+    ];
+}
+function textSection(id, title, content) {
+    return { id, title, kind: 'text', content, trim: 'keep' };
+}
+function listSection(id, title, items, options) {
+    return {
+        id,
+        title,
+        kind: 'list',
+        items,
+        ...(options?.empty_placeholder ? { empty_placeholder: options.empty_placeholder } : {}),
+        ...(options?.trim ? { trim: options.trim } : { trim: { policy: 'keep' } }),
+    };
+}
+function validationLine(v) {
+    const label = v.name ? `${v.kind}:${v.name}` : v.kind;
+    return v.kind === 'custom' ? v.command : `${label} — \`${v.command}\``;
+}
+// Linked context uses two sub-lists (decisions + notes) under one heading. The
+// legacy layout merged them so we render as a single `text` section whose
+// content is the pre-formatted bullet list, and trim by hand before handing it
+// to the core. That keeps byte-identical output without teaching the core
+// about multi-list sections.
+function renderLinkedContext(relatedDecisions, relatedNotes, mode) {
+    const lines = [];
+    const decisions = mode === 'full'
+        ? relatedDecisions
+        : mode === 'trim'
+            ? sliceWithOverflow(relatedDecisions, 3, 'decisions')
+            : sliceWithOverflow(relatedDecisions, 1, 'decisions');
+    const notes = mode === 'full'
+        ? relatedNotes
+        : mode === 'trim'
+            ? sliceWithOverflow(relatedNotes, 2, 'notes')
+            : sliceWithOverflow(relatedNotes, 0, 'notes');
+    if (decisions.length === 0)
+        lines.push('- no related decisions');
+    else
+        for (const d of decisions)
+            lines.push(`- ${d}`);
+    if (notes.length === 0)
+        lines.push('- no related notes');
+    else
+        for (const n of notes)
+            lines.push(`- ${n}`);
+    return lines;
+}
+function sliceWithOverflow(items, limit, label) {
+    if (items.length <= limit)
+        return items;
+    const kept = items.slice(0, limit);
+    kept.push(`+ ${items.length - limit} more ${label} (see task packet for full list)`);
+    return kept;
+}
+function renderPreviousRuns(runs) {
+    const lines = [];
+    runs.forEach((prev, idx) => {
+        if (idx > 0)
+            lines.push('');
+        lines.push(`### ${prev.run_id} — ${prev.runner} (${prev.agent_role})`);
+        lines.push(`- Status: ${prev.status}`);
+        if (prev.validation_summary)
+            lines.push(`- Validation: ${prev.validation_summary}`);
+        if (prev.summary)
+            lines.push(`- Summary: ${prev.summary}`);
+        if (prev.changed_files && prev.changed_files.length > 0) {
+            const limited = prev.changed_files.slice(0, 12);
+            lines.push(`- Changed files (${prev.changed_files.length}):`);
+            for (const f of limited)
+                lines.push(`  - ${f}`);
+            if (prev.changed_files.length > limited.length) {
+                lines.push(`  - + ${prev.changed_files.length - limited.length} more (see run record)`);
+            }
+        }
+        if (prev.log_tail) {
+            lines.push('- Log tail:');
+            lines.push('```');
+            for (const line of prev.log_tail.split('\n'))
+                lines.push(line);
+            lines.push('```');
+        }
+    });
+    return lines;
+}
+function renderConstraints(technical, design) {
+    const lines = [];
+    if (technical.length === 0)
+        lines.push('- no technical constraints');
+    else
+        for (const t of technical)
+            lines.push(`- ${t}`);
+    if (design.length === 0)
+        lines.push('- no design constraints');
+    else
+        for (const d of design)
+            lines.push(`- ${d}`);
+    return lines;
+}
+export function packetToCompileInput(input) {
+    const { task, run, runner, agentRole, linkedContext, budget } = input;
+    const pref = budget ?? PROMPT_PREFERENCE_DEFAULTS;
+    const header = [
+        '# Sidecar Execution Brief',
+        '',
+        `Runner: ${runner}`,
+        `Agent role: ${agentRole}`,
+        `Run id: ${run.run_id}`,
+        `Task id: ${task.task_id}`,
+        `Compiled at: ${nowIso()}`,
+    ];
+    const relatedDecisions = linkedContext?.related_decisions ?? task.context.related_decisions;
+    const relatedNotes = linkedContext?.related_notes ?? task.context.related_notes;
+    const sections = [
+        textSection('task', 'Task', [
+            `- ${task.title}`,
+            `- Type: ${task.type}`,
+            `- Priority: ${task.priority}`,
+            `- Status: ${task.status}`,
+        ]),
+        textSection('objective', 'Objective', [task.goal]),
+        textSection('why', 'Why this matters', [task.summary]),
+        listSection('in_scope', 'In scope', task.scope.in_scope, {
+            trim: { policy: 'trim-last', limit: 8, limit_strict: 8, overflow_label: 'in-scope items' },
+        }),
+        listSection('out_of_scope', 'Out of scope', task.scope.out_of_scope, {
+            trim: { policy: 'trim-last', limit: 5, limit_strict: 3, overflow_label: 'out-of-scope items' },
+        }),
+        listSection('files_to_read', 'Read these first', task.implementation.files_to_read, {
+            trim: { policy: 'trim-last', limit: 10, limit_strict: 10, overflow_label: 'read-first files' },
+        }),
+        listSection('files_to_avoid', 'Avoid changing', task.implementation.files_to_avoid, {
+            trim: { policy: 'trim-last', limit: 5, limit_strict: 3, overflow_label: 'avoid files' },
+        }),
+        // Linked context stays a text section so the "no related X" placeholders stay where they were.
+        textSection('linked_context', 'Linked context', renderLinkedContext(relatedDecisions, relatedNotes, 'full')),
+        // Previous runner context — only when this run is a later step in a pipeline.
+        ...(linkedContext?.previous_runs && linkedContext.previous_runs.length > 0
+            ? [textSection('previous_runs', 'Previous runner context', renderPreviousRuns(linkedContext.previous_runs))]
+            : []),
+        textSection('constraints', 'Constraints', renderConstraints(task.constraints.technical, task.constraints.design)),
+        listSection('validation', 'Validation', task.execution.commands.validation.map(validationLine)),
+        listSection('definition_of_done', 'Definition of done', task.definition_of_done),
+        textSection('runner_guidance', 'Runner guidance', runnerGuidance(runner)),
+        textSection('final_response_format', 'Final response format', finalResponseFormat(runner)),
+    ];
+    return {
+        header,
+        sections,
+        budget: { target: pref.budget_target, max: pref.budget_max },
+    };
+}
+// Legacy metadata expects `trimmed_sections: string[]` using the historical names.
+// Map the new core metadata back for back-compat.
+export const LEGACY_TRIM_IDS = [
+    'in_scope',
+    'out_of_scope',
+    'files_to_read',
+    'files_to_avoid',
+    'related_decisions',
+    'related_notes',
+];
+// Rebuild linked_context lines under a trim mode. The core compileSections()
+// can't partially trim a text section, so we run the full pipeline twice in
+// prompt-compiler.ts: first with full linked_context, and again with trimmed
+// linked_context if the baseline is over budget. See prompt-compiler.ts for
+// the wrapper that orchestrates this.
+export function linkedContextForMode(relatedDecisions, relatedNotes, mode) {
+    return renderLinkedContext(relatedDecisions, relatedNotes, mode);
+}

package/dist/prompts/prompt-compiler.js

@@ -1,83 +1,113 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { nowIso } from '../lib/format.js';
 import { getSidecarPaths } from '../lib/paths.js';
-function section(title, lines) {
-    return [`## ${title}`, ...lines, ''].join('\n');
+import { PROMPT_PREFERENCE_DEFAULTS } from '../runners/config.js';
+import { compileSections } from './sections.js';
+import { linkedContextForMode, packetToCompileInput, } from './packet-sections.js';
+// Rebuild the packet adapter output with a specific linked_context trim mode.
+// Linked context mixes two sub-lists under a single heading, which the core
+// compiler treats as a text section (can't partial-trim), so the wrapper owns
+// the two-pass escalation the legacy compiler used.
+function packetInputForMode(adapterInput, mode) {
+    const baseline = packetToCompileInput(adapterInput);
+    if (mode === 'full')
+        return baseline;
+    const relatedDecisions = adapterInput.linkedContext?.related_decisions ?? adapterInput.task.context.related_decisions;
+    const relatedNotes = adapterInput.linkedContext?.related_notes ?? adapterInput.task.context.related_notes;
+    const linkedLines = linkedContextForMode(relatedDecisions, relatedNotes, mode);
+    const sections = baseline.sections.map((section) => {
+        if (section.id !== 'linked_context')
+            return section;
+        return { ...section, content: linkedLines };
+    });
+    return { ...baseline, sections };
 }
-function bullets(items, empty = '- none') {
-    if (items.length === 0)
-        return [empty];
-    return items.map((item) => `- ${item}`);
-}
-function finalResponseFormat(runner) {
-    if (runner === 'codex') {
-        return [
-            '- Start with a one-line outcome summary.',
-            '- List files changed with concise reasons.',
-            '- Include validation commands run and their results.',
-            '- Note risks, blockers, or follow-up tasks.',
-        ];
+// Preserve the legacy trimmed_sections names (include related_decisions /
+// related_notes) since downstream run records use these keys.
+function buildLegacyTrimmed(adapterInput, listTrimmed, mode) {
+    const out = new Set(listTrimmed);
+    if (mode !== 'full') {
+        const decisions = adapterInput.linkedContext?.related_decisions ?? adapterInput.task.context.related_decisions;
+        const notes = adapterInput.linkedContext?.related_notes ?? adapterInput.task.context.related_notes;
+        if (mode === 'trim') {
+            if (decisions.length > 3)
+                out.add('related_decisions');
+            if (notes.length > 2)
+                out.add('related_notes');
+        }
+        else {
+            if (decisions.length > 1)
+                out.add('related_decisions');
+            if (notes.length > 0)
+                out.add('related_notes');
+        }
     }
-    return [
-        '- Use a brief plan -> implementation -> summary structure.',
-        '- Call out assumptions and tradeoffs explicitly.',
-        '- List changed files and validation results.',
-        '- End with remaining risks and next steps if any.',
-    ];
+    return [...out];
 }
-function runnerGuidance(runner) {
-    if (runner === 'codex') {
-        return [
-            'Work directly in this repository and keep changes tightly scoped to the task.',
-            'Prefer existing project helpers and patterns over introducing new abstractions.',
-            'Keep final reporting concise and implementation-focused.',
-        ];
-    }
-    return [
-        'Begin with a short plan, then execute changes in small coherent steps.',
-        'Explain implementation choices and tradeoffs briefly as you go.',
-        'Provide a clear summary with validation and follow-up notes at the end.',
-    ];
+// `policy_overrides` with every list id → 'keep' forces compileSections to
+// render the untrimmed baseline. The legacy compiler chose to trim based on
+// THIS baseline, not the partially-trimmed first pass, so we do the same to
+// preserve byte-identical output for downstream consumers.
+function allKeepOverrides(fullInput) {
+    const out = {};
+    for (const s of fullInput.sections)
+        if (s.kind === 'list')
+            out[s.id] = 'keep';
+    return out;
 }
 export function compilePromptMarkdown(input) {
-    const { task, run, runner, agentRole, linkedContext } = input;
-    const lines = [];
-    lines.push('# Sidecar Execution Brief');
-    lines.push('');
-    lines.push(`Runner: ${runner}`);
-    lines.push(`Agent role: ${agentRole}`);
-    lines.push(`Run id: ${run.run_id}`);
-    lines.push(`Task id: ${task.task_id}`);
-    lines.push(`Compiled at: ${nowIso()}`);
-    lines.push('');
-    lines.push(section('Task', [
-        `- ${task.title}`,
-        `- Type: ${task.type}`,
-        `- Priority: ${task.priority}`,
-        `- Status: ${task.status}`,
-    ]));
-    lines.push(section('Objective', [task.goal]));
-    lines.push(section('Why this matters', [task.summary]));
-    lines.push(section('In scope', bullets(task.scope.in_scope)));
-    lines.push(section('Out of scope', bullets(task.scope.out_of_scope)));
-    lines.push(section('Read these first', bullets(task.implementation.files_to_read)));
-    lines.push(section('Avoid changing', bullets(task.implementation.files_to_avoid)));
-    const relatedDecisions = linkedContext?.related_decisions ?? task.context.related_decisions;
-    const relatedNotes = linkedContext?.related_notes ?? task.context.related_notes;
-    lines.push(section('Linked context', [
-        ...bullets(relatedDecisions, '- no related decisions'),
-        ...bullets(relatedNotes, '- no related notes'),
-    ]));
-    lines.push(section('Constraints', [
-        ...bullets(task.constraints.technical, '- no technical constraints'),
-        ...bullets(task.constraints.design, '- no design constraints'),
-    ]));
-    lines.push(section('Validation', bullets(task.execution.commands.validation)));
-    lines.push(section('Definition of done', bullets(task.definition_of_done)));
-    lines.push(section('Runner guidance', runnerGuidance(runner)));
-    lines.push(section('Final response format', finalResponseFormat(runner)));
-    return `${lines.join('\n').trim()}\n`;
+    const pref = input.budget ?? PROMPT_PREFERENCE_DEFAULTS;
+    const adapterInput = {
+        task: input.task,
+        run: input.run,
+        runner: input.runner,
+        agentRole: input.agentRole,
+        ...(input.linkedContext ? { linkedContext: input.linkedContext } : {}),
+        ...(input.budget ? { budget: input.budget } : {}),
+    };
+    const fullInput = packetInputForMode(adapterInput, 'full');
+    const untrimmed = compileSections({ ...fullInput, policy_overrides: allKeepOverrides(fullInput) });
+    // Fast path — the fully untrimmed render fits within the target budget.
+    if (untrimmed.metadata.estimated_tokens_after <= pref.budget_target) {
+        return {
+            markdown: untrimmed.markdown,
+            metadata: {
+                estimated_tokens_before: untrimmed.metadata.estimated_tokens_before,
+                estimated_tokens_after: untrimmed.metadata.estimated_tokens_after,
+                budget_target: pref.budget_target,
+                budget_max: pref.budget_max,
+                trimmed_sections: [],
+            },
+        };
+    }
+    // Target pass — trim lists + linked_context.
+    const trimInput = packetInputForMode(adapterInput, 'trim');
+    const trim = compileSections(trimInput);
+    // Strict pass (safety valve) if still over max.
+    if (trim.metadata.estimated_tokens_after > pref.budget_max) {
+        const strictInput = packetInputForMode(adapterInput, 'strict');
+        const strict = compileSections(strictInput);
+        return {
+            markdown: strict.markdown,
+            metadata: {
+                estimated_tokens_before: untrimmed.metadata.estimated_tokens_before,
+                estimated_tokens_after: strict.metadata.estimated_tokens_after,
+                budget_target: pref.budget_target,
+                budget_max: pref.budget_max,
+                trimmed_sections: buildLegacyTrimmed(adapterInput, strict.metadata.trimmed_sections, 'strict'),
+            },
+        };
+    }
+    return {
+        markdown: trim.markdown,
+        metadata: {
+            estimated_tokens_before: untrimmed.metadata.estimated_tokens_before,
+            estimated_tokens_after: trim.metadata.estimated_tokens_after,
+            budget_target: pref.budget_target,
+            budget_max: pref.budget_max,
+            trimmed_sections: buildLegacyTrimmed(adapterInput, trim.metadata.trimmed_sections, 'trim'),
+        },
+    };
 }
 export function saveCompiledPrompt(rootPath, runId, markdown) {
     const promptsPath = getSidecarPaths(rootPath).promptsPath;

package/dist/prompts/prompt-service.js

@@ -1,3 +1,4 @@
+import { loadPromptPreferences } from '../runners/config.js';
 import { createRunRecordEntry, updateRunRecordEntry } from '../runs/run-service.js';
 import { getTaskPacket } from '../tasks/task-service.js';
 import { compilePromptMarkdown, saveCompiledPrompt } from './prompt-compiler.js';
@@ -10,19 +11,29 @@ export function compileTaskPrompt(input) {
         status: 'preparing',
         branch: task.tracking.branch,
         worktree: task.tracking.worktree,
+        ...(input.parentRunId ? { parent_run_id: input.parentRunId } : {}),
+        ...(input.replayReason ? { replay_reason: input.replayReason } : {}),
+        ...(input.pipelineId ? { pipeline_id: input.pipelineId } : {}),
+        ...(input.pipelineStep ? { pipeline_step: input.pipelineStep } : {}),
+        ...(input.pipelineTotal ? { pipeline_total: input.pipelineTotal } : {}),
     });
-    const promptMarkdown = compilePromptMarkdown({
+    const compiledPrompt = compilePromptMarkdown({
         task,
         run: created.run,
         runner: input.runner,
         agentRole: input.agentRole,
         linkedContext: input.linkedContext,
+        budget: loadPromptPreferences(input.rootPath),
     });
-    const promptPath = saveCompiledPrompt(input.rootPath, created.run.run_id, promptMarkdown);
+    const promptPath = saveCompiledPrompt(input.rootPath, created.run.run_id, compiledPrompt.markdown);
     updateRunRecordEntry(input.rootPath, created.run.run_id, {
         status: 'queued',
         prompt_path: promptPath,
-        summary: `Compiled prompt for task ${task.task_id}`,
+        prompt_tokens_estimated_before: compiledPrompt.metadata.estimated_tokens_before,
+        prompt_tokens_estimated_after: compiledPrompt.metadata.estimated_tokens_after,
+        prompt_budget_target: compiledPrompt.metadata.budget_target,
+        prompt_trimmed_sections: compiledPrompt.metadata.trimmed_sections,
+        summary: `Compiled prompt for task ${task.task_id} (${compiledPrompt.metadata.estimated_tokens_before} -> ${compiledPrompt.metadata.estimated_tokens_after} est. tokens)`,
     });
     return {
         run_id: created.run.run_id,
@@ -30,6 +41,7 @@ export function compileTaskPrompt(input) {
         runner_type: input.runner,
         agent_role: input.agentRole,
         prompt_path: promptPath,
-        prompt_markdown: promptMarkdown,
+        prompt_markdown: compiledPrompt.markdown,
+        prompt_optimization: compiledPrompt.metadata,
     };
 }