@compilr-dev/cli 0.5.0 → 0.5.2

package/dist/ui/tool-formatters.js

@@ -4,6 +4,7 @@
  * Extracts content, summary, and success from tool results.
  * Each tool type has its own formatter to produce human-readable output.
  */
+import { truncate } from './base/index.js';
 /**
  * Format tool result for display.
  * Handles the agent's structured result format.
@@ -16,6 +17,10 @@ export function formatToolResult(toolName, result) {
         // Check for success/result wrapper
         const success = obj.success !== false;
         const innerResult = (obj.result ?? obj);
+        // Handle delegated results — large tool outputs that were auto-summarized
+        if (innerResult._delegated === true) {
+            return formatDelegated(toolName, innerResult);
+        }
         // Extract content based on tool type
         let content = '';
         let summary = '';
@@ -95,6 +100,99 @@ export function formatToolResult(toolName, result) {
         else if (toolLower === 'task') {
             ({ content, summary } = formatTask(innerResult));
         }
+        else if (toolLower === 'plan_get') {
+            ({ content, summary } = formatPlanGet(innerResult));
+        }
+        else if (toolLower === 'plan_list') {
+            ({ content, summary } = formatPlanList(innerResult));
+        }
+        else if (toolLower === 'plan_create') {
+            ({ content, summary } = formatPlanCreate(innerResult));
+        }
+        else if (toolLower === 'plan_update') {
+            ({ content, summary } = formatPlanUpdate(innerResult));
+        }
+        else if (toolLower === 'plan_delete') {
+            ({ content, summary } = formatPlanDelete(innerResult));
+        }
+        else if (toolLower === 'delegate_background') {
+            ({ content, summary } = formatDelegateBackground(innerResult));
+        }
+        else if (toolLower === 'delegate' || toolLower === 'handoff') {
+            ({ content, summary } = formatDelegate(innerResult));
+        }
+        else if (toolLower === 'todo_claim' || toolLower === 'todo_handoff') {
+            ({ content, summary } = formatTodoClaim(innerResult));
+        }
+        else if (toolLower === 'recall_work') {
+            ({ content, summary } = formatRecallWork(innerResult));
+        }
+        else if (toolLower.startsWith('artifact_')) {
+            ({ content, summary } = formatArtifact(toolLower, innerResult));
+        }
+        else if (toolLower === 'app_model_get') {
+            ({ content, summary } = formatAppModelGet(innerResult));
+        }
+        else if (toolLower === 'app_model_update') {
+            ({ content, summary } = formatAppModelUpdate(innerResult));
+        }
+        else if (toolLower === 'app_model_validate') {
+            ({ content, summary } = formatAppModelValidate(innerResult));
+        }
+        else if (toolLower === 'factory_scaffold') {
+            ({ content, summary } = formatFactoryScaffold(innerResult));
+        }
+        else if (toolLower === 'factory_list_toolkits') {
+            ({ content, summary } = formatFactoryListToolkits(innerResult));
+        }
+        else if (toolLower === 'list_tools') {
+            ({ content, summary } = formatListTools(innerResult));
+        }
+        else if (toolLower === 'get_tool_info') {
+            ({ content, summary } = formatGetToolInfo(innerResult));
+        }
+        else if (toolLower === 'git_stash') {
+            ({ content, summary } = formatGitStash(innerResult));
+        }
+        else if (toolLower === 'git_blame') {
+            ({ content, summary } = formatGitBlame(innerResult));
+        }
+        else if (toolLower === 'git_file_history') {
+            ({ content, summary } = formatGitFileHistory(innerResult));
+        }
+        else if (toolLower === 'run_build') {
+            ({ content, summary } = formatRunBuild(innerResult));
+        }
+        else if (toolLower === 'run_format') {
+            ({ content, summary } = formatRunFormat(innerResult));
+        }
+        else if (toolLower === 'find_definition') {
+            ({ content, summary } = formatFindDefinition(innerResult));
+        }
+        else if (toolLower === 'find_references') {
+            ({ content, summary } = formatFindReferences(innerResult));
+        }
+        else if (toolLower === 'find_todos') {
+            ({ content, summary } = formatFindTodos(innerResult));
+        }
+        else if (toolLower === 'check_outdated') {
+            ({ content, summary } = formatCheckOutdated(innerResult));
+        }
+        else if (toolLower === 'find_vulnerabilities') {
+            ({ content, summary } = formatFindVulnerabilities(innerResult));
+        }
+        else if (toolLower === 'analyze_test_coverage') {
+            ({ content, summary } = formatAnalyzeTestCoverage(innerResult));
+        }
+        else if (toolLower === 'get_file_structure') {
+            ({ content, summary } = formatGetFileStructure(innerResult));
+        }
+        else if (toolLower === 'get_complexity') {
+            ({ content, summary } = formatGetComplexity(innerResult));
+        }
+        else if (toolLower === 'read_function' || toolLower === 'read_class' || toolLower === 'read_type') {
+            ({ content, summary } = formatReadSymbol(innerResult));
+        }
         else {
             // Generic handling
             ({ content, summary } = formatGeneric(innerResult));
@@ -458,7 +556,7 @@ function formatProjectDocument(toolName, result) {
         }
         const docType = document.docType || 'unknown';
         const content = document.content || '';
-        const preview = content.length > 200 ? content.slice(0, 200) + '...' : content;
+        const preview = truncate(content, 200);
         return { content: preview, summary: `Document: ${docType}` };
     }
     // Handle document_list - return list of documents
@@ -504,6 +602,590 @@ function formatTask(result) {
     const content = response || '';
     return { content, summary };
 }
+// =============================================================================
+// Plan Formatters
+// =============================================================================
+function formatPlanGet(result) {
+    const plan = result.plan;
+    if (!plan) {
+        const message = result.message;
+        return { content: '', summary: message || 'Plan not found' };
+    }
+    const name = plan.name || 'Unknown';
+    const status = plan.status || 'draft';
+    const planContent = plan.content || '';
+    const workItem = plan.workItem;
+    // Build summary
+    let summary = `${name} [${status}]`;
+    if (workItem) {
+        const itemId = workItem.itemId || '';
+        summary += ` → ${itemId}`;
+    }
+    // For content, show a preview of the plan (first 500 chars with section headers visible)
+    const lines = planContent.split('\n');
+    const previewLines = [];
+    let charCount = 0;
+    const maxChars = 500;
+    for (const line of lines) {
+        if (charCount >= maxChars) {
+            previewLines.push('...');
+            break;
+        }
+        previewLines.push(line);
+        charCount += line.length + 1;
+    }
+    const content = previewLines.join('\n');
+    return { content, summary };
+}
+function formatPlanList(result) {
+    const plans = result.plans;
+    const count = result.count;
+    const statusCounts = result.statusCounts;
+    if (!plans?.length) {
+        return { content: '', summary: 'No plans found' };
+    }
+    // Build summary with status counts
+    let summary = `${String(count ?? plans.length)} plan(s)`;
+    if (statusCounts) {
+        const statuses = [];
+        if (statusCounts.draft)
+            statuses.push(`${String(statusCounts.draft)} draft`);
+        if (statusCounts.approved)
+            statuses.push(`${String(statusCounts.approved)} approved`);
+        if (statusCounts.in_progress)
+            statuses.push(`${String(statusCounts.in_progress)} in progress`);
+        if (statusCounts.completed)
+            statuses.push(`${String(statusCounts.completed)} completed`);
+        if (statuses.length)
+            summary += ` (${statuses.join(', ')})`;
+    }
+    // Build content with plan list
+    const lines = plans.slice(0, 10).map((p) => {
+        const status = p.status ? `[${p.status}]` : '';
+        const workItem = p.workItemItemId ? ` → ${p.workItemItemId}` : '';
+        return `${p.name || '?'} ${status}${workItem}`;
+    });
+    if (plans.length > 10) {
+        lines.push(`... and ${String(plans.length - 10)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatPlanCreate(result) {
+    const message = result.message;
+    const plan = result.plan;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (plan) {
+        const name = plan.name || 'Unknown';
+        const id = plan.id;
+        return { content: '', summary: `Created plan: ${name}${id ? ` (ID: ${String(id)})` : ''}` };
+    }
+    return { content: '', summary: 'Plan created' };
+}
+function formatPlanUpdate(result) {
+    const message = result.message;
+    const plan = result.plan;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (plan) {
+        const name = plan.name || 'Unknown';
+        const status = plan.status || '';
+        return { content: '', summary: `Updated plan: ${name}${status ? ` [${status}]` : ''}` };
+    }
+    return { content: '', summary: 'Plan updated' };
+}
+function formatPlanDelete(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Plan deleted' };
+}
+// =============================================================================
+// agents-coding Tool Formatters
+// =============================================================================
+function formatGitStash(result) {
+    const message = result.message;
+    const stashes = result.stashes;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (stashes?.length) {
+        const lines = stashes.slice(0, 5).map((s) => `stash@{${String(s.index ?? 0)}}: ${(s.message || '').slice(0, 50)}`);
+        if (stashes.length > 5)
+            lines.push(`... and ${String(stashes.length - 5)} more`);
+        return { content: lines.join('\n'), summary: `${String(stashes.length)} stash(es)` };
+    }
+    return { content: '', summary: 'No stashes' };
+}
+function formatGitBlame(result) {
+    const lines = result.lines;
+    const authors = result.authorSummary;
+    if (authors?.length) {
+        const topAuthors = authors.slice(0, 3).map((a) => `${a.author || '?'}: ${String(a.lines ?? 0)} lines`).join(', ');
+        const summary = `${String(lines?.length ?? 0)} lines, ${topAuthors}`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: `${String(lines?.length ?? 0)} lines analyzed` };
+}
+function formatGitFileHistory(result) {
+    const commits = result.commits;
+    const file = result.file;
+    if (!commits?.length) {
+        return { content: '', summary: 'No history found' };
+    }
+    const summary = `${String(commits.length)} commit(s) for ${file || 'file'}`;
+    const lines = commits.slice(0, 5).map((c) => `${c.shortHash || '?'} ${(c.subject || '').slice(0, 50)}`);
+    if (commits.length > 5)
+        lines.push(`... and ${String(commits.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatRunBuild(result) {
+    const success = result.success;
+    const command = result.command;
+    const stdout = result.stdout;
+    const status = success === false ? 'Build failed' : 'Build succeeded';
+    const summary = command ? `${status} (${command})` : status;
+    return { content: stdout || '', summary };
+}
+function formatRunFormat(result) {
+    const filesFormatted = result.filesFormatted;
+    const command = result.command;
+    if (filesFormatted !== undefined) {
+        return { content: '', summary: `Formatted ${String(filesFormatted)} file(s)` };
+    }
+    return { content: '', summary: command ? `Ran ${command}` : 'Format complete' };
+}
+function formatFindDefinition(result) {
+    const definitions = result.definitions;
+    if (!definitions?.length) {
+        return { content: '', summary: 'No definitions found' };
+    }
+    const summary = `Found ${String(definitions.length)} definition(s)`;
+    const lines = definitions.slice(0, 5).map((d) => `${d.path || '?'}:${String(d.line ?? 0)} [${d.type || '?'}] ${d.name || ''}`);
+    if (definitions.length > 5)
+        lines.push(`... and ${String(definitions.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatFindReferences(result) {
+    const references = result.references;
+    const totalCount = result.totalCount;
+    const count = totalCount ?? references?.length ?? 0;
+    if (count === 0) {
+        return { content: '', summary: 'No references found' };
+    }
+    const summary = `Found ${String(count)} reference(s)`;
+    if (references?.length) {
+        const lines = references.slice(0, 5).map((r) => `${r.path || '?'}:${String(r.line ?? 0)}`);
+        if (references.length > 5)
+            lines.push(`... and ${String(references.length - 5)} more`);
+        return { content: lines.join('\n'), summary };
+    }
+    return { content: '', summary };
+}
+function formatFindTodos(result) {
+    const todos = result.todos;
+    if (!todos?.length) {
+        return { content: '', summary: 'No TODOs found' };
+    }
+    const summary = `Found ${String(todos.length)} TODO(s)`;
+    const lines = todos.slice(0, 5).map((t) => `${t.path || '?'}:${String(t.line ?? 0)} [${t.type || 'TODO'}] ${(t.text || '').slice(0, 40)}`);
+    if (todos.length > 5)
+        lines.push(`... and ${String(todos.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatCheckOutdated(result) {
+    const packages = result.packages;
+    if (!packages?.length) {
+        return { content: '', summary: 'All packages up to date' };
+    }
+    const summary = `${String(packages.length)} outdated package(s)`;
+    const lines = packages.slice(0, 5).map((p) => `${p.name || '?'}: ${p.current || '?'} → ${p.latest || '?'} (${p.type || 'update'})`);
+    if (packages.length > 5)
+        lines.push(`... and ${String(packages.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatFindVulnerabilities(result) {
+    const vulnerabilities = result.vulnerabilities;
+    if (!vulnerabilities?.length) {
+        return { content: '', summary: 'No vulnerabilities found' };
+    }
+    // Count by severity
+    const bySeverity = {};
+    vulnerabilities.forEach((v) => {
+        const sev = v.severity || 'unknown';
+        bySeverity[sev] = (bySeverity[sev] || 0) + 1;
+    });
+    const sevParts = Object.entries(bySeverity).map(([k, v]) => `${String(v)} ${k}`).join(', ');
+    const summary = `${String(vulnerabilities.length)} vulnerabilities (${sevParts})`;
+    const lines = vulnerabilities.slice(0, 5).map((v) => `[${v.severity || '?'}] ${v.name || '?'}: ${(v.title || '').slice(0, 40)}`);
+    if (vulnerabilities.length > 5)
+        lines.push(`... and ${String(vulnerabilities.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatAnalyzeTestCoverage(result) {
+    const summary_data = result.summary;
+    const meetsThreshold = result.meetsThreshold;
+    if (summary_data) {
+        const lineCov = summary_data.lines?.pct ?? summary_data.statements?.pct ?? 0;
+        const funcCov = summary_data.functions?.pct ?? 0;
+        const branchCov = summary_data.branches?.pct ?? 0;
+        const status = meetsThreshold === false ? ' (below threshold)' : '';
+        const summary = `Coverage: ${lineCov.toFixed(1)}% lines, ${funcCov.toFixed(1)}% functions, ${branchCov.toFixed(1)}% branches${status}`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: 'Coverage analysis complete' };
+}
+function formatGetFileStructure(result) {
+    const classes = result.classes;
+    const functions = result.functions;
+    const imports = result.imports;
+    const exports = result.exports;
+    const parts = [];
+    if (classes?.length)
+        parts.push(`${String(classes.length)} class(es)`);
+    if (functions?.length)
+        parts.push(`${String(functions.length)} function(s)`);
+    if (imports?.length)
+        parts.push(`${String(imports.length)} import(s)`);
+    if (exports?.length)
+        parts.push(`${String(exports.length)} export(s)`);
+    const summary = parts.length > 0 ? parts.join(', ') : 'Empty file';
+    // Build detailed content
+    const lines = [];
+    if (classes?.length) {
+        lines.push('Classes:');
+        classes.slice(0, 5).forEach((c) => lines.push(`  - ${c.name || '?'}`));
+        if (classes.length > 5)
+            lines.push(`  ... and ${String(classes.length - 5)} more`);
+    }
+    if (functions?.length) {
+        lines.push('Functions:');
+        functions.slice(0, 5).forEach((f) => lines.push(`  - ${f.name || '?'}`));
+        if (functions.length > 5)
+            lines.push(`  ... and ${String(functions.length - 5)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatGetComplexity(result) {
+    const files = result.files;
+    const functions_data = result.functions;
+    if (functions_data?.length) {
+        const highComplexity = functions_data.filter((f) => (f.complexity ?? 0) > 10);
+        if (highComplexity.length > 0) {
+            const summary = `${String(highComplexity.length)} high-complexity function(s)`;
+            const lines = highComplexity.slice(0, 5).map((f) => `${f.name || '?'}: complexity ${String(f.complexity ?? 0)}`);
+            if (highComplexity.length > 5)
+                lines.push(`... and ${String(highComplexity.length - 5)} more`);
+            return { content: lines.join('\n'), summary };
+        }
+        return { content: '', summary: 'All functions within complexity threshold' };
+    }
+    if (files?.length) {
+        const summary = `Analyzed ${String(files.length)} file(s)`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: 'Complexity analysis complete' };
+}
+function formatReadSymbol(result) {
+    const name = result.name;
+    const kind = result.kind;
+    const startLine = result.startLine;
+    const endLine = result.endLine;
+    const codeContent = result.content;
+    const signature = result.signature;
+    const container = result.container;
+    // Build summary: [kind] name (lines X-Y)
+    const kindLabel = kind || 'symbol';
+    const lineRange = startLine && endLine ? ` (lines ${String(startLine)}-${String(endLine)})` : '';
+    const containerInfo = container ? ` in ${container}` : '';
+    const summary = `[${kindLabel}] ${name || '?'}${containerInfo}${lineRange}`;
+    // Content is the actual source code
+    // Format it nicely with line numbers
+    if (codeContent) {
+        const lines = codeContent.split('\n');
+        const start = startLine ?? 1;
+        const numberedLines = lines.map((line, i) => {
+            const lineNum = String(start + i).padStart(4, ' ');
+            return `${lineNum} │ ${line}`;
+        });
+        return { content: numberedLines.join('\n'), summary };
+    }
+    // Fallback to signature if no content
+    if (signature) {
+        return { content: signature, summary };
+    }
+    return { content: '', summary };
+}
+function formatTodoClaim(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Done' };
+}
+function formatRecallWork(result) {
+    const episodes = result.episodes;
+    const totalEpisodes = result.totalEpisodes;
+    const totalEffort = result.totalEffort;
+    const uncommittedCount = result.uncommittedCount;
+    if (!episodes?.length) {
+        return { content: '', summary: 'No work history' };
+    }
+    // Summary line
+    const uncommittedInfo = uncommittedCount ? `, ${String(uncommittedCount)} uncommitted` : '';
+    const summary = `${String(totalEpisodes ?? episodes.length)} episode(s), effort: ${totalEffort || '?'}${uncommittedInfo}`;
+    // Build detailed content
+    const lines = [];
+    for (const ep of episodes.slice(0, 10)) {
+        const time = ep.timestamp ? new Date(ep.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : '?';
+        const agent = ep.agentId || '?';
+        const action = ep.summary || ep.action || '?';
+        const effort = ep.effort ? `[${ep.effort}]` : '';
+        lines.push(`${time} ${agent} ${effort} ${action}`);
+    }
+    if (episodes.length > 10) {
+        lines.push(`... and ${String(episodes.length - 10)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatArtifact(toolName, result) {
+    const action = toolName.replace('artifact_', '');
+    // artifact_list
+    if (action === 'list') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const lines = content.split('\n').filter((l) => l.length > 0);
+        // First line is typically "Found N artifacts:"
+        const summary = lines.length > 0 ? lines[0].slice(0, 60) : 'No artifacts';
+        return { content: '', summary };
+    }
+    // artifact_save
+    if (action === 'save') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Created artifact "([^"]+)"/.exec(content);
+        return { content: '', summary: match ? `Saved: ${match[1]}` : 'Artifact saved' };
+    }
+    // artifact_get
+    if (action === 'get') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Artifact: (.+)/.exec(content);
+        return { content, summary: match ? match[1].slice(0, 60) : 'Artifact retrieved' };
+    }
+    // artifact_delete
+    if (action === 'delete') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Deleted artifact "([^"]+)"/.exec(content);
+        return { content: '', summary: match ? `Deleted: ${match[1]}` : 'Artifact deleted' };
+    }
+    // Fallback
+    const message = typeof result.content === 'string' ? result.content.split('\n')[0] : '';
+    return { content: '', summary: message.slice(0, 60) || 'Done' };
+}
+function formatListTools(result) {
+    const count = result.count;
+    const tools = result.tools;
+    if (tools?.length) {
+        const names = tools.slice(0, 8).map((t) => t.name || '?').join(', ');
+        const more = tools.length > 8 ? `, +${String(tools.length - 8)} more` : '';
+        return { content: '', summary: `${String(count ?? tools.length)} tools: ${names}${more}` };
+    }
+    return { content: '', summary: count ? `${String(count)} tools available` : 'No tools' };
+}
+function formatGetToolInfo(result) {
+    // Compact schema format (SDK 0.1.15+): result is a string like "tool_name(...)\n  description"
+    if (typeof result === 'string') {
+        // Extract tool name from signature line: "tool_name(params...)"
+        const parenIdx = result.indexOf('(');
+        const toolName = parenIdx > 0 ? result.slice(0, parenIdx) : null;
+        if (toolName) {
+            return { content: '', summary: `Schema: ${toolName}` };
+        }
+        return { content: '', summary: result.split('\n')[0].slice(0, 80) };
+    }
+    // Legacy object format: { name, description, parameters }
+    const name = result.name;
+    if (name) {
+        return { content: '', summary: `Schema: ${name}` };
+    }
+    return { content: '', summary: 'Tool info' };
+}
+function formatDelegateBackground(result) {
+    const delegated = result.delegated;
+    const delegationId = result.delegationId;
+    const status = result.status;
+    const message = result.message;
+    const error = result.error;
+    if (error) {
+        return { content: '', summary: error };
+    }
+    if (delegated && delegationId) {
+        const shortId = delegationId.replace('del_', '');
+        const statusLabel = status === 'queued' ? 'queued' : 'running';
+        return { content: '', summary: `${shortId} ${statusLabel}` };
+    }
+    return { content: '', summary: message || 'Delegated' };
+}
+function formatDelegate(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Delegated' };
+}
+// =============================================================================
+// Factory Tool Formatters
+// =============================================================================
+/**
+ * Unwrap the use_tool envelope to get the actual tool result.
+ * use_tool wraps as: { tool, status, message, result: { success, result: actualData } }
+ */
+function unwrapToolResult(result) {
+    const inner = result.result;
+    if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
+        const innerObj = inner;
+        // If wrapped by use_tool, the actual data is in innerObj.result
+        if (innerObj.result && typeof innerObj.result === 'object' && !Array.isArray(innerObj.result)) {
+            return innerObj.result;
+        }
+        return innerObj;
+    }
+    return result;
+}
+function formatAppModelGet(result) {
+    const data = unwrapToolResult(result);
+    // No model exists
+    if (data.exists === false) {
+        const message = data.message;
+        return { content: '', summary: message || 'No Application Model found' };
+    }
+    // Summary scope
+    if (data.entityCount !== undefined) {
+        const name = data.name || '?';
+        const entityCount = data.entityCount;
+        const toolkit = data.toolkit || '?';
+        const revision = data.revision;
+        const entities = data.entities;
+        const summary = `${name} — ${String(entityCount)} entities, toolkit: ${toolkit}${revision !== undefined ? `, rev ${String(revision)}` : ''}`;
+        const lines = [];
+        if (entities?.length) {
+            for (const e of entities) {
+                const rels = e.relationshipCount > 0 ? `, ${String(e.relationshipCount)} rel` : '';
+                lines.push(`  ${e.name} (${String(e.fieldCount)} fields, ${e.views.join('/')})${rels}`);
+            }
+        }
+        const features = data.features;
+        if (features) {
+            const enabled = Object.entries(features).filter(([, v]) => v).map(([k]) => k);
+            if (enabled.length)
+                lines.push(`Features: ${enabled.join(', ')}`);
+        }
+        return { content: lines.join('\n'), summary };
+    }
+    // Single entity scope
+    if (data.entity && typeof data.entity === 'object') {
+        const entity = data.entity;
+        const name = entity.name || '?';
+        const fields = entity.fields;
+        const rels = entity.relationships;
+        const summary = `Entity: ${name} (${String(fields?.length ?? 0)} fields)`;
+        const lines = [];
+        if (fields?.length) {
+            lines.push('Fields:');
+            for (const f of fields)
+                lines.push(`  ${f.name}: ${f.type}`);
+        }
+        if (rels?.length) {
+            lines.push('Relationships:');
+            for (const r of rels)
+                lines.push(`  ${r.type} → ${r.target}`);
+        }
+        return { content: lines.join('\n'), summary };
+    }
+    // Section scopes (identity, features, layout, theme, techStack)
+    const section = data.identity ?? data.features ?? data.layout ?? data.theme ?? data.techStack;
+    if (section && typeof section === 'object') {
+        const entries = Object.entries(section);
+        const summary = entries.map(([k, v]) => `${k}: ${String(v)}`).join(', ');
+        return { content: '', summary: truncate(summary, 80) };
+    }
+    // Full model fallback
+    const message = data.message;
+    return { content: '', summary: message || 'Application Model' };
+}
+function formatAppModelUpdate(result) {
+    const data = unwrapToolResult(result);
+    const op = data.op || '';
+    const revision = data.revision;
+    const message = data.message;
+    const revInfo = revision !== undefined ? ` (rev ${String(revision)})` : '';
+    const summary = message || `${op} applied${revInfo}`;
+    return { content: '', summary: truncate(summary, 80) };
+}
+function formatAppModelValidate(result) {
+    const data = unwrapToolResult(result);
+    const valid = data.valid;
+    const errors = data.errors;
+    const revision = data.revision;
+    if (valid) {
+        return { content: '', summary: `Model valid${revision !== undefined ? ` (rev ${String(revision)})` : ''}` };
+    }
+    const errorCount = errors?.length ?? 0;
+    const summary = `${String(errorCount)} validation error(s)`;
+    const lines = errors?.slice(0, 10).map((e) => `${e.path || '?'}: ${e.message || 'error'}`) ?? [];
+    if (errorCount > 10)
+        lines.push(`... and ${String(errorCount - 10)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatFactoryScaffold(result) {
+    const data = unwrapToolResult(result);
+    const toolkit = data.toolkit || '?';
+    const fileCount = data.fileCount;
+    const files = data.files;
+    const dryRun = data.dryRun;
+    const warnings = data.warnings;
+    const message = data.message;
+    const mode = dryRun ? 'Dry run' : 'Generated';
+    const summary = message || `${mode}: ${String(fileCount ?? 0)} files (${toolkit})`;
+    // Build detailed content with file listing
+    const lines = [];
+    if (files?.length) {
+        // Group files by directory
+        const dirs = new Map();
+        for (const f of files) {
+            const parts = f.split('/');
+            const dir = parts.length > 1 ? parts.slice(0, -1).join('/') : '.';
+            const file = parts[parts.length - 1];
+            const existing = dirs.get(dir);
+            if (existing) {
+                existing.push(file);
+            }
+            else {
+                dirs.set(dir, [file]);
+            }
+        }
+        for (const [dir, dirFiles] of dirs) {
+            lines.push(`${dir}/`);
+            for (const f of dirFiles)
+                lines.push(`  ${f}`);
+        }
+    }
+    if (warnings?.length) {
+        lines.push('');
+        lines.push('Warnings:');
+        for (const w of warnings)
+            lines.push(`  ! ${w}`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatFactoryListToolkits(result) {
+    const data = unwrapToolResult(result);
+    const count = data.count;
+    const toolkits = data.toolkits;
+    if (!toolkits?.length) {
+        return { content: '', summary: 'No toolkits available' };
+    }
+    const summary = `${String(count ?? toolkits.length)} toolkit(s)`;
+    const lines = toolkits.map((t) => {
+        const name = t.name || t.id || '?';
+        const desc = t.description ? ` — ${t.description}` : '';
+        const sections = t.requiredSections?.length ? `\n  Requires: ${t.requiredSections.join(', ')}` : '';
+        return `${name}${desc}${sections}`;
+    });
+    return { content: lines.join('\n'), summary };
+}
 function formatGeneric(result) {
     const content = typeof result.content === 'string'
         ? result.content
@@ -514,3 +1196,16 @@ function formatGeneric(result) {
     const summary = lines.length > 0 ? lines[0].slice(0, 60) : 'Completed';
     return { content, summary };
 }
+function formatDelegated(toolName, result) {
+    const originalTokens = result._originalTokens;
+    const summaryTokens = result._summaryTokens;
+    const summaryText = result.summary;
+    // Summary line: "Delegated (24,921 → 800 tokens)"
+    const tokenInfo = originalTokens && summaryTokens
+        ? ` (${originalTokens.toLocaleString()} → ${summaryTokens.toLocaleString()} tokens)`
+        : '';
+    const summary = `Delegated${tokenInfo}`;
+    // Content: the summary text (truncated for display, full in Ctrl+O)
+    const content = summaryText || `[${toolName} result was auto-summarized to conserve context]`;
+    return { content, summary, success: true };
+}