@fitlab-ai/agent-infra 0.8.2 → 0.8.3

package/dist/lib/sandbox/image-build.js

@@ -0,0 +1,80 @@
+import { createHash } from 'node:crypto';
+import { detectEngine } from './engine.js';
+import { resolveBuildUid } from './engines/native.js';
+import { toEnginePath } from './engines/wsl2-paths.js';
+import { sandboxImageConfigLabel, sandboxImageRefreshLabel, sandboxLabel } from './constants.js';
+import { runEngine, runSafeEngine } from './shell.js';
+import { imageSignatureFields, toolNpmPackagesArg, toolShellInstallScriptBase64 } from './tools.js';
+export function buildImageSignature(preparedDockerfile, tools) {
+    return createHash('sha256')
+        .update(JSON.stringify({
+        dockerfile: preparedDockerfile.signature,
+        tools: imageSignatureFields(tools)
+    }))
+        .digest('hex')
+        .slice(0, 12);
+}
+export function buildSandboxImageArgs(config, tools, dockerfilePath, imageSignature, { engine, runFn = runEngine, runSafeFn = runSafeEngine, env = process.env, refresh = false, lastRefresh } = {}) {
+    const selectedEngine = engine ?? detectEngine({ engine: config.engine });
+    const { uid: hostUid, gid: hostGid } = resolveBuildUid({
+        engine: selectedEngine,
+        runFn,
+        runSafeFn,
+        env
+    });
+    const args = [
+        'build',
+        '-t',
+        config.imageName,
+        '--build-arg',
+        `HOST_UID=${hostUid}`,
+        '--build-arg',
+        `HOST_GID=${hostGid}`,
+        '--build-arg',
+        `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
+        '--build-arg',
+        `AI_TOOLS_SHELL_INSTALL_B64=${toolShellInstallScriptBase64(tools)}`,
+        '--label',
+        sandboxLabel(config),
+        '--label',
+        `${sandboxImageConfigLabel(config)}=${imageSignature}`
+    ];
+    if (lastRefresh !== undefined) {
+        args.push('--label', `${sandboxImageRefreshLabel(config)}=${lastRefresh}`);
+    }
+    args.push('-f', toEnginePath(selectedEngine, dockerfilePath), toEnginePath(selectedEngine, config.repoRoot));
+    if (refresh) {
+        args.splice(1, 0, '--no-cache', '--pull');
+    }
+    return args;
+}
+export function parseRefreshTimestamp(value) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+export function parseImageLabels(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === 'string'));
+    }
+    catch {
+        return {};
+    }
+}
+export function isRefreshDisabled(env, noRefreshFlag) {
+    if (noRefreshFlag) {
+        return true;
+    }
+    const value = env.AI_SANDBOX_NO_REFRESH?.trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+}
+export function isRefreshDue(lastRefresh, now, intervalDays) {
+    if (intervalDays <= 0 || lastRefresh > now) {
+        return false;
+    }
+    return now - lastRefresh >= intervalDays * 24 * 60 * 60 * 1000;
+}
+//# sourceMappingURL=image-build.js.map

package/dist/lib/sandbox/image-prune.js

@@ -1,6 +1,6 @@
 import * as p from '@clack/prompts';
-import { sandboxLabel } from "./constants.js";
-import { runEngine } from "./shell.js";
+import { sandboxLabel } from './constants.js';
+import { runEngine } from './shell.js';
 export function pruneSandboxDanglingImages(config, engine) {
     try {
         runEngine(engine, 'docker', [

package/dist/lib/sandbox/index.js

@@ -37,12 +37,12 @@ export async function runSandbox(args) {
     }
     switch (subcommand) {
         case 'create': {
-            const { create } = await import("./commands/create.js");
+            const { create } = await import('./commands/create.js');
             await create(rest);
             break;
         }
         case 'exec': {
-            const { enter } = await import("./commands/enter.js");
+            const { enter } = await import('./commands/enter.js');
             const exitCode = await enter(rest);
             if (typeof exitCode === 'number' && exitCode !== 0) {
                 process.exitCode = exitCode;
@@ -50,27 +50,27 @@ export async function runSandbox(args) {
             break;
         }
         case 'ls': {
-            const { ls } = await import("./commands/ls.js");
+            const { ls } = await import('./commands/ls.js');
             ls(rest);
             break;
         }
         case 'show': {
-            const { show } = await import("./commands/show.js");
+            const { show } = await import('./commands/show.js');
             show(rest);
             break;
         }
         case 'prune': {
-            const { prune } = await import("./commands/prune.js");
+            const { prune } = await import('./commands/prune.js');
             await prune(rest);
             break;
         }
         case 'rebuild': {
-            const { rebuild } = await import("./commands/rebuild.js");
+            const { rebuild } = await import('./commands/rebuild.js');
             await rebuild(rest);
             break;
         }
         case 'refresh': {
-            const { refresh } = await import("./commands/refresh.js");
+            const { refresh } = await import('./commands/refresh.js');
             const exitCode = await refresh(rest);
             if (typeof exitCode === 'number' && exitCode !== 0) {
                 process.exitCode = exitCode;
@@ -78,17 +78,17 @@ export async function runSandbox(args) {
             break;
         }
         case 'rm': {
-            const { rm } = await import("./commands/rm.js");
+            const { rm } = await import('./commands/rm.js');
             await rm(rest);
             break;
         }
         case 'start': {
-            const { start } = await import("./commands/start.js");
+            const { start } = await import('./commands/start.js');
             await start(rest);
             break;
         }
         case 'vm': {
-            const { vm } = await import("./commands/vm.js");
+            const { vm } = await import('./commands/vm.js');
             await vm(rest);
             break;
         }

package/dist/lib/sandbox/managed-fs.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { run } from "./shell.js";
+import { run } from './shell.js';
 export function assertManagedPath(root, target) {
     const resolvedRoot = path.resolve(root);
     const resolvedTarget = path.resolve(target);

package/dist/lib/sandbox/readme-scaffold.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { shareBranchDir, shareCommonDir } from "./constants.js";
+import { shareBranchDir, shareCommonDir } from './constants.js';
 const DOTFILES_README = `# User-level dotfiles channel
 
 This directory is mounted **read-only** into every sandbox container at

package/dist/lib/sandbox/tools.js

@@ -1,5 +1,5 @@
-import { safeNameCandidates, sanitizeBranchName } from "./constants.js";
-import { hostJoin } from "./engines/wsl2-paths.js";
+import { safeNameCandidates, sanitizeBranchName } from './constants.js';
+import { hostJoin } from './engines/wsl2-paths.js';
 const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 function createBuiltinTools(home, project) {
     return {

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

@@ -1,4 +1,5 @@
-import { cardMessage, createFeishuTransport, normalizeMessage } from "./transport.js";
+import { renderFeishuMessage } from './renderer.js';
+import { createFeishuTransport, normalizeMessage } from './transport.js';
 // Assemble the feishu adapter. The transport is injectable so unit tests can
 // drive start/dispatch/reply/sendMessage against a fake transport without the
 // real SDK; production uses the default SDK-backed transport.
@@ -19,7 +20,10 @@ export function createFeishuAdapter(config, transport = createFeishuTransport(co
                         messageId: normalized.messageId,
                         raw: normalized.raw,
                         reply: async (text) => {
-                            await transport.send(normalized.chatId, cardMessage(text));
+                            await transport.send(normalized.chatId, renderFeishuMessage(text));
+                        },
+                        replyDisplay: async (message) => {
+                            await transport.send(normalized.chatId, renderFeishuMessage(message));
                         }
                     };
                     await adapterCtx.dispatch(message);
@@ -33,7 +37,10 @@ export function createFeishuAdapter(config, transport = createFeishuTransport(co
             await transport.stop();
         },
         async sendMessage(target, text) {
-            await transport.send(target.chatId, cardMessage(text));
+            await transport.send(target.chatId, renderFeishuMessage(text));
+        },
+        async sendDisplayMessage(target, message) {
+            await transport.send(target.chatId, renderFeishuMessage(message));
         }
     };
 }

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.