@fitlab-ai/agent-infra 0.8.2 → 0.8.4

package/dist/lib/server/adapters/feishu/renderer.js

@@ -0,0 +1,88 @@
+import { stripVTControlCharacters } from 'node:util';
+import { normalizeOutbound, outboundToText } from '../../display.js';
+const FEISHU_LARK_MD_MAX_LENGTH = 20_000;
+function templateForTone(tone) {
+    if (tone === 'success')
+        return 'green';
+    if (tone === 'warning')
+        return 'yellow';
+    if (tone === 'danger')
+        return 'red';
+    return 'blue';
+}
+function templateForResult(exitCode) {
+    return exitCode === 0 ? 'green' : 'red';
+}
+export function cleanFeishuText(text) {
+    return stripVTControlCharacters(text).replace(/\r\n/g, '\n');
+}
+function clampLarkMarkdown(text) {
+    const clean = cleanFeishuText(text);
+    if (clean.length <= FEISHU_LARK_MD_MAX_LENGTH)
+        return clean;
+    return `${clean.slice(0, FEISHU_LARK_MD_MAX_LENGTH - 18)}\n\n...(truncated)`;
+}
+function div(content) {
+    return { tag: 'div', text: { tag: 'lark_md', content: clampLarkMarkdown(content) } };
+}
+function fields(rows) {
+    return {
+        tag: 'div',
+        fields: rows.map(([label, value]) => ({
+            is_short: true,
+            text: { tag: 'lark_md', content: clampLarkMarkdown(`**${label}**\n${value}`) }
+        }))
+    };
+}
+function card(title, template, elements) {
+    return {
+        msg_type: 'interactive',
+        content: JSON.stringify({
+            config: { wide_screen_mode: true },
+            header: { title: { tag: 'plain_text', content: cleanFeishuText(title) }, template },
+            elements
+        })
+    };
+}
+function tableMarkdown(message) {
+    return outboundToText(message);
+}
+function renderStatus(message) {
+    const elements = [];
+    if (message.fields && message.fields.length > 0)
+        elements.push(fields(message.fields));
+    if (message.body)
+        elements.push(div(message.body));
+    if (elements.length === 0)
+        elements.push(div(message.title));
+    return card(message.title, templateForTone(message.tone), elements);
+}
+function renderStream(message) {
+    const template = message.phase === 'finished' ? templateForResult(message.exitCode ?? null) : 'blue';
+    return card(message.title, template, [div(outboundToText(message))]);
+}
+function renderCommandResult(message) {
+    return card(message.title, templateForResult(message.exitCode), [div(outboundToText(message))]);
+}
+function renderUnknownDisplayKind(message) {
+    return card('agent-infra', 'blue', [div(`[unknown display kind: ${String(message.kind)}]`)]);
+}
+export function renderFeishuMessage(message) {
+    const normalized = normalizeOutbound(message);
+    switch (normalized.kind) {
+        case 'text':
+            return card('agent-infra', 'blue', [div(normalized.text)]);
+        case 'markdown':
+            return card('agent-infra', 'blue', [div(normalized.markdown)]);
+        case 'table':
+            return card(normalized.title ?? 'agent-infra', 'blue', [div(tableMarkdown(normalized))]);
+        case 'status-card':
+            return renderStatus(normalized);
+        case 'stream-event':
+            return renderStream(normalized);
+        case 'command-result':
+            return renderCommandResult(normalized);
+    }
+    return renderUnknownDisplayKind(normalized);
+}
+//# sourceMappingURL=renderer.js.map

package/dist/lib/server/adapters/feishu/transport.js

@@ -1,5 +1,4 @@
 import * as lark from '@larksuiteoapi/node-sdk';
-import { stripVTControlCharacters } from 'node:util';
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : {};
 }
@@ -41,21 +40,11 @@ export function normalizeMessage(event) {
 function resolveDomain(value) {
     return value === 'lark' || value === 'Lark' ? lark.Domain.Lark : lark.Domain.Feishu;
 }
-export function cleanFeishuText(text) {
-    return stripVTControlCharacters(text).replace(/\r\n/g, '\n');
-}
-export function cardMessage(text) {
-    return { kind: 'interactive', title: 'agent-infra', text: cleanFeishuText(text) };
-}
 export function toFeishuCreateData(chatId, message) {
     return {
         receive_id: chatId,
-        msg_type: 'interactive',
-        content: JSON.stringify({
-            config: { wide_screen_mode: true },
-            header: { title: { tag: 'plain_text', content: message.title }, template: 'blue' },
-            elements: [{ tag: 'div', text: { tag: 'lark_md', content: message.text } }]
-        })
+        msg_type: message.msg_type,
+        content: message.content
     };
 }
 // Build the real SDK-backed transport from adapter config. appId/appSecret come

package/dist/lib/server/daemon.js

@@ -1,14 +1,69 @@
-import { VERSION } from "../version.js";
-import { loadServerConfig } from "./config.js";
-import { createLogger } from "./logger.js";
-import { loadAdapters, unloadAdapters } from "./plugin-loader.js";
-import { authorize } from "./auth.js";
-import { commandHelp, parseCommand } from "./protocol.js";
-import { runAi } from "./runner.js";
-import { streamCommand } from "./streamer.js";
+import { VERSION } from '../version.js';
+import { loadServerConfig } from './config.js';
+import { createLogger } from './logger.js';
+import { loadAdapters, unloadAdapters } from './plugin-loader.js';
+import { authorize } from './auth.js';
+import { commandHelp, parseCommand } from './protocol.js';
+import { runAi } from './runner.js';
+import { streamCommand } from './streamer.js';
+import { markdownMessage, replyOutbound, textMessage } from './display.js';
+import { buildStatusModel, statusModelToDisplay } from '../task/commands/status.js';
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function isTaskStatus(argv) {
+    return argv[0] === 'task' && argv[1] === 'status' && typeof argv[2] === 'string';
+}
+export function createMessageDispatcher(options) {
+    const runAiImpl = options.runAi ?? runAi;
+    const buildStatusModelImpl = options.buildStatusModel ?? buildStatusModel;
+    const statusModelToDisplayImpl = options.statusModelToDisplay ?? statusModelToDisplay;
+    return async (message) => {
+        const plan = parseCommand(message.text);
+        if (plan.kind === 'ignore')
+            return;
+        if (plan.kind === 'error') {
+            await replyOutbound(message, textMessage(plan.message));
+            options.logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'ping') {
+            await replyOutbound(message, textMessage(`pong ${VERSION}`));
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'help') {
+            await replyOutbound(message, markdownMessage(commandHelp()));
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'version') {
+            await replyOutbound(message, textMessage(`agent-infra ${VERSION}`));
+            return;
+        }
+        if (plan.kind === 'ai') {
+            const allowed = authorize({ adapter: message.adapter, userId: message.userId }, plan.role, options.config.auth);
+            if (!allowed.ok) {
+                await replyOutbound(message, textMessage(allowed.message));
+                options.logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
+                return;
+            }
+            if (isTaskStatus(plan.argv)) {
+                try {
+                    await replyOutbound(message, statusModelToDisplayImpl(buildStatusModelImpl(plan.argv[2])));
+                    return;
+                }
+                catch {
+                    // Fall back to the existing CLI streaming path. This preserves the
+                    // old behavior for invalid refs and any status-model collection error.
+                }
+            }
+            await streamCommand({
+                title: `ai ${plan.argv.join(' ')}`,
+                chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
+                throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
+            }, (emit) => runAiImpl(plan.argv, { onChunk: emit }), (outbound) => replyOutbound(message, outbound));
+        }
+    };
+}
 // The daemon main loop. Runs in the detached child spawned by
 // process-control.start(), or in the foreground for debugging.
 //
@@ -35,41 +90,7 @@ export async function runDaemon() {
     const shutdown = new Promise((resolve) => {
         resolveShutdown = resolve;
     });
-    const dispatch = async (message) => {
-        const plan = parseCommand(message.text);
-        if (plan.kind === 'ignore')
-            return;
-        if (plan.kind === 'error') {
-            await message.reply(plan.message);
-            logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
-            return;
-        }
-        if (plan.kind === 'builtin' && plan.name === 'ping') {
-            await message.reply(`pong ${VERSION}`);
-            return;
-        }
-        if (plan.kind === 'builtin' && plan.name === 'help') {
-            await message.reply(commandHelp());
-            return;
-        }
-        if (plan.kind === 'builtin' && plan.name === 'version') {
-            await message.reply(`agent-infra ${VERSION}`);
-            return;
-        }
-        if (plan.kind === 'ai') {
-            const allowed = authorize({ adapter: message.adapter, userId: message.userId }, plan.role, config.auth);
-            if (!allowed.ok) {
-                await message.reply(allowed.message);
-                logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
-                return;
-            }
-            await streamCommand({
-                title: `ai ${plan.argv.join(' ')}`,
-                chunkChars: typeof config.stream?.chunkChars === 'number' ? config.stream.chunkChars : 4000,
-                throttleMs: typeof config.stream?.throttleMs === 'number' ? config.stream.throttleMs : 1500
-            }, (emit) => runAi(plan.argv, { onChunk: emit }), (text) => message.reply(text));
-        }
-    };
+    const dispatch = createMessageDispatcher({ config, logger });
     const ctx = { config, logger, dispatch, signal: abortController.signal };
     const adapters = await loadAdapters(config, ctx);
     logger.ok(`loaded ${adapters.length} adapter(s)`);

package/dist/lib/server/display.js

@@ -0,0 +1,83 @@
+export function textMessage(text) {
+    return { kind: 'text', text };
+}
+export function markdownMessage(markdown) {
+    return { kind: 'markdown', markdown };
+}
+export function tableMessage(columns, rows, title) {
+    return { kind: 'table', title, columns, rows };
+}
+export function statusCard(title, tone, fields, body) {
+    return { kind: 'status-card', title, tone, fields, body };
+}
+export function streamEvent(title, phase, text, exitCode, signal) {
+    const message = { kind: 'stream-event', title, phase };
+    if (text !== undefined)
+        message.text = text;
+    if (exitCode !== undefined)
+        message.exitCode = exitCode;
+    if (signal !== undefined)
+        message.signal = signal;
+    return message;
+}
+export function commandResult(title, exitCode, signal, stdout, stderr) {
+    return { kind: 'command-result', title, exitCode, signal, stdout, stderr };
+}
+export function normalizeOutbound(message) {
+    return typeof message === 'string' ? textMessage(message) : message;
+}
+function tableToText(message) {
+    const lines = [];
+    if (message.title)
+        lines.push(message.title);
+    lines.push(message.columns.join(' | '));
+    lines.push(message.columns.map(() => '---').join(' | '));
+    for (const row of message.rows) {
+        lines.push(row.join(' | '));
+    }
+    return lines.join('\n');
+}
+function compact(lines) {
+    return lines.filter((line) => typeof line === 'string' && line !== '').join('\n');
+}
+function unknownDisplayKind(message) {
+    return `[unknown: ${String(message.kind)}]`;
+}
+export function outboundToText(message) {
+    const normalized = normalizeOutbound(message);
+    switch (normalized.kind) {
+        case 'text':
+            return normalized.text;
+        case 'markdown':
+            return normalized.markdown;
+        case 'table':
+            return tableToText(normalized);
+        case 'status-card':
+            return compact([
+                normalized.title,
+                ...(normalized.fields ?? []).map(([label, value]) => `${label}: ${value}`),
+                normalized.body
+            ]);
+        case 'stream-event':
+            if (normalized.phase === 'started')
+                return `started ${normalized.title}`;
+            if (normalized.phase === 'chunk')
+                return normalized.text ?? '';
+            return `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`;
+        case 'command-result':
+            return compact([
+                `finished ${normalized.title} exitCode=${normalized.exitCode ?? 'null'} signal=${normalized.signal ?? 'null'}`,
+                normalized.stdout,
+                normalized.stderr
+            ]);
+    }
+    return unknownDisplayKind(normalized);
+}
+export async function replyOutbound(inbound, message) {
+    if (inbound.replyDisplay) {
+        await inbound.replyDisplay(message);
+        return;
+    }
+    await inbound.reply(outboundToText(message));
+}
+//# sourceMappingURL=display.js.map

package/dist/lib/server/index.js

@@ -1,5 +1,5 @@
-import { runDaemon } from "./daemon.js";
-import { start, stop, status, logs } from "./process-control.js";
+import { runDaemon } from './daemon.js';
+import { start, stop, status, logs } from './process-control.js';
 const USAGE = `Usage: ai server <command> [options]
 
 Commands:

package/dist/lib/server/process-control.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
-import { loadServerConfig } from "./config.js";
-import { runDaemon } from "./daemon.js";
+import { loadServerConfig } from './config.js';
+import { runDaemon } from './daemon.js';
 export function buildStopCommand(pid, platform) {
     if (platform === 'win32') {
         return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };

package/dist/lib/server/protocol.js

@@ -1,5 +1,5 @@
-import { VERSION } from "../version.js";
-import { getSkillRunSpec } from "../run/skills.js";
+import { VERSION } from '../version.js';
+import { getSkillRunSpec } from '../run/skills.js';
 const TASK_READ = new Set(['ls', 'list', 'status', 'show', 'log', 'decisions']);
 const SANDBOX_READ = new Set(['ls', 'list', 'show']);
 const SANDBOX_WRITE = new Set(['create', 'start']);

package/dist/lib/server/streamer.js

@@ -1,4 +1,5 @@
-import { redactSecrets } from "./redact.js";
+import { streamEvent } from './display.js';
+import { redactSecrets } from './redact.js';
 function chunks(text, size) {
     if (text.length === 0)
         return [];
@@ -9,7 +10,7 @@ function chunks(text, size) {
     return out;
 }
 export async function streamCommand(options, run, send) {
-    await send(`started ${options.title}`);
+    await send(streamEvent(options.title, 'started'));
     const size = options.chunkChars ?? 4000;
     const throttleMs = options.throttleMs ?? 0;
     let streamed = false;
@@ -22,7 +23,7 @@ export async function streamCommand(options, run, send) {
         buffer = '';
         lastFlush = Date.now();
         for (const chunk of chunks(text, size)) {
-            await send(chunk);
+            await send(streamEvent(options.title, 'chunk', chunk));
         }
     };
     const emit = async (chunk) => {
@@ -38,7 +39,7 @@ export async function streamCommand(options, run, send) {
         buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
     }
     await flush();
-    await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+    await send(streamEvent(options.title, 'finished', undefined, result.exitCode, result.signal));
     return result;
 }
 //# sourceMappingURL=streamer.js.map

package/dist/lib/task/commands/cat.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
-import { resolveTaskRef } from "../resolve-ref.js";
-import { resolveArtifact } from "../artifacts.js";
+import { resolveTaskRef } from '../resolve-ref.js';
+import { resolveArtifact } from '../artifacts.js';
 const USAGE = `Usage: ai task cat <N | #N | TASK-id> <artifact | N>
 
 Prints a task artifact's raw content to stdout.

package/dist/lib/task/commands/decisions.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { formatTable } from "../../table.js";
-import { resolveTaskRef } from "../resolve-ref.js";
-import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
-import { extractSubSection } from "../sections.js";
+import { formatTable } from '../../table.js';
+import { resolveTaskRef } from '../resolve-ref.js';
+import { parseLedger, HUMAN_DECISION_STATUSES } from '../ledger.js';
+import { extractSubSection } from '../sections.js';
 const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
 
 Lists the human-decision (HD-) items recorded in a task's review disagreement

package/dist/lib/task/commands/files.js

@@ -1,6 +1,6 @@
-import { formatTable } from "../../table.js";
-import { resolveTaskRef } from "../resolve-ref.js";
-import { enumerateArtifacts } from "../artifacts.js";
+import { formatTable } from '../../table.js';
+import { resolveTaskRef } from '../resolve-ref.js';
+import { enumerateArtifacts } from '../artifacts.js';
 const USAGE = `Usage: ai task files <N | #N | TASK-id>
 
 Lists the artifacts in a task directory with stable numbers.

package/dist/lib/task/commands/grep.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { resolveTaskRef, detectRepoRoot, enumerateTaskDirs } from "../resolve-ref.js";
-import { enumerateArtifacts, resolveArtifact } from "../artifacts.js";
-import { loadShortIdByTaskId } from "../short-id.js";
+import { resolveTaskRef, detectRepoRoot, enumerateTaskDirs } from '../resolve-ref.js';
+import { enumerateArtifacts, resolveArtifact } from '../artifacts.js';
+import { loadShortIdByTaskId } from '../short-id.js';
 const USAGE = `Usage: ai task grep <pattern> [ref] [artifact | N]
 
 Literal (non-regex) line search across task artifacts.

package/dist/lib/task/commands/issue-body.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
-import { resolveTaskRef } from "../resolve-ref.js";
-import { extractTitle } from "../frontmatter.js";
-import { extractSection, findSectionHeading } from "../sections.js";
-import { renderTemplateBody, PLACEHOLDER } from "../issue-form.js";
+import { resolveTaskRef } from '../resolve-ref.js';
+import { extractTitle } from '../frontmatter.js';
+import { extractSection, findSectionHeading } from '../sections.js';
+import { renderTemplateBody, PLACEHOLDER } from '../issue-form.js';
 const USAGE = `Usage: ai task issue-body <N | #N | TASK-id> [--template <path>]
 
 Print a deterministic Issue body extracted from a task's task.md.

package/dist/lib/task/commands/log.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
-import { formatTable } from "../../table.js";
-import { resolveTaskRef } from "../resolve-ref.js";
-import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
+import { formatTable } from '../../table.js';
+import { resolveTaskRef } from '../resolve-ref.js';
+import { parseLedger } from '../ledger.js';
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
 Renders a task's activity log as a per-step status table. A step's start and
@@ -13,7 +13,7 @@ Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
   a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
   the verdict list, right after blockers/major/minor: manual-validation
-  and human-decision (current ledger stage total).
+  and human-decision (current pending ledger stage total).
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // The activity-log H2 heading is language-dependent (zh template / en template).
@@ -100,7 +100,7 @@ function pairEntries(entries) {
 function countHumanDecisionsByStage(rows) {
     const counts = new Map();
     for (const row of rows) {
-        if (!isReviewStage(row.stage) || !HUMAN_DECISION_STATUSES.has(row.status))
+        if (!isReviewStage(row.stage) || row.status !== 'needs-human-decision')
             continue;
         counts.set(row.stage, (counts.get(row.stage) ?? 0) + 1);
     }

package/dist/lib/task/commands/ls.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { formatTable } from "../../table.js";
-import { parseTaskFrontmatter, extractTitle } from "../frontmatter.js";
-import { loadShortIdByTaskId } from "../short-id.js";
+import { formatTable } from '../../table.js';
+import { parseTaskFrontmatter, extractTitle } from '../frontmatter.js';
+import { loadShortIdByTaskId } from '../short-id.js';
 const USAGE = `Usage: ai task ls [--all | --blocked | --completed]
 
 Lists tasks under .agents/workspace/. Defaults to active tasks only.

package/dist/lib/task/commands/show.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { resolveTaskRef } from "../resolve-ref.js";
+import { resolveTaskRef } from '../resolve-ref.js';
 const USAGE = `Usage: ai task show <N | #N | TASK-id>
 
 Prints the task.md content for the matching task.

package/dist/lib/task/commands/status.js

@@ -1,12 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { commandForEngine } from "../../sandbox/shell.js";
-import { resolveTaskRef } from "../resolve-ref.js";
-import { enumerateArtifacts } from "../artifacts.js";
-import { parseTaskFrontmatter, extractTitle } from "../frontmatter.js";
-import { loadShortIdByTaskId } from "../short-id.js";
-import { parseActivityLog, pairEntries } from "./log.js";
+import { commandForEngine } from '../../sandbox/shell.js';
+import { resolveTaskRef } from '../resolve-ref.js';
+import { enumerateArtifacts } from '../artifacts.js';
+import { parseTaskFrontmatter, extractTitle } from '../frontmatter.js';
+import { loadShortIdByTaskId } from '../short-id.js';
+import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workflow-warnings.js';
+import { parseActivityLog, pairEntries } from './log.js';
+import { statusCard } from '../../server/display.js';
 const USAGE = `Usage: ai task status <N | #N | TASK-id>
 
 Prints an aggregated "health check" view for a task: header, metadata,
@@ -267,6 +269,9 @@ function renderStatus(model) {
     if (model.title)
         lines.push(model.title);
     lines.push('', 'Metadata', ...renderPairs(model.metadata));
+    if (model.workflowWarnings.length > 0) {
+        lines.push('', `Workflow Warnings (${model.workflowWarnings.length} open)`, ...formatWorkflowWarningSummary(model.workflowWarnings).map((line) => `  ${line}`));
+    }
     lines.push('', `Artifacts (${model.artifacts.count})`);
     if (model.artifacts.groups.length === 0) {
         lines.push('  (none)');
@@ -302,6 +307,59 @@ function renderStatus(model) {
     ]));
     return lines;
 }
+function modelTone(model) {
+    if (model.workflow.state === 'in-progress')
+        return model.workflow.stale === 'yes' ? 'warning' : 'running';
+    if (model.metadata.some(([key, value]) => key === 'status' && value === 'completed'))
+        return 'success';
+    if (model.metadata.some(([key, value]) => key === 'status' && (value === 'blocked' || value === 'cancelled'))) {
+        return 'danger';
+    }
+    return 'info';
+}
+function buildFromResolved(input) {
+    const content = fs.readFileSync(input.taskMdPath, 'utf8');
+    const fm = parseTaskFrontmatter(content);
+    const run = input.run ?? makeRunner(input.repoRoot);
+    const artifacts = enumerateArtifacts(input.taskDir);
+    const workflow = collectWorkflow(content, input.now);
+    return {
+        taskId: input.taskId,
+        shortId: input.shortId ?? loadShortIdByTaskId(input.repoRoot).get(input.taskId) ?? DASH,
+        title: extractTitle(content),
+        metadata: collectMetadata(fm),
+        workflowWarnings: getOpenWorkflowWarnings(content),
+        artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
+        workflow,
+        runtime: collectRuntime(input.taskDir, workflow, run),
+        git: collectGit(fm.branch ?? '', run)
+    };
+}
+function buildStatusModel(refOrInput, options = {}) {
+    if (typeof refOrInput !== 'string') {
+        return buildFromResolved(refOrInput);
+    }
+    const resolved = resolveTaskRef(refOrInput);
+    if (!resolved.ok) {
+        throw new Error(resolved.message);
+    }
+    return buildFromResolved({
+        taskId: resolved.taskId,
+        taskDir: resolved.taskDir,
+        taskMdPath: resolved.taskMdPath,
+        repoRoot: resolved.repoRoot,
+        run: options.run,
+        now: options.now
+    });
+}
+function statusModelToDisplay(model) {
+    return statusCard(`Task ${model.taskId} (${model.shortId})`, modelTone(model), [
+        ['workflow', model.workflow.state],
+        ['step', model.workflow.step],
+        ['runtime', model.runtime.status],
+        ['git', model.git.uncommitted]
+    ], renderStatus(model).join('\n'));
+}
 function status(args = []) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
@@ -309,30 +367,18 @@ function status(args = []) {
             process.exitCode = 1;
         return;
     }
-    const resolved = resolveTaskRef(args[0]);
-    if (!resolved.ok) {
-        process.stderr.write(`ai task status: ${resolved.message}\n`);
+    let model;
+    try {
+        model = buildStatusModel(args[0]);
+    }
+    catch (error) {
+        process.stderr.write(`ai task status: ${error instanceof Error ? error.message : String(error)}\n`);
         process.exitCode = 1;
         return;
     }
-    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    const fm = parseTaskFrontmatter(content);
-    const run = makeRunner(resolved.repoRoot);
-    const artifacts = enumerateArtifacts(resolved.taskDir);
-    const workflow = collectWorkflow(content);
-    const model = {
-        taskId: resolved.taskId,
-        shortId: loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId) ?? DASH,
-        title: extractTitle(content),
-        metadata: collectMetadata(fm),
-        artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
-        workflow,
-        runtime: collectRuntime(resolved.taskDir, workflow, run),
-        git: collectGit(fm.branch ?? '', run)
-    };
     for (const line of renderStatus(model)) {
         process.stdout.write(`${line}\n`);
     }
 }
-export { status, makeRunner, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, METADATA_KEYS };
+export { status, makeRunner, buildStatusModel, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, statusModelToDisplay, METADATA_KEYS };
 //# sourceMappingURL=status.js.map