@fitlab-ai/agent-infra 0.7.1 → 0.7.2

package/bin/cli.ts

@@ -18,6 +18,7 @@ Usage:
   agent-infra init            Initialize a new project with update-agent-infra seed command
   agent-infra merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
   agent-infra sandbox         Manage Docker-based AI sandboxes
+  agent-infra task            Read-only views over .agents/workspace tasks (ls / show)
   agent-infra update          Update seed files and sync file registry for an existing project
   agent-infra version         Show version
 
@@ -97,6 +98,16 @@ switch (command) {
     });
     break;
   }
+  case 'task': {
+    const imported = await importCommand('../lib/task/index.ts');
+    if (!imported) break;
+    const { runTask } = imported;
+    await runTask(process.argv.slice(3)).catch((e: unknown) => {
+      process.stderr.write(`Error: ${errorMessage(e)}\n`);
+      process.exit(1);
+    });
+    break;
+  }
   case 'cp': {
     const imported = await importCommand('../lib/cp.ts');
     if (!imported) break;

package/dist/bin/cli.js

@@ -22,6 +22,7 @@ Usage:
   agent-infra init            Initialize a new project with update-agent-infra seed command
   agent-infra merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
   agent-infra sandbox         Manage Docker-based AI sandboxes
+  agent-infra task            Read-only views over .agents/workspace tasks (ls / show)
   agent-infra update          Update seed files and sync file registry for an existing project
   agent-infra version         Show version
 
@@ -100,6 +101,17 @@ switch (command) {
         });
         break;
     }
+    case 'task': {
+        const imported = await importCommand('../lib/task/index.ts');
+        if (!imported)
+            break;
+        const { runTask } = imported;
+        await runTask(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exit(1);
+        });
+        break;
+    }
     case 'cp': {
         const imported = await importCommand('../lib/cp.ts');
         if (!imported)

package/dist/lib/sandbox/commands/create.js

@@ -630,13 +630,21 @@ export function ensureCodexModelInheritance(toolDir, hostHomeDir) {
             return;
         }
     }
+    const inheritSpecs = [
+        ['model', 'string'],
+        ['model_reasoning_effort', 'string'],
+        ['model_auto_compact_token_limit', 'number']
+    ];
     let changed = false;
-    for (const key of ['model', 'model_reasoning_effort']) {
+    for (const [key, type] of inheritSpecs) {
         if (Object.hasOwn(sandboxParsed, key)) {
             continue;
         }
         const value = hostParsed[key];
-        if (typeof value !== 'string' || value === '') {
+        if (type === 'string' && (typeof value !== 'string' || value === '')) {
+            continue;
+        }
+        if (type === 'number' && (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
             continue;
         }
         sandboxParsed[key] = value;

package/dist/lib/sandbox/commands/enter.js

@@ -1,5 +1,5 @@
 import { loadConfig } from "../config.js";
-import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from "../constants.js";
+import { assertValidBranchName, containerNameCandidates } from "../constants.js";
 import { detectEngine } from "../engine.js";
 import { formatCredentialWarnings, formatRemaining, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from "../credentials.js";
 import { runInteractiveEngine, runSafeEngine } from "../shell.js";
@@ -7,11 +7,13 @@ import { resolveTaskBranch } from "../task-resolver.js";
 import { dotfilesCacheDir, materializeDotfiles } from "../dotfiles.js";
 import { runInteractiveWithClipboardBridge } from "../clipboard/bridge.js";
 import { detectHostTimezone } from "../host-timezone.js";
-import { fetchSandboxRows, isTaskShortRef, resolveTaskShortRef } from "./list-running.js";
-const USAGE = `Usage: ai sandbox exec <branch | TASK-id | '#N'> [cmd...]
+import { isTaskShortRef, resolveTaskShortRef } from "./list-running.js";
+const USAGE = `Usage: ai sandbox exec <branch | TASK-id | N | '#N'> [cmd...]
 
-'#N' references the N-th running sandbox in 'ai sandbox ls' order (1-based).
-Quote it as '#N' to avoid shell '#' comment handling.`;
+N (bare) and '#N' both reference the same active task short id from
+.agents/workspace/active/.short-ids.json. They resolve only via that
+registry — they do not reference a container's row position in
+'ai sandbox ls' output.`;
 const TMUX_ENTRY_PATH = '/usr/local/bin/sandbox-tmux-entry';
 // Terminal-detection variables that interactive TUIs (e.g. claude-code)
 // inspect to enable progressive enhancements such as the kitty keyboard
@@ -86,8 +88,7 @@ export async function enter(args) {
     const [firstArg = '', ...cmd] = args;
     let branch;
     if (isTaskShortRef(firstArg)) {
-        const { running } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
-        branch = resolveTaskShortRef(firstArg, { running, repoRoot: config.repoRoot });
+        branch = resolveTaskShortRef(firstArg, { repoRoot: config.repoRoot });
     }
     else {
         branch = resolveTaskBranch(firstArg, config.repoRoot);

package/dist/lib/sandbox/commands/list-running.js

@@ -68,13 +68,14 @@ export function fetchSandboxRows(engine, label, branchKey) {
     return sortAndIndexSandboxRows(parseSandboxRows(raw, branchKey));
 }
 /**
- * Returns true iff `arg` is a syntactically valid task short reference ('#N').
+ * Returns true iff `arg` is a syntactically valid task short reference.
+ * Accepts both bare numeric ('11') and '#'-prefixed ('#11') forms.
  * Zero IO. Callers MUST use this as the gate before constructing any context
  * for resolveTaskShortRef — that way non-matching arguments (e.g. '#abc',
  * '#1.5', '#') never trigger sandbox list IO.
  */
 export function isTaskShortRef(arg) {
-    return /^#\d+$/.test(arg);
+    return /^#?\d+$/.test(arg);
 }
 /**
  * Try to resolve a short ref against the global task-short-id registry.
@@ -89,6 +90,9 @@ function tryResolveFromRegistry(arg, repoRoot) {
     const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
     if (!fs.existsSync(scriptPath))
         return { status: 'miss' };
+    // Strip leading '#' when forwarding bare-numeric input through the script's CLI.
+    // (Script accepts both forms, but this avoids shell quoting confusion in error
+    // messages echoed back to the user.)
     const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
     if (result.status !== 0)
         return { status: 'miss' };
@@ -113,41 +117,26 @@ function tryResolveFromRegistry(arg, repoRoot) {
     }
     throw new Error(`Short ref '${arg}' resolved to task ${taskId} but task.md was not found under any workspace dir`);
 }
-function resolveByRunningIndex(arg, running) {
-    const n = Number(arg.slice(1));
-    if (n < 1) {
-        throw new Error(`Invalid sandbox index '${arg}': must be >= 1`);
-    }
-    if (running.length === 0) {
-        throw new Error(`No running sandbox to reference with '${arg}'`);
-    }
-    if (n > running.length) {
-        throw new Error(`No running sandbox at index '${arg}' (only ${running.length} running)`);
-    }
-    const row = running[n - 1];
-    if (!row.branch) {
-        throw new Error(`Cannot resolve branch for sandbox '${arg}' (container '${row.name}' missing branch label)`);
-    }
-    return row.branch;
-}
 /**
- * Resolve a task short reference ('#N') to a branch name for the sandbox entrypoint.
+/**
+ * Resolve a task short reference (bare 'N' or '#N') to a branch name for the
+ * sandbox entrypoint.
  *
- * Resolution order (sandbox fallback mode, plan-r7 C2):
- *   1. Try the global task-short-id registry under repoRoot. If hit, look up the
- *      branch from the matching task.md.
- *   2. Fallback to the running-sandbox list index (preserves the #414 ls-index
- *      behaviour; long-term contract per analysis-r5).
+ * Resolution: registry-only. Look up the short id in the global task-short-id
+ * registry under repoRoot; if hit, read the branch from the matching task.md.
+ * On miss (registry empty or short id absent), throw with an actionable
+ * message instead of falling back to a container's row position in
+ * 'ai sandbox ls' output — that fallback would make the same syntax mean
+ * different things depending on `docker ps` state.
  *
  * Precondition: callers MUST gate on isTaskShortRef(arg) === true.
  */
 export function resolveTaskShortRef(arg, ctx) {
-    if (ctx.repoRoot) {
-        const lookup = tryResolveFromRegistry(arg, ctx.repoRoot);
-        if (lookup.status === 'hit')
-            return lookup.branch;
-        // 'miss' falls through to ls-index fallback (preserves #414 behaviour); 'hit-but-invalid' already threw above.
-    }
-    return resolveByRunningIndex(arg, ctx.running);
+    const lookup = tryResolveFromRegistry(arg, ctx.repoRoot);
+    if (lookup.status === 'hit')
+        return lookup.branch;
+    throw new Error(`short ref '${arg}' is not in the active task registry. ` +
+        `'#N' and bare N resolve only via the registry (not by row position in 'ai sandbox ls'); ` +
+        `use a task short id (e.g. 'ai sandbox exec 11'), a TASK-id, or a branch name.`);
 }
 //# sourceMappingURL=list-running.js.map

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

@@ -6,27 +6,20 @@ import { loadConfig } from "../config.js";
 import { sandboxBranchLabel, sandboxLabel } from "../constants.js";
 import { detectEngine } from "../engine.js";
 import { resolveTools, toolProjectDirCandidates } from "../tools.js";
+import { formatTable } from "../../table.js";
+import { lookupShortIdByBranch } from "../../task/short-id.js";
 import { fetchSandboxRows } from "./list-running.js";
 export { containerListFormat, parseLabels } from "./list-running.js";
 const USAGE = `Usage: ai sandbox ls
 
-Lists all containers for the current project. The leftmost '#' column
-numbers running sandboxes; use it as "ai sandbox exec '#N'" to enter one.
-Quote '#N' to avoid shell '#' comment handling.`;
-const CONTAINER_TABLE_HEADERS = ['#', 'NAMES', 'STATUS', 'BRANCH'];
+Lists all containers for the current project. The '#' column is a
+display-only row number; the 'SHORT' column shows the active task short
+id bound to each container's branch (via
+.agents/workspace/active/.short-ids.json), or '-' if no active task is
+bound. Pass the SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').`;
+const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'];
 export function formatContainerTable(rows) {
-    const columns = rows.map((row) => [row.index, row.name, row.status, row.branch]);
-    const widths = [
-        Math.max(CONTAINER_TABLE_HEADERS[0].length, ...rows.map((row) => row.index.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[1].length, ...rows.map((row) => row.name.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[2].length, ...rows.map((row) => row.status.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[3].length, ...rows.map((row) => row.branch.length))
-    ];
-    const renderRow = (values) => `${values[0].padEnd(widths[0])}  ${values[1].padEnd(widths[1])}  ${values[2].padEnd(widths[2])}  ${values[3]}`.trimEnd();
-    return [
-        renderRow(CONTAINER_TABLE_HEADERS),
-        ...columns.map((column) => renderRow(column))
-    ];
+    return formatTable(CONTAINER_TABLE_HEADERS, rows.map((r) => [r.row, r.shortId, r.name, r.status, r.branch]));
 }
 function listChildren(dir) {
     if (!fs.existsSync(dir)) {
@@ -51,15 +44,20 @@ export function ls(args = []) {
         p.log.warn('  No sandbox containers');
     }
     else {
-        const tableRows = ordered.map((row) => ({
-            index: row.index === null ? '' : String(row.index),
-            name: row.name,
-            status: row.status,
-            branch: row.branch
-        }));
+        const tableRows = ordered.map((container, i) => {
+            const shortId = container.branch ? lookupShortIdByBranch(container.branch, config.repoRoot) : null;
+            return {
+                row: String(i + 1),
+                shortId: shortId ?? '-',
+                name: container.name,
+                status: container.status,
+                branch: container.branch
+            };
+        });
         for (const line of formatContainerTable(tableRows)) {
             process.stdout.write(`  ${line}\n`);
         }
+        process.stdout.write(`  Total: ${ordered.length} containers\n`);
     }
     p.log.step('Worktrees');
     const worktrees = listChildren(config.worktreeBase);

package/dist/lib/sandbox/index.js

@@ -2,9 +2,13 @@ const USAGE = `Usage: ai sandbox <command> [options]
 
 Commands:
   create <branch> [base]       Create a sandbox (VM + image + worktree + container)
-  exec <branch | '#N'> [cmd...]
-                               Enter sandbox or run a command (use leftmost '#' column from 'ls')
-  ls                           List sandboxes for the current project
+  exec <branch | TASK-id | N | '#N'> [cmd...]
+                               Enter sandbox or run a command. N (bare) is the
+                               recommended form for task short ids (e.g.
+                               'ai sandbox exec 11'); '#N' is also accepted.
+  ls                           List sandboxes for the current project (the '#'
+                               column is a display-only row number; the 'SHORT'
+                               column shows the active task short id, '-' if none)
   prune [--dry-run]            Remove orphaned per-branch state dirs
   rebuild [--quiet] [--refresh]
                                Rebuild the sandbox image (--refresh pulls base + tools)

package/dist/lib/sandbox/task-resolver.js

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const SHORT_ID_RE = /^#\d+$/;
+const SHORT_ID_RE = /^#?\d+$/;
 const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
 function resolveShortIdStrict(arg, repoRoot) {
     const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');

package/dist/lib/sandbox/tools.js

@@ -6,7 +6,7 @@ function createBuiltinTools(home, project) {
         'claude-code': {
             id: 'claude-code',
             name: 'Claude Code',
-            install: { type: 'npm', cmd: '@anthropic-ai/claude-code@stable' },
+            install: { type: 'npm', cmd: '@anthropic-ai/claude-code@latest' },
             sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
             containerMount: '/home/devuser/.claude',
             versionCmd: 'claude --version',

package/dist/lib/table.js

@@ -0,0 +1,29 @@
+function formatTable(headers, rows) {
+    const columnCount = headers.length;
+    const widths = headers.map((header, i) => {
+        const headerLen = header.length;
+        let max = headerLen;
+        for (const row of rows) {
+            const cell = row[i] ?? '';
+            if (cell.length > max)
+                max = cell.length;
+        }
+        return max;
+    });
+    const renderRow = (values) => {
+        const parts = [];
+        for (let i = 0; i < columnCount; i += 1) {
+            const cell = values[i] ?? '';
+            if (i === columnCount - 1) {
+                parts.push(cell);
+            }
+            else {
+                parts.push(cell.padEnd(widths[i]));
+            }
+        }
+        return parts.join('  ').trimEnd();
+    };
+    return [renderRow(headers), ...rows.map((row) => renderRow(row))];
+}
+export { formatTable };
+//# sourceMappingURL=table.js.map

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

@@ -0,0 +1,122 @@
+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";
+const USAGE = `Usage: ai task ls [--all | --blocked | --completed]
+
+Lists tasks under .agents/workspace/. Defaults to active tasks only.
+  --all         Include active + blocked + completed (excludes archive)
+  --blocked     Only blocked tasks
+  --completed   Only completed tasks
+
+Columns: # (display-only row number) / SHORT (task short id, usable as an argument) / type / status / current_step / branch / title
+`;
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const TABLE_HEADERS = ['#', 'SHORT', 'TYPE', 'STATUS', 'STEP', 'BRANCH', 'TITLE'];
+function detectRepoRoot() {
+    try {
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        throw new Error('ai task: current directory is not inside a git repository');
+    }
+}
+function parseSelection(args) {
+    const positional = args.filter((a) => !a.startsWith('--'));
+    if (positional.length > 0) {
+        return {
+            ok: false,
+            message: `ai task ls: unexpected positional argument(s): ${positional.join(' ')}`
+        };
+    }
+    const flags = args.filter((a) => a.startsWith('--'));
+    if (flags.length === 0)
+        return { ok: true, selection: ['active'] };
+    if (flags.length > 1) {
+        return {
+            ok: false,
+            message: 'ai task ls: pass at most one of --all / --blocked / --completed'
+        };
+    }
+    switch (flags[0]) {
+        case '--all':
+            return { ok: true, selection: ['active', 'blocked', 'completed'] };
+        case '--blocked':
+            return { ok: true, selection: ['blocked'] };
+        case '--completed':
+            return { ok: true, selection: ['completed'] };
+        default:
+            return { ok: false, message: `ai task ls: unknown flag: ${flags[0]}` };
+    }
+}
+function collectTasks(repoRoot, state) {
+    const dir = path.join(repoRoot, '.agents', 'workspace', state);
+    if (!fs.existsSync(dir))
+        return [];
+    // Short ids live only in the registry and only for active tasks; archived
+    // (blocked/completed) tasks have released their short id and render '-'.
+    const shortIdByTaskId = state === 'active' ? loadShortIdByTaskId(repoRoot) : new Map();
+    const rows = [];
+    for (const entry of fs.readdirSync(dir).sort()) {
+        if (!TASK_ID_RE.test(entry))
+            continue;
+        const taskMdPath = path.join(dir, entry, 'task.md');
+        if (!fs.existsSync(taskMdPath))
+            continue;
+        const content = fs.readFileSync(taskMdPath, 'utf8');
+        const fm = parseTaskFrontmatter(content);
+        const title = extractTitle(content);
+        const shortId = shortIdByTaskId.get(entry) ?? '-';
+        rows.push({
+            shortId,
+            type: fm.type ?? '-',
+            status: fm.status ?? state,
+            step: fm.current_step ?? '-',
+            branch: fm.branch ?? '-',
+            title: title || fm.id || entry
+        });
+    }
+    return rows;
+}
+function ls(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const result = parseSelection(args);
+    if (!result.ok) {
+        process.stderr.write(`${result.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const { selection } = result;
+    const repoRoot = detectRepoRoot();
+    const rows = [];
+    for (const state of selection) {
+        rows.push(...collectTasks(repoRoot, state));
+    }
+    if (rows.length === 0) {
+        process.stdout.write(`No tasks under .agents/workspace/${selection.join('|')}\n`);
+        return;
+    }
+    const tableRows = rows.map((r, i) => [
+        String(i + 1),
+        r.shortId,
+        r.type,
+        r.status,
+        r.step,
+        r.branch,
+        r.title
+    ]);
+    for (const line of formatTable(TABLE_HEADERS, tableRows)) {
+        process.stdout.write(`${line}\n`);
+    }
+    process.stdout.write(`Total: ${rows.length} tasks\n`);
+}
+export { ls };
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { normalizeShortIdInput } from "../short-id.js";
+const USAGE = `Usage: ai task show <N | #N | TASK-id>
+
+Prints the task.md content for the matching task.
+  N (bare numeric)   Recommended; resolves the active short id via the registry.
+  '#N'               Compatibility form for old commands.
+  TASK-YYYYMMDD-HHMMSS  Locates a task in active / blocked / completed / archive.
+`;
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+// Flat-structured workspace dirs that hold tasks under `{dir}/{taskId}/task.md`.
+// Note: `archive` uses a three-level YYYY/MM/DD layout and is handled separately.
+const FLAT_WORKSPACE_DIRS = ['active', 'blocked', 'completed'];
+function detectRepoRoot() {
+    try {
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        throw new Error('ai task: current directory is not inside a git repository');
+    }
+}
+function readShortIdLength(repoRoot) {
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        const v = cfg?.task?.shortIdLength;
+        if (typeof v === 'number' && Number.isFinite(v) && v >= 1)
+            return v;
+    }
+    catch {
+        // fall through to default
+    }
+    return 2;
+}
+function resolveShortIdToTaskId(arg, repoRoot) {
+    const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+    if (!fs.existsSync(scriptPath)) {
+        throw new Error(`task-short-id.js not found at ${scriptPath}`);
+    }
+    const result = spawnSync('node', [scriptPath, 'resolve', arg], {
+        encoding: 'utf8',
+        cwd: repoRoot
+    });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || '').trim() || `failed to resolve '${arg}'`);
+    }
+    return result.stdout.trim();
+}
+function listSortedNumeric(dir, width) {
+    if (!fs.existsSync(dir))
+        return [];
+    const pattern = new RegExp(`^\\d{${width}}$`);
+    return fs
+        .readdirSync(dir)
+        .filter((entry) => pattern.test(entry))
+        .sort()
+        .reverse();
+}
+function findInArchive(repoRoot, taskId) {
+    // archive-tasks SKILL writes to .agents/workspace/archive/YYYY/MM/DD/{taskId}/task.md
+    // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
+    // the task id's creation date. So we cannot derive the path from taskId alone;
+    // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
+    const archiveDir = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    for (const year of listSortedNumeric(archiveDir, 4)) {
+        const yearDir = path.join(archiveDir, year);
+        for (const month of listSortedNumeric(yearDir, 2)) {
+            const monthDir = path.join(yearDir, month);
+            for (const day of listSortedNumeric(monthDir, 2)) {
+                const candidate = path.join(monthDir, day, taskId, 'task.md');
+                if (fs.existsSync(candidate))
+                    return candidate;
+            }
+        }
+    }
+    return null;
+}
+function findTaskMd(repoRoot, taskId) {
+    for (const sub of FLAT_WORKSPACE_DIRS) {
+        const candidate = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return findInArchive(repoRoot, taskId);
+}
+function show(args = []) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        if (args.length === 0)
+            process.exitCode = 1;
+        return;
+    }
+    const repoRoot = detectRepoRoot();
+    const arg = args[0];
+    let taskId;
+    if (TASK_ID_RE.test(arg)) {
+        taskId = arg;
+    }
+    else {
+        const shortIdLength = readShortIdLength(repoRoot);
+        const normalized = normalizeShortIdInput(arg, { shortIdLength });
+        if (normalized.kind === 'error') {
+            process.stderr.write(`ai task show: ${normalized.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        if (normalized.kind === 'pass') {
+            process.stderr.write(`ai task show: '${arg}' is not a valid short id or TASK-id; ` +
+                `expected bare digits, '#N', or 'TASK-YYYYMMDD-HHMMSS'\n`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            taskId = resolveShortIdToTaskId(normalized.value, repoRoot);
+        }
+        catch (e) {
+            process.stderr.write(`ai task show: ${e.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const taskMdPath = findTaskMd(repoRoot, taskId);
+    if (!taskMdPath) {
+        process.stderr.write(`ai task show: task ${taskId} not found in active / blocked / completed / archive\n`);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(fs.readFileSync(taskMdPath, 'utf8'));
+}
+export { show };
+//# sourceMappingURL=show.js.map

package/dist/lib/task/frontmatter.js

@@ -0,0 +1,32 @@
+function parseTaskFrontmatter(content) {
+    const result = {};
+    if (!content.startsWith('---'))
+        return result;
+    const end = content.indexOf('\n---', 3);
+    if (end === -1)
+        return result;
+    const body = content.slice(3, end);
+    for (const rawLine of body.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (!line.trim())
+            continue;
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (key)
+            result[key] = value;
+    }
+    return result;
+}
+function extractTitle(content) {
+    for (const line of content.split('\n')) {
+        const m = /^#\s+(?:任务[:：]?\s*)?(.+)$/.exec(line.trim());
+        if (m && m[1])
+            return m[1].trim();
+    }
+    return '';
+}
+export { parseTaskFrontmatter, extractTitle };
+//# sourceMappingURL=frontmatter.js.map

package/dist/lib/task/index.js

@@ -0,0 +1,41 @@
+const USAGE = `Usage: ai task <command> [options]
+
+Commands:
+  ls [--all | --blocked | --completed]   List tasks (default: active)
+  show <N | #N | TASK-id>                Print a task.md
+
+Examples:
+  ai task ls
+  ai task show 11
+  ai task show TASK-20260612-162737
+
+Run 'ai task <command> --help' for details.`;
+export async function runTask(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        process.stdout.write(`${USAGE}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    switch (subcommand) {
+        case 'ls': {
+            const { ls } = await import("./commands/ls.js");
+            ls(rest);
+            break;
+        }
+        case 'show': {
+            const { show } = await import("./commands/show.js");
+            show(rest);
+            break;
+        }
+        default:
+            process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
+            process.stdout.write(`${USAGE}\n`);
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=index.js.map