@fitlab-ai/agent-infra 0.7.0 → 0.7.2

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

@@ -1,7 +1,20 @@
+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 WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
+function resolveShortIdStrict(arg, repoRoot) {
+    const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+    if (!fs.existsSync(scriptPath)) {
+        throw new Error(`Short id '${arg}' provided but task-short-id.js script is missing at ${scriptPath}`);
+    }
+    const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
+    if (result.status !== 0) {
+        throw new Error(`Short id '${arg}' not found in active task registry: ${(result.stderr || '').trim()}`);
+    }
+    return result.stdout.trim();
+}
 function stripQuotes(value) {
     return value.replace(/^(["'])(.*)\1$/, '$2');
 }
@@ -26,6 +39,11 @@ function resolveBranchFromTaskContent(content, taskId) {
     throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
 export function resolveTaskBranch(arg, repoRoot) {
+    if (SHORT_ID_RE.test(arg)) {
+        const taskId = resolveShortIdStrict(arg, repoRoot);
+        const content = readTaskContent(repoRoot, taskId);
+        return resolveBranchFromTaskContent(content, taskId);
+    }
     if (!TASK_ID_RE.test(arg)) {
         return arg;
     }

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

package/dist/lib/task/short-id.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const REGISTRY_NAME = '.short-ids.json';
+function normalizeShortIdInput(input, opts) {
+    const L = opts.shortIdLength;
+    const m = /^#?(\d+)$/.exec(input);
+    if (!m) {
+        return { kind: 'pass', value: input };
+    }
+    const n = Number(m[1]);
+    if (n === 0) {
+        return {
+            kind: 'error',
+            message: `short id '${input}' is invalid (#${'0'.repeat(L)} is reserved)`
+        };
+    }
+    const max = Math.pow(10, L) - 1;
+    if (n > max) {
+        return {
+            kind: 'error',
+            message: `short id ${n} exceeds shortIdLength=${L} capacity (max=${max}); archive tasks or raise task.shortIdLength in .agents/.airc.json`
+        };
+    }
+    return { kind: 'shortId', value: `#${String(n).padStart(L, '0')}` };
+}
+function readRegistry(repoRoot) {
+    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+    if (!fs.existsSync(registryPath))
+        return null;
+    try {
+        const raw = fs.readFileSync(registryPath, 'utf8');
+        const data = JSON.parse(raw);
+        if (!data || typeof data !== 'object' || !data.ids)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function readBranchFromTaskMd(repoRoot, taskId) {
+    const taskMdPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+    if (!fs.existsSync(taskMdPath))
+        return null;
+    const content = fs.readFileSync(taskMdPath, 'utf8');
+    const m = content.match(/^branch:\s*(.+)$/m);
+    if (!m || !m[1])
+        return null;
+    return m[1].trim().replace(/^(["'])(.*)\1$/, '$2');
+}
+function loadShortIdByTaskId(repoRoot) {
+    const registry = readRegistry(repoRoot);
+    const map = new Map();
+    if (!registry)
+        return map;
+    for (const [key, taskId] of Object.entries(registry.ids)) {
+        map.set(taskId, `#${key}`);
+    }
+    return map;
+}
+function lookupShortIdByBranch(branch, repoRoot, _opts) {
+    const registry = readRegistry(repoRoot);
+    if (!registry)
+        return null;
+    const matches = [];
+    for (const [key, taskId] of Object.entries(registry.ids)) {
+        const taskBranch = readBranchFromTaskMd(repoRoot, taskId);
+        if (taskBranch && taskBranch === branch) {
+            matches.push(`#${key}`);
+        }
+    }
+    if (matches.length === 0)
+        return null;
+    if (matches.length > 1) {
+        process.stderr.write(`Warning: branch '${branch}' is bound to multiple active tasks: ${matches.join(', ')}; using ${matches[0]}\n`);
+    }
+    return matches[0];
+}
+export { normalizeShortIdInput, lookupShortIdByBranch, loadShortIdByTaskId };
+//# sourceMappingURL=short-id.js.map

package/dist/lib/update.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { info, ok, err } from "./log.js";
 import { resolveTemplateDir } from "./paths.js";
 import { renderFile, copySkillDir, KNOWN_PLATFORMS } from "./render.js";
+import { isPathOwnedByDisabledTUI, resolveEnabledTUIs } from "./builtin-tuis.js";
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const CONFIG_DIR = '.agents';
 const CONFIG_PATH = path.join(CONFIG_DIR, '.airc.json');
@@ -15,7 +16,7 @@ function isPathOwnedByOtherPlatform(relativePath, platformType) {
         return false;
     return candidate !== platformType;
 }
-function syncFileRegistry(config, platformType) {
+function syncFileRegistry(config, platformType, enabledTUIs) {
     config.files ||= {};
     const before = JSON.stringify({
         files: {
@@ -36,6 +37,8 @@ function syncFileRegistry(config, platformType) {
     for (const entry of defaults.files.managed) {
         if (isPathOwnedByOtherPlatform(entry, platformType))
             continue;
+        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
+            continue;
         if (!allExisting.includes(entry)) {
             config.files.managed.push(entry);
             added.managed.push(entry);
@@ -44,6 +47,8 @@ function syncFileRegistry(config, platformType) {
     for (const entry of defaults.files.merged) {
         if (isPathOwnedByOtherPlatform(entry, platformType))
             continue;
+        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
+            continue;
         if (!allExisting.includes(entry)) {
             config.files.merged.push(entry);
             added.merged.push(entry);
@@ -82,6 +87,7 @@ async function cmdUpdate() {
     const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     const { project, org, language } = config;
     const platformType = config.platform?.type || defaults.platform.type;
+    const enabledTUIs = resolveEnabledTUIs(config.tuis);
     const replacements = { project, org };
     info(`Updating seed files for: ${project}`);
     console.log('');
@@ -106,20 +112,27 @@ async function cmdUpdate() {
     catch {
         // Ignore missing legacy script from pre-ESM installs.
     }
-    // update Claude command
-    renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Updated .claude/commands/update-agent-infra.md');
-    // update Gemini command
-    renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
-    ok(`Updated .gemini/commands/${project}/update-agent-infra.toml`);
-    // update OpenCode command
-    renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Updated .opencode/commands/update-agent-infra.md');
+    // update Claude command (only if enabled)
+    if (enabledTUIs.has('claude-code')) {
+        renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Updated .claude/commands/update-agent-infra.md');
+    }
+    // update Gemini command (only if enabled)
+    if (enabledTUIs.has('gemini-cli')) {
+        renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
+        ok(`Updated .gemini/commands/${project}/update-agent-infra.toml`);
+    }
+    // update OpenCode command (only if enabled)
+    if (enabledTUIs.has('opencode')) {
+        renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Updated .opencode/commands/update-agent-infra.md');
+    }
     // sync file registry
-    const { added, changed } = syncFileRegistry(config, platformType);
+    const { added, changed } = syncFileRegistry(config, platformType, enabledTUIs);
     const hasNewEntries = added.managed.length > 0 || added.merged.length > 0;
     const platformAdded = !config.platform;
     const sandboxAdded = !config.sandbox;
+    const taskAdded = !config.task;
     const labelsAdded = !config.labels;
     const requiresPullRequestAdded = config.requiresPullRequest === undefined;
     let configChanged = changed;
@@ -131,6 +144,10 @@ async function cmdUpdate() {
         config.sandbox = structuredClone(defaults.sandbox);
         configChanged = true;
     }
+    if (taskAdded) {
+        config.task = structuredClone(defaults.task);
+        configChanged = true;
+    }
     if (labelsAdded) {
         config.labels = structuredClone(defaults.labels);
         configChanged = true;
@@ -150,13 +167,16 @@ async function cmdUpdate() {
                 ok(`  merged: ${entry}`);
             }
         }
-        else if (platformAdded || sandboxAdded || labelsAdded || requiresPullRequestAdded) {
+        else if (platformAdded || sandboxAdded || taskAdded || labelsAdded || requiresPullRequestAdded) {
             if (platformAdded) {
                 info(`Default platform config added to ${CONFIG_PATH}.`);
             }
             if (sandboxAdded) {
                 info(`Default sandbox config added to ${CONFIG_PATH}.`);
             }
+            if (taskAdded) {
+                info(`Default task.shortIdLength=${defaults.task.shortIdLength} added to ${CONFIG_PATH}.`);
+            }
             if (labelsAdded) {
                 info(`Default labels.in config added to ${CONFIG_PATH}.`);
             }
@@ -170,6 +190,9 @@ async function cmdUpdate() {
         if (hasNewEntries && sandboxAdded) {
             info(`Default sandbox config added to ${CONFIG_PATH}.`);
         }
+        if (hasNewEntries && taskAdded) {
+            info(`Default task.shortIdLength=${defaults.task.shortIdLength} added to ${CONFIG_PATH}.`);
+        }
         if (hasNewEntries && labelsAdded) {
             info(`Default labels.in config added to ${CONFIG_PATH}.`);
         }
@@ -186,12 +209,30 @@ async function cmdUpdate() {
     console.log('');
     ok('Seed files updated successfully!');
     console.log('');
-    console.log('  Next step: run the full update in your AI TUI:');
-    console.log('');
-    console.log('    Claude Code / OpenCode:  /update-agent-infra');
-    console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
-    console.log('    Codex CLI:               $update-agent-infra');
-    console.log('');
+    if (enabledTUIs.size === 0) {
+        console.log('  No built-in TUI enabled (tuis: []).');
+        console.log(`  Configure "customTUIs" in ${CONFIG_PATH} if needed.`);
+        console.log('');
+    }
+    else {
+        console.log('  Next step: run the full update in your AI TUI:');
+        console.log('');
+        const claudeOrOpencode = [];
+        if (enabledTUIs.has('claude-code'))
+            claudeOrOpencode.push('Claude Code');
+        if (enabledTUIs.has('opencode'))
+            claudeOrOpencode.push('OpenCode');
+        if (claudeOrOpencode.length > 0) {
+            console.log(`    ${claudeOrOpencode.join(' / ')}:  /update-agent-infra`);
+        }
+        if (enabledTUIs.has('gemini-cli')) {
+            console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
+        }
+        if (enabledTUIs.has('codex')) {
+            console.log('    Codex CLI:               $update-agent-infra');
+        }
+        console.log('');
+    }
 }
 export { cmdUpdate };
 //# sourceMappingURL=update.js.map