@fitlab-ai/agent-infra 0.7.7 → 0.8.1

package/README.md

@@ -82,6 +82,7 @@ Every command above works the same way in Claude Code, Codex, Gemini CLI, and Op
 
 - **Multi-AI collaboration**: one shared operating model for Claude Code, Codex, Gemini CLI, and OpenCode
 - **Bootstrap CLI + skill-driven execution**: initialize once, then let AI skills drive day-to-day work
+- **IM command bridge**: route Feishu messages to built-ins, read-only task views, sandbox management, and controlled lifecycle skill runs
 - **Bilingual project docs**: English-first docs with synchronized Chinese translations
 - **Template-source architecture**: `templates/` mirrors the rendered project structure
 - **AI-assisted updates**: template changes can be merged while preserving project-specific customization
@@ -191,6 +192,7 @@ In-depth guides live under [`docs/en/`](./docs/en/README.md):
 - [Architecture Overview](./docs/en/architecture.md) — bootstrap CLI, end-to-end flow, layered architecture
 - [Platform Support](./docs/en/platform-support.md) — macOS, Linux, Windows; sandbox engines and resources
 - [Sandbox](./docs/en/sandbox.md) — sandbox aliases, host-sandbox file exchange, user-level dotfiles channel
+- [Feishu Bridge](./docs/en/feishu-bridge.md) — configure the Feishu long-connection adapter, command routing, permissions, and TUI selection
 - [Built-in AI Skills](./docs/en/skills.md) — the full skill catalog by use case
 - [Custom Skills](./docs/en/custom-skills.md) — create and sync project-specific skills
 - [Custom TUI Configuration](./docs/en/custom-tui.md) — adapt agent-infra to non-built-in AI TUIs

package/README.zh-CN.md

@@ -82,6 +82,7 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 
 - **多 AI 协作**：为 Claude Code、Codex、Gemini CLI、OpenCode 提供统一的协作模型
 - **引导 CLI + skill 驱动执行**：初始化一次，后续日常操作交给 AI skills
+- **IM 命令桥接**：把飞书消息路由到内置命令、任务只读视图、沙箱管理和受控生命周期 skill 执行
 - **双语文档**：英文为主文档，配套同步的中文版本
 - **模板源架构**：`templates/` 目录镜像最终渲染出的项目结构
 - **AI 辅助升级**：模板升级时可合并变更，同时尽量保留项目侧定制
@@ -191,6 +192,7 @@ my-project/
 - [架构概览](./docs/zh-CN/architecture.md) — 引导 CLI、端到端流程、分层架构
 - [平台支持](./docs/zh-CN/platform-support.md) — macOS、Linux、Windows；沙箱引擎与资源配置
 - [沙箱](./docs/zh-CN/sandbox.md) — 沙箱 aliases、宿主-沙箱文件交换、用户级 dotfiles 通道
+- [飞书桥接](./docs/zh-CN/feishu-bridge.md) — 配置飞书长连接 adapter、命令路由、权限和 TUI 选择
 - [内置 AI Skills](./docs/zh-CN/skills.md) — 按使用场景分组的完整 skill 清单
 - [自定义 Skills](./docs/zh-CN/custom-skills.md) — 创建并同步项目专属 skill
 - [自定义 TUI 配置](./docs/zh-CN/custom-tui.md) — 适配非内置的 AI TUI

package/bin/cli.ts

@@ -16,10 +16,13 @@ Usage: ai <command> [options]
 
 Commands:
   cp <ssh-alias>  Copy local clipboard image to a remote macOS NSPasteboard
+  decide          Record a human decision for a task HD item
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
   merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
+  run             Schedule a lifecycle skill in the task sandbox tmux session
   sandbox, s      Manage Docker-based AI sandboxes
+  server          Run the local AI collaboration daemon (start/stop/status/logs)
   task, t         Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
   update          Update seed files and sync file registry for an existing project
   version         Show version
@@ -68,21 +71,29 @@ async function importCommand(importPath: string) {
 }
 
 switch (command) {
-  case 'init': {
-    const imported = await importCommand('../lib/init.ts');
+  case 'cp': {
+    const imported = await importCommand('../lib/cp.ts');
     if (!imported) break;
-    const { cmdInit } = imported;
-    await cmdInit().catch((e: unknown) => {
+    const { cmdCp } = imported;
+    const code = await cmdCp(process.argv.slice(3)).catch((e: unknown) => {
       process.stderr.write(`Error: ${errorMessage(e)}\n`);
-      process.exitCode = 1;
+      return 1;
     });
+    if (code) process.exitCode = code;
     break;
   }
-  case 'update': {
-    const imported = await importCommand('../lib/update.ts');
+  case 'decide': {
+    const imported = await importCommand('../lib/decide.ts');
     if (!imported) break;
-    const { cmdUpdate } = imported;
-    await cmdUpdate().catch((e: unknown) => {
+    const { cmdDecide } = imported;
+    await cmdDecide(process.argv.slice(3));
+    break;
+  }
+  case 'init': {
+    const imported = await importCommand('../lib/init.ts');
+    if (!imported) break;
+    const { cmdInit } = imported;
+    await cmdInit().catch((e: unknown) => {
       process.stderr.write(`Error: ${errorMessage(e)}\n`);
       process.exitCode = 1;
     });
@@ -98,6 +109,13 @@ switch (command) {
     });
     break;
   }
+  case 'run': {
+    const imported = await importCommand('../lib/run/index.ts');
+    if (!imported) break;
+    const { cmdRun } = imported;
+    await cmdRun(process.argv.slice(3));
+    break;
+  }
   case 'sandbox': {
     const imported = await importCommand('../lib/sandbox/index.ts');
     if (!imported) break;
@@ -108,6 +126,16 @@ switch (command) {
     });
     break;
   }
+  case 'server': {
+    const imported = await importCommand('../lib/server/index.ts');
+    if (!imported) break;
+    const { runServer } = imported;
+    await runServer(process.argv.slice(3)).catch((e: unknown) => {
+      process.stderr.write(`Error: ${errorMessage(e)}\n`);
+      process.exit(1);
+    });
+    break;
+  }
   case 'task': {
     const imported = await importCommand('../lib/task/index.ts');
     if (!imported) break;
@@ -118,15 +146,14 @@ switch (command) {
     });
     break;
   }
-  case 'cp': {
-    const imported = await importCommand('../lib/cp.ts');
+  case 'update': {
+    const imported = await importCommand('../lib/update.ts');
     if (!imported) break;
-    const { cmdCp } = imported;
-    const code = await cmdCp(process.argv.slice(3)).catch((e: unknown) => {
+    const { cmdUpdate } = imported;
+    await cmdUpdate().catch((e: unknown) => {
       process.stderr.write(`Error: ${errorMessage(e)}\n`);
-      return 1;
+      process.exitCode = 1;
     });
-    if (code) process.exitCode = code;
     break;
   }
   case 'version': {

package/dist/bin/cli.js

@@ -20,10 +20,13 @@ Usage: ai <command> [options]
 
 Commands:
   cp <ssh-alias>  Copy local clipboard image to a remote macOS NSPasteboard
+  decide          Record a human decision for a task HD item
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
   merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
+  run             Schedule a lifecycle skill in the task sandbox tmux session
   sandbox, s      Manage Docker-based AI sandboxes
+  server          Run the local AI collaboration daemon (start/stop/status/logs)
   task, t         Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
   update          Update seed files and sync file registry for an existing project
   version         Show version
@@ -66,23 +69,33 @@ async function importCommand(importPath) {
     }
 }
 switch (command) {
-    case 'init': {
-        const imported = await importCommand('../lib/init.ts');
+    case 'cp': {
+        const imported = await importCommand('../lib/cp.ts');
         if (!imported)
             break;
-        const { cmdInit } = imported;
-        await cmdInit().catch((e) => {
+        const { cmdCp } = imported;
+        const code = await cmdCp(process.argv.slice(3)).catch((e) => {
             process.stderr.write(`Error: ${errorMessage(e)}\n`);
-            process.exitCode = 1;
+            return 1;
         });
+        if (code)
+            process.exitCode = code;
         break;
     }
-    case 'update': {
-        const imported = await importCommand('../lib/update.ts');
+    case 'decide': {
+        const imported = await importCommand('../lib/decide.ts');
         if (!imported)
             break;
-        const { cmdUpdate } = imported;
-        await cmdUpdate().catch((e) => {
+        const { cmdDecide } = imported;
+        await cmdDecide(process.argv.slice(3));
+        break;
+    }
+    case 'init': {
+        const imported = await importCommand('../lib/init.ts');
+        if (!imported)
+            break;
+        const { cmdInit } = imported;
+        await cmdInit().catch((e) => {
             process.stderr.write(`Error: ${errorMessage(e)}\n`);
             process.exitCode = 1;
         });
@@ -99,6 +112,14 @@ switch (command) {
         });
         break;
     }
+    case 'run': {
+        const imported = await importCommand('../lib/run/index.ts');
+        if (!imported)
+            break;
+        const { cmdRun } = imported;
+        await cmdRun(process.argv.slice(3));
+        break;
+    }
     case 'sandbox': {
         const imported = await importCommand('../lib/sandbox/index.ts');
         if (!imported)
@@ -110,6 +131,17 @@ switch (command) {
         });
         break;
     }
+    case 'server': {
+        const imported = await importCommand('../lib/server/index.ts');
+        if (!imported)
+            break;
+        const { runServer } = imported;
+        await runServer(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exit(1);
+        });
+        break;
+    }
     case 'task': {
         const imported = await importCommand('../lib/task/index.ts');
         if (!imported)
@@ -121,17 +153,15 @@ switch (command) {
         });
         break;
     }
-    case 'cp': {
-        const imported = await importCommand('../lib/cp.ts');
+    case 'update': {
+        const imported = await importCommand('../lib/update.ts');
         if (!imported)
             break;
-        const { cmdCp } = imported;
-        const code = await cmdCp(process.argv.slice(3)).catch((e) => {
+        const { cmdUpdate } = imported;
+        await cmdUpdate().catch((e) => {
             process.stderr.write(`Error: ${errorMessage(e)}\n`);
-            return 1;
+            process.exitCode = 1;
         });
-        if (code)
-            process.exitCode = code;
         break;
     }
     case 'version': {

package/dist/lib/decide.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { VERSION } from "./version.js";
+import { resolveTaskRef } from "./task/resolve-ref.js";
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+function detectRepoRoot() {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+}
+function defaultNow() {
+    return new Intl.DateTimeFormat('sv-SE', {
+        timeZoneName: 'longOffset',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false
+    })
+        .format(new Date())
+        .replace(' GMT', '');
+}
+function taskPath(repoRoot, ref) {
+    if (!TASK_ID_RE.test(ref)) {
+        const resolved = resolveTaskRef(ref);
+        if (!resolved.ok)
+            throw new Error(resolved.message);
+        if (!resolved.taskDir.includes(`${path.join('.agents', 'workspace', 'active')}${path.sep}`)) {
+            throw new Error(`task ${resolved.taskId} is not active`);
+        }
+        return resolved.taskMdPath;
+    }
+    const candidate = path.join(repoRoot, '.agents', 'workspace', 'active', ref, 'task.md');
+    if (!fs.existsSync(candidate))
+        throw new Error(`active task not found: ${ref}`);
+    return candidate;
+}
+function replaceFrontmatterField(content, field, value) {
+    const re = new RegExp(`^${field}:.*$`, 'm');
+    if (re.test(content))
+        return content.replace(re, `${field}: ${value}`);
+    return content.replace(/^---\n/, `---\n${field}: ${value}\n`);
+}
+function replaceLedgerRow(content, hdId) {
+    const lines = content.split('\n');
+    let found = false;
+    let pending = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (!line.trim().startsWith(`| ${hdId} |`))
+            continue;
+        found = true;
+        const cells = line.split('|').slice(1, -1).map((cell) => cell.trim());
+        if (cells[4] !== 'needs-human-decision')
+            break;
+        pending = true;
+        cells[4] = 'human-decided';
+        cells[5] = `task.md#${hdId}`;
+        lines[i] = `| ${cells.join(' | ')} |`;
+        break;
+    }
+    return { content: lines.join('\n'), found, pending };
+}
+function appendUnderHeading(content, heading, block) {
+    if (!content.includes(`${heading}\n`)) {
+        return `${content.trimEnd()}\n\n${heading}\n\n${block}\n`;
+    }
+    const idx = content.indexOf(`${heading}\n`) + heading.length + 1;
+    const before = content.slice(0, idx);
+    const after = content.slice(idx);
+    return `${before}\n${block}\n${after.replace(/^\n/, '')}`;
+}
+export async function decide(args, options = {}) {
+    const [taskRef, hdId, ...decisionParts] = args;
+    if (!taskRef || !hdId || decisionParts.length === 0) {
+        process.stderr.write('Usage: ai decide <task-ref> <HD-id> <decision>\n');
+        return 1;
+    }
+    try {
+        const repoRoot = options.repoRoot ?? detectRepoRoot();
+        const file = taskPath(repoRoot, taskRef);
+        let content = fs.readFileSync(file, 'utf8');
+        const replaced = replaceLedgerRow(content, hdId);
+        if (!replaced.found)
+            throw new Error(`${hdId} not found in review ledger`);
+        if (!replaced.pending)
+            throw new Error(`${hdId} is not needs-human-decision`);
+        content = replaced.content;
+        const now = (options.now ?? defaultNow)();
+        content = replaceFrontmatterField(content, 'updated_at', now);
+        content = replaceFrontmatterField(content, 'agent_infra_version', options.version ?? VERSION);
+        const decision = decisionParts.join(' ');
+        content = appendUnderHeading(content, '## 人工裁决', `### ${hdId}\n\n- **裁决时间**：${now}\n- **裁决结果**：${decision}`);
+        content = appendUnderHeading(content, '## 活动日志', `- ${now} — **Human Decision** by human — ${hdId} decided`);
+        fs.writeFileSync(file, content);
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+export async function cmdDecide(args) {
+    process.exitCode = await decide(args);
+}
+//# sourceMappingURL=decide.js.map

package/dist/lib/run/host.js

@@ -0,0 +1,39 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function resolveCommand(file) {
+    if (process.platform !== 'win32' || path.extname(file)) {
+        return file;
+    }
+    const pathValue = process.env.Path || process.env.PATH || '';
+    const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
+            if (fs.existsSync(lowerCandidate))
+                return lowerCandidate;
+            const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
+            if (fs.existsSync(upperCandidate))
+                return upperCandidate;
+        }
+    }
+    return file;
+}
+function needsShell(file) {
+    return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+export async function runHostCommand(command) {
+    const [file, ...args] = command;
+    if (!file)
+        throw new Error('run: missing command');
+    return new Promise((resolve, reject) => {
+        const resolvedFile = resolveCommand(file);
+        const child = spawn(resolvedFile, args, {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            shell: needsShell(resolvedFile)
+        });
+        child.on('error', reject);
+        child.on('close', (exitCode, signal) => resolve({ exitCode, signal }));
+    });
+}
+//# sourceMappingURL=host.js.map

package/dist/lib/run/index.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadServerConfig } from "../server/config.js";
+import { resolveTaskBranch } from "../sandbox/task-resolver.js";
+import { createRunId, runInSandbox } from "../sandbox/capture.js";
+import { loadShortIdByTaskId, normalizeShortIdInput } from "../task/short-id.js";
+import { buildTuiCommand, renderPrompt, selectTui } from "./tui.js";
+import { getSkillRunSpec } from "./skills.js";
+import { runHostCommand } from "./host.js";
+const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>]
+
+Task skills are scheduled inside the sandbox tmux session; ai run returns once
+the tmux window is created.
+
+Examples:
+  ai run create-task "describe the task" --tui codex
+  ai run code-task #7 --tui codex`;
+function extractTui(args) {
+    const rest = [];
+    let tui = null;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--tui') {
+            const value = args[i + 1];
+            if (!value)
+                throw new Error('--tui requires a value');
+            tui = value;
+            i += 1;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, tui };
+}
+export function parseRunArgs(args) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        throw new Error(USAGE);
+    }
+    const { rest, tui } = extractTui(args);
+    const [skill = '', maybeTaskRef, ...remaining] = rest;
+    const spec = getSkillRunSpec(skill);
+    if (!spec)
+        throw new Error(`Unknown skill '${skill}'`);
+    if (spec.kind === 'create') {
+        const createArgs = rest.slice(1);
+        if (createArgs.length === 0)
+            throw new Error('create-task requires a description');
+        return { skill, taskRef: null, args: createArgs, tui };
+    }
+    if (!maybeTaskRef)
+        throw new Error(`${skill} requires a task-ref`);
+    return { skill, taskRef: maybeTaskRef, args: remaining, tui };
+}
+function assertAllowedByConfig(skill, commandConfig) {
+    const allowed = commandConfig.allowedSkills;
+    if (!Array.isArray(allowed))
+        return;
+    if (!allowed.every((entry) => typeof entry === 'string')) {
+        throw new Error('command.allowedSkills must be an array of skill names');
+    }
+    if (!allowed.includes(skill)) {
+        throw new Error(`Skill '${skill}' is not allowed by command.allowedSkills`);
+    }
+}
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+function readShortIdLength(repoRoot) {
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        const value = cfg?.task?.shortIdLength;
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 1)
+            return value;
+    }
+    catch {
+        // Use the project default when config is absent in lightweight tests.
+    }
+    return 2;
+}
+function readActiveShortIdRegistry(repoRoot) {
+    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', '.short-ids.json');
+    try {
+        const data = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+        return data && typeof data === 'object' && data.ids && typeof data.ids === 'object' ? data.ids : {};
+    }
+    catch {
+        return {};
+    }
+}
+function resolveActiveTaskIdentity(taskRef, repoRoot) {
+    let taskId = null;
+    let resolvedTaskRef = taskRef;
+    if (TASK_ID_RE.test(taskRef)) {
+        taskId = taskRef;
+        resolvedTaskRef = loadShortIdByTaskId(repoRoot).get(taskId) ?? taskRef;
+    }
+    else {
+        const normalized = normalizeShortIdInput(taskRef, { shortIdLength: readShortIdLength(repoRoot) });
+        if (normalized.kind !== 'shortId')
+            return null;
+        resolvedTaskRef = normalized.value;
+        taskId = readActiveShortIdRegistry(repoRoot)[normalized.value.slice(1)] ?? null;
+    }
+    if (!taskId)
+        return null;
+    const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    if (!fs.existsSync(path.join(taskDir, 'task.md')))
+        return null;
+    return { taskId, taskDir, taskRef: resolvedTaskRef };
+}
+function formatLocalTimestamp(date = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const year = date.getFullYear();
+    const month = pad(date.getMonth() + 1);
+    const day = pad(date.getDate());
+    const hour = pad(date.getHours());
+    const minute = pad(date.getMinutes());
+    const second = pad(date.getSeconds());
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const offsetHour = pad(Math.floor(Math.abs(offsetMinutes) / 60));
+    const offsetMinute = pad(Math.abs(offsetMinutes) % 60);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}${sign}${offsetHour}:${offsetMinute}`;
+}
+function writeRunRecord(params) {
+    const runsDir = path.join(params.identity.taskDir, 'runs');
+    fs.mkdirSync(runsDir, { recursive: true });
+    const record = {
+        version: 1,
+        run_id: params.run.runId,
+        task_id: params.identity.taskId,
+        task_ref: params.identity.taskRef,
+        branch: params.branch,
+        engine: params.run.engine,
+        container: params.run.container,
+        run_dir: params.run.runDir,
+        status_file: `${params.run.runDir}/status`,
+        log_file: `${params.run.runDir}/output.log`,
+        created_at: formatLocalTimestamp(),
+        command: params.command
+    };
+    fs.writeFileSync(path.join(runsDir, `${params.run.runId}.json`), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+}
+export async function runSkill(args, options = {}) {
+    const parsed = parseRunArgs(args);
+    const config = options.command ? null : loadServerConfig({ rootDir: options.repoRoot });
+    const commandConfig = options.command ?? config?.command ?? {};
+    assertAllowedByConfig(parsed.skill, commandConfig);
+    const tui = selectTui(parsed.skill, { cliTui: parsed.tui, command: commandConfig });
+    const promptArgs = parsed.taskRef === null ? parsed.args : [parsed.taskRef, ...parsed.args];
+    const prompt = renderPrompt({ tui, skill: parsed.skill, args: promptArgs });
+    const [file, argv] = buildTuiCommand(tui, prompt);
+    const command = [file, ...argv];
+    if (parsed.taskRef === null) {
+        const result = await (options.runHost ?? runHostCommand)(command);
+        return result.exitCode ?? (result.signal ? 1 : 0);
+    }
+    const repoRoot = options.repoRoot ?? config?.repoRoot ?? process.cwd();
+    const branch = resolveTaskBranch(parsed.taskRef, repoRoot);
+    const identity = resolveActiveTaskIdentity(parsed.taskRef, repoRoot);
+    const runId = identity ? createRunId() : undefined;
+    const writeStdout = options.writeStdout ?? ((chunk) => process.stdout.write(chunk));
+    const writeStderr = options.writeStderr ?? ((chunk) => process.stderr.write(chunk));
+    const runSandbox = options.runSandbox ??
+        ((request) => runInSandbox(request));
+    const result = await runSandbox({ taskRef: parsed.taskRef, branch, command, runId });
+    if (result.stdout) {
+        writeStdout(result.stdout);
+    }
+    if (result.stderr) {
+        writeStderr(result.stderr);
+    }
+    if ((result.exitCode ?? (result.signal ? 1 : 0)) === 0 && identity && result.run) {
+        writeRunRecord({ identity, run: result.run, branch, command });
+    }
+    return result.exitCode ?? (result.signal ? 1 : 0);
+}
+export async function cmdRun(args) {
+    try {
+        const code = await runSkill(args);
+        process.exitCode = code;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith('Usage:')) {
+            process.stdout.write(`${message}\n`);
+            process.exitCode = args.length === 0 ? 1 : 0;
+        }
+        else {
+            process.stderr.write(`Error: ${message}\n`);
+            process.exitCode = 1;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/run/prompt.js

@@ -0,0 +1,2 @@
+export { renderPrompt } from "./tui.js";
+//# sourceMappingURL=prompt.js.map

package/dist/lib/run/skills.js

@@ -0,0 +1,29 @@
+const TASK_SKILLS = new Set([
+    'analyze-task',
+    'block-task',
+    'cancel-task',
+    'code-task',
+    'commit',
+    'complete-task',
+    'create-pr',
+    'plan-task',
+    'review-analysis',
+    'review-code',
+    'review-plan',
+    'test',
+    'test-integration',
+    'watch-pr'
+]);
+export function getSkillRunSpec(skill) {
+    if (skill === 'create-task') {
+        return { kind: 'create', skill: 'create-task', role: 'exec', requiresSandbox: false };
+    }
+    if (TASK_SKILLS.has(skill)) {
+        return { kind: 'task', skill, role: 'exec', requiresSandbox: true };
+    }
+    return null;
+}
+export function allowedSkillNames() {
+    return ['create-task', ...TASK_SKILLS].sort();
+}
+//# sourceMappingURL=skills.js.map

package/dist/lib/run/tui.js

@@ -0,0 +1,35 @@
+const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+function isTuiName(value) {
+    return typeof value === 'string' && TUI_NAMES.has(value);
+}
+export function selectTui(skill, options) {
+    if (isTuiName(options.cliTui))
+        return options.cliTui;
+    const defaults = options.command?.skillTuiDefaults;
+    if (defaults && typeof defaults === 'object' && !Array.isArray(defaults)) {
+        const value = defaults[skill];
+        if (isTuiName(value))
+            return value;
+    }
+    if (isTuiName(options.command?.defaultTui))
+        return options.command.defaultTui;
+    return 'codex';
+}
+export function renderPrompt(params) {
+    const suffix = [params.skill, ...params.args].join(' ').trim();
+    if (params.tui === 'codex')
+        return `$${suffix}`;
+    if (params.tui === 'gemini')
+        return `/agent-infra:${suffix}`;
+    return `/${suffix}`;
+}
+export function buildTuiCommand(tui, prompt) {
+    if (tui === 'claude')
+        return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
+    if (tui === 'gemini')
+        return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+    if (tui === 'opencode')
+        return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
+    return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
+}
+//# sourceMappingURL=tui.js.map