@fitlab-ai/agent-infra 0.8.0 → 0.8.2

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

@@ -1,4 +1,5 @@
 import * as lark from '@larksuiteoapi/node-sdk';
+import { stripVTControlCharacters } from 'node:util';
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : {};
 }
@@ -40,6 +41,23 @@ 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 } }]
+        })
+    };
+}
 // Build the real SDK-backed transport from adapter config. appId/appSecret come
 // from server config (appSecret only via server.local.json / env). The WSClient
 // long connection delivers events; the Client REST call sends replies.
@@ -84,10 +102,10 @@ export function createFeishuTransport(config) {
                 // Ignore: the daemon is shutting down regardless.
             }
         },
-        async send(chatId, text) {
+        async send(chatId, message) {
             await client.im.message.create({
                 params: { receive_id_type: 'chat_id' },
-                data: { receive_id: chatId, msg_type: 'text', content: JSON.stringify({ text }) }
+                data: toFeishuCreateData(chatId, message)
             });
         }
     };

package/dist/lib/server/protocol.js

@@ -12,10 +12,26 @@ function taskSubcommand(subcommand) {
 export function commandHelp() {
     return [
         `agent-infra ${VERSION}`,
-        'Built-ins: /help, /ping, /version',
-        'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
-        'Write: /sandbox create|start',
-        'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+        'Built-ins:',
+        '/help',
+        '/ping',
+        '/version',
+        'Read:',
+        '/sandbox ls',
+        '/sandbox show {ref}',
+        '/sandbox vm status',
+        '/task decisions {ref}',
+        '/task log {ref}',
+        '/task ls',
+        '/task show {ref}',
+        '/task status {ref}',
+        'Write:',
+        '/sandbox create {ref}',
+        '/sandbox start {ref}',
+        'Exec:',
+        '/decide {task-ref} {HD-id} {decision}',
+        '/run create-task {description}',
+        '/run {skill} {task-ref}'
     ].join('\n');
 }
 export function parseCommand(text) {

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

@@ -12,7 +12,7 @@ completion time (or '(in progress)' while still running).
 Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
   a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
-  the verdict list, right after blockers/major/minor: manual-verify (env-blocked)
+  the verdict list, right after blockers/major/minor: manual-validation
   and human-decision (current ledger stage total).
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
@@ -33,10 +33,6 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 // note these differ from the `.airc.json` long names claude-code/gemini-cli).
 // Any other executor token (a human name, possibly CJK) is treated as human.
 const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode', 'cursor']);
-const ENV_BLOCKED_RE = /\(\+\s*(\d+)\s+env-blocked\)/i;
-// Same match plus any leading whitespace, so folding the count into the verdict
-// text drops the redundant `(+ n env-blocked)` fragment without leaving a gap.
-const ENV_BLOCKED_STRIP_RE = /\s*\(\+\s*\d+\s+env-blocked\)/i;
 const REVIEW_STAGE_PREFIXES = [
     { prefix: 'Review Analysis', stage: 'analysis' },
     { prefix: 'Review Plan', stage: 'plan' },
@@ -116,9 +112,31 @@ function isReviewStage(stage) {
 function reviewStageForStep(step) {
     return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
 }
+function splitArtifactSuffix(note) {
+    const arrow = note.indexOf(' → ');
+    return arrow === -1 ? { verdict: note, suffix: '' } : { verdict: note.slice(0, arrow), suffix: note.slice(arrow) };
+}
+function fieldNumber(field, label) {
+    const trimmed = field.trim();
+    const colon = trimmed.indexOf(':');
+    if (colon === -1)
+        return undefined;
+    if (trimmed.slice(0, colon).trim().toLowerCase() !== label)
+        return undefined;
+    const value = Number(trimmed.slice(colon + 1).trim());
+    return Number.isInteger(value) && value >= 0 ? value : undefined;
+}
 function humanValidationCount(note) {
-    const match = ENV_BLOCKED_RE.exec(note);
-    return match ? Number(match[1]) : 0;
+    const { verdict } = splitArtifactSuffix(note);
+    for (const field of verdict.split(',')) {
+        const value = fieldNumber(field, 'manual-validation');
+        if (value !== undefined)
+            return value;
+    }
+    return 0;
+}
+function isHumanCountField(field) {
+    return fieldNumber(field, 'manual-validation') !== undefined || fieldNumber(field, 'human-decision') !== undefined;
 }
 // A step is human-executed when its agent token is not a known AI token. Take
 // the first whitespace-delimited token and drop any trailing parenthetical
@@ -129,13 +147,17 @@ function isHumanAgent(agent) {
 }
 // Fold the two human counts into a review row's verdict NOTE: comma-joined, right
 // after the blockers/major/minor list and before the ` → artifact` link, mirroring
-// the review count line. The raw `(+ n env-blocked)` fragment is dropped so the
-// env-blocked number is not shown twice (it becomes the manual-verify count).
-function foldHumanCounts(note, decisions, envBlocked) {
-    const base = note.replace(ENV_BLOCKED_STRIP_RE, '');
-    const group = `Manual-verify: ${envBlocked}, Human-decision: ${decisions}`;
-    const arrow = base.indexOf(' → ');
-    return arrow === -1 ? `${base}, ${group}` : `${base.slice(0, arrow)}, ${group}${base.slice(arrow)}`;
+// the review count line. Review done notes already carry `Manual-validation` as a
+// source field, so build the final verdict field list once instead of cleaning a
+// previously rendered string.
+function foldHumanCounts(note, decisions, manualValidation) {
+    const { verdict, suffix } = splitArtifactSuffix(note);
+    const fields = verdict
+        .split(',')
+        .map((field) => field.trim())
+        .filter((field) => field !== '' && !isHumanCountField(field));
+    const group = `Manual-validation: ${manualValidation}, Human-decision: ${decisions}`;
+    return `${[...fields, group].join(', ')}${suffix}`;
 }
 function log(args = []) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {

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

@@ -1,23 +1,26 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { commandForEngine } from "../../sandbox/shell.js";
 import { resolveTaskRef } from "../resolve-ref.js";
 import { enumerateArtifacts } from "../artifacts.js";
 import { parseTaskFrontmatter, extractTitle } from "../frontmatter.js";
 import { loadShortIdByTaskId } from "../short-id.js";
+import { parseActivityLog, pairEntries } from "./log.js";
 const USAGE = `Usage: ai task status <N | #N | TASK-id>
 
-Prints an aggregated "health check" view for a task: header, metadata, an
-artifacts summary, git branch state, and best-effort GitHub issue/PR status.
+Prints an aggregated "health check" view for a task: header, metadata,
+artifacts, workflow/runtime execution state, and git branch state.
   <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
-Git and Platform rows are best-effort: a failed git/gh call degrades that row to
-'-' without failing the command.
+Git rows are best-effort: a failed git call degrades that row to '-' without
+failing the command.
 `;
 const DASH = '-';
 function makeRunner(cwd) {
     return (file, args) => execFileSync(file, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
 }
-// Run `run` and swallow any failure into null, so a single failing git/gh call
+// Run `run` and swallow any failure into null, so a single failing git call
 // degrades only its own field instead of aborting the whole view.
 function tryRun(run, file, args) {
     try {
@@ -37,9 +40,7 @@ const METADATA_KEYS = [
     'branch',
     'assigned_to',
     'created_at',
-    'updated_at',
-    'issue_number',
-    'pr_status'
+    'updated_at'
 ];
 function collectMetadata(fm) {
     return METADATA_KEYS.map((key) => [key, fm[key] ? fm[key] : DASH]);
@@ -136,39 +137,123 @@ function collectGit(frontmatterBranch, run) {
     }
     return { current, frontmatter, match, exists, uncommitted, aheadBehind };
 }
-function collectPlatform(fm, run) {
-    let issue = DASH;
-    if (fm.issue_number && /^\d+$/.test(fm.issue_number)) {
-        const out = tryRun(run, 'gh', ['issue', 'view', fm.issue_number, '--json', 'state,labels']);
-        if (out !== null) {
-            try {
-                const data = JSON.parse(out);
-                const labels = Array.isArray(data.labels)
-                    ? data.labels.map((label) => label.name).join(', ')
-                    : '';
-                issue = labels ? `${data.state} [${labels}]` : `${data.state}`;
-            }
-            catch {
-                issue = DASH;
+const STALE_MS = 60 * 60 * 1000;
+function parseActivityTime(value) {
+    const epoch = Date.parse(value.replace(' ', 'T'));
+    return Number.isFinite(epoch) ? epoch : Number.NaN;
+}
+function collectWorkflow(content, now = new Date()) {
+    const parsed = parseActivityLog(content);
+    if (!parsed.sectionFound || parsed.entries.length === 0) {
+        return { state: 'unknown', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH };
+    }
+    const rows = pairEntries(parsed.entries);
+    const latest = rows.at(-1);
+    if (!latest) {
+        return { state: 'unknown', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH };
+    }
+    const inProgress = latest.started !== '' && latest.done === '';
+    const state = inProgress ? 'in-progress' : latest.done ? 'idle' : 'unknown';
+    let stale = DASH;
+    if (inProgress) {
+        const started = parseActivityTime(latest.started);
+        stale = Number.isFinite(started) ? (now.getTime() - started > STALE_MS ? 'yes' : 'no') : 'unknown';
+    }
+    return {
+        state,
+        step: latest.step || DASH,
+        agent: latest.agent || DASH,
+        startedAt: latest.started || DASH,
+        doneAt: latest.done || DASH,
+        stale
+    };
+}
+function latestRunRecord(taskDir) {
+    const runsDir = path.join(taskDir, 'runs');
+    if (!fs.existsSync(runsDir))
+        return null;
+    const candidates = [];
+    for (const entry of fs.readdirSync(runsDir)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const filePath = path.join(runsDir, entry);
+        const stat = fs.statSync(filePath);
+        if (stat.isFile())
+            candidates.push({ path: filePath, mtimeMs: stat.mtimeMs });
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const candidate of candidates) {
+        try {
+            const data = JSON.parse(fs.readFileSync(candidate.path, 'utf8'));
+            if (typeof data?.run_id === 'string' &&
+                typeof data?.engine === 'string' &&
+                typeof data?.container === 'string' &&
+                typeof data?.run_dir === 'string') {
+                return {
+                    run_id: data.run_id,
+                    engine: data.engine,
+                    container: data.container,
+                    run_dir: data.run_dir,
+                    status_file: typeof data.status_file === 'string' ? data.status_file : `${data.run_dir}/status`,
+                    log_file: typeof data.log_file === 'string' ? data.log_file : `${data.run_dir}/output.log`
+                };
             }
         }
+        catch {
+            // Ignore malformed local records and try the next newest file.
+        }
     }
-    let pr = DASH;
-    if (fm.pr_status === 'created' && fm.pr_number && /^\d+$/.test(fm.pr_number)) {
-        const out = tryRun(run, 'gh', ['pr', 'view', fm.pr_number, '--json', 'state,statusCheckRollup']);
-        if (out !== null) {
-            try {
-                const data = JSON.parse(out);
-                const rollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : [];
-                const passed = rollup.filter((check) => check.conclusion === 'SUCCESS' || check.state === 'SUCCESS').length;
-                pr = rollup.length > 0 ? `${data.state}, checks: ${passed}/${rollup.length}` : `${data.state}`;
-            }
-            catch {
-                pr = DASH;
+    return null;
+}
+function readRuntimeFile(record, filePath, run) {
+    const command = commandForEngine(record.engine, 'docker', ['exec', record.container, 'cat', filePath]);
+    const output = tryRun(run, command.cmd, command.args);
+    return output === null ? null : output.trim();
+}
+function runtimeValue(record, name, run) {
+    const output = readRuntimeFile(record, `${record.run_dir}/${name}`, run);
+    return output ? output : DASH;
+}
+function collectRuntime(taskDir, workflow, run) {
+    const record = latestRunRecord(taskDir);
+    if (!record) {
+        return workflow.state === 'in-progress'
+            ? {
+                mode: 'unmanaged',
+                status: 'inferred-from-workflow',
+                run: DASH,
+                tmux: DASH,
+                startedAt: DASH,
+                finishedAt: DASH,
+                exitCode: DASH,
+                log: DASH
             }
-        }
+            : {
+                mode: 'none',
+                status: DASH,
+                run: DASH,
+                tmux: DASH,
+                startedAt: DASH,
+                finishedAt: DASH,
+                exitCode: DASH,
+                log: DASH
+            };
     }
-    return { issue, pr };
+    const status = readRuntimeFile(record, record.status_file, run)?.trim() || 'unknown';
+    const session = runtimeValue(record, 'session', run);
+    const window = runtimeValue(record, 'window', run);
+    const pane = runtimeValue(record, 'pane', run);
+    const tmux = session !== DASH && window !== DASH && pane !== DASH ? `${session}:${window}:${pane}` : DASH;
+    return {
+        mode: 'managed-tmux',
+        status,
+        run: record.run_id,
+        tmux,
+        startedAt: runtimeValue(record, 'started_at', run),
+        finishedAt: runtimeValue(record, 'finished_at', run),
+        exitCode: runtimeValue(record, 'exit_code', run),
+        log: record.log_file
+    };
 }
 // Indent each label/value pair by two spaces and pad labels to a common width so
 // every section reads as an aligned "key   value" block.
@@ -189,6 +274,24 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
+    lines.push('', 'Workflow', ...renderPairs([
+        ['state', model.workflow.state],
+        ['step', model.workflow.step],
+        ['agent', model.workflow.agent],
+        ['started_at', model.workflow.startedAt],
+        ['done_at', model.workflow.doneAt],
+        ['stale', model.workflow.stale]
+    ]));
+    lines.push('', 'Runtime', ...renderPairs([
+        ['mode', model.runtime.mode],
+        ['status', model.runtime.status],
+        ['run', model.runtime.run],
+        ['tmux', model.runtime.tmux],
+        ['started_at', model.runtime.startedAt],
+        ['finished_at', model.runtime.finishedAt],
+        ['exit_code', model.runtime.exitCode],
+        ['log', model.runtime.log]
+    ]));
     lines.push('', 'Git', ...renderPairs([
         ['current', model.git.current],
         ['frontmatter', model.git.frontmatter],
@@ -197,11 +300,6 @@ function renderStatus(model) {
         ['uncommitted', model.git.uncommitted],
         ['ahead/behind', model.git.aheadBehind]
     ]));
-    const issueLabel = model.issueNumber ? `issue #${model.issueNumber}` : 'issue';
-    lines.push('', 'Platform', ...renderPairs([
-        [issueLabel, model.platform.issue],
-        ['pr', model.platform.pr]
-    ]));
     return lines;
 }
 function status(args = []) {
@@ -221,19 +319,20 @@ function status(args = []) {
     const fm = parseTaskFrontmatter(content);
     const run = makeRunner(resolved.repoRoot);
     const artifacts = enumerateArtifacts(resolved.taskDir);
+    const workflow = collectWorkflow(content);
     const model = {
         taskId: resolved.taskId,
         shortId: loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId) ?? DASH,
         title: extractTitle(content),
-        issueNumber: fm.issue_number && /^\d+$/.test(fm.issue_number) ? fm.issue_number : '',
         metadata: collectMetadata(fm),
         artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
-        git: collectGit(fm.branch ?? '', run),
-        platform: collectPlatform(fm, run)
+        workflow,
+        runtime: collectRuntime(resolved.taskDir, workflow, run),
+        git: collectGit(fm.branch ?? '', run)
     };
     for (const line of renderStatus(model)) {
         process.stdout.write(`${line}\n`);
     }
 }
-export { status, makeRunner, collectMetadata, groupArtifacts, collectGit, collectPlatform, renderStatus, METADATA_KEYS };
+export { status, makeRunner, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, METADATA_KEYS };
 //# sourceMappingURL=status.js.map

package/dist/lib/update.js

@@ -7,6 +7,9 @@ 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');
+const AGENT_INFRA_SANDBOX_TOOL = 'agent-infra';
+const LEGACY_DEFAULT_SANDBOX_TOOLS = ['claude-code', 'codex', 'gemini-cli', 'opencode'];
+const DEFAULT_SANDBOX_TOOLS = [AGENT_INFRA_SANDBOX_TOOL, ...LEGACY_DEFAULT_SANDBOX_TOOLS];
 // One-time migration of the legacy project-level PR switch to the three-state
 // `prFlow` preference. `true` (the old default / "PR flow on") maps to the
 // strong constraint `required`; `false` maps to `disabled`. A missing or
@@ -25,6 +28,24 @@ function migratePrFlow(config) {
     }
     return null;
 }
+function isLegacyDefaultSandboxTools(value) {
+    if (!Array.isArray(value) || value.length !== LEGACY_DEFAULT_SANDBOX_TOOLS.length) {
+        return false;
+    }
+    const tools = new Set(value);
+    return LEGACY_DEFAULT_SANDBOX_TOOLS.every((tool) => tools.has(tool));
+}
+function migrateSandboxTools(config) {
+    const tools = config.sandbox?.tools;
+    if (!isLegacyDefaultSandboxTools(tools)) {
+        return false;
+    }
+    config.sandbox = {
+        ...config.sandbox,
+        tools: [...DEFAULT_SANDBOX_TOOLS]
+    };
+    return true;
+}
 function isPathOwnedByOtherPlatform(relativePath, platformType) {
     const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
     if (!top.startsWith('.'))
@@ -153,6 +174,7 @@ async function cmdUpdate() {
     const taskAdded = !config.task;
     const labelsAdded = !config.labels;
     const prFlowMigrated = migratePrFlow(config);
+    const sandboxToolsMigrated = !sandboxAdded && migrateSandboxTools(config);
     let configChanged = changed;
     if (platformAdded) {
         config.platform = structuredClone(defaults.platform);
@@ -173,6 +195,9 @@ async function cmdUpdate() {
     if (prFlowMigrated) {
         configChanged = true;
     }
+    if (sandboxToolsMigrated) {
+        configChanged = true;
+    }
     if (configChanged) {
         console.log('');
         if (hasNewEntries) {
@@ -200,6 +225,9 @@ async function cmdUpdate() {
             if (prFlowMigrated) {
                 info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
             }
+            if (sandboxToolsMigrated) {
+                info(`Migrated default sandbox.tools to include ${AGENT_INFRA_SANDBOX_TOOL} in ${CONFIG_PATH}.`);
+            }
         }
         else {
             info(`File registry changed in ${CONFIG_PATH}.`);
@@ -219,6 +247,9 @@ async function cmdUpdate() {
         if (hasNewEntries && prFlowMigrated) {
             info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
         }
+        if (hasNewEntries && sandboxToolsMigrated) {
+            info(`Migrated default sandbox.tools to include ${AGENT_INFRA_SANDBOX_TOOL} in ${CONFIG_PATH}.`);
+        }
         fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
         ok(`Updated ${CONFIG_PATH}`);
     }

package/lib/defaults.json

@@ -8,6 +8,7 @@
       "node22"
     ],
     "tools": [
+      "agent-infra",
       "claude-code",
       "codex",
       "gemini-cli",

package/lib/run/index.ts

@@ -1,6 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { loadServerConfig } from '../server/config.ts';
 import { resolveTaskBranch } from '../sandbox/task-resolver.ts';
-import { runInSandbox } from '../sandbox/capture.ts';
+import { createRunId, runInSandbox, type SandboxRunMetadata } from '../sandbox/capture.ts';
+import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
 import { getSkillRunSpec } from './skills.ts';
 import { runHostCommand, type RunProcessResult } from './host.ts';
@@ -16,19 +19,27 @@ export type SandboxRunRequest = {
   taskRef: string;
   branch: string;
   command: string[];
+  runId?: string;
+};
+
+export type SandboxRunResult = RunProcessResult & {
+  run?: SandboxRunMetadata;
 };
 
 export type RunSkillOptions = {
   command?: Record<string, unknown>;
   repoRoot?: string;
   runHost?: (command: string[]) => Promise<RunProcessResult>;
-  runSandbox?: (request: SandboxRunRequest) => Promise<RunProcessResult>;
+  runSandbox?: (request: SandboxRunRequest) => Promise<SandboxRunResult>;
   writeStdout?: (chunk: string) => void;
   writeStderr?: (chunk: string) => void;
 };
 
 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`;
@@ -78,6 +89,99 @@ function assertAllowedByConfig(skill: string, commandConfig: Record<string, unkn
   }
 }
 
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+
+function readShortIdLength(repoRoot: string): number {
+  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: string): Record<string, string> {
+  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 {};
+  }
+}
+
+type ActiveTaskIdentity = {
+  taskId: string;
+  taskDir: string;
+  taskRef: string;
+};
+
+function resolveActiveTaskIdentity(taskRef: string, repoRoot: string): ActiveTaskIdentity | null {
+  let taskId: string | null = 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: Date = new Date()): string {
+  const pad = (n: number): string => 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: {
+  identity: ActiveTaskIdentity;
+  run: SandboxRunMetadata;
+  branch: string;
+  command: string[];
+}): void {
+  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: string[], options: RunSkillOptions = {}): Promise<number> {
   const parsed = parseRunArgs(args);
   const config = options.command ? null : loadServerConfig({ rootDir: options.repoRoot });
@@ -96,13 +200,22 @@ export async function runSkill(args: string[], options: RunSkillOptions = {}): P
 
   const repoRoot = options.repoRoot ?? config?.repoRoot ?? process.cwd();
   const branch = resolveTaskBranch(parsed.taskRef, repoRoot);
-  const runSandbox = options.runSandbox ?? ((request: SandboxRunRequest) => runInSandbox(request));
-  const result = await runSandbox({ taskRef: parsed.taskRef, branch, command });
+  const identity = resolveActiveTaskIdentity(parsed.taskRef, repoRoot);
+  const runId = identity ? createRunId() : undefined;
+  const writeStdout = options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk));
+  const writeStderr = options.writeStderr ?? ((chunk: string) => process.stderr.write(chunk));
+  const runSandbox =
+    options.runSandbox ??
+    ((request: SandboxRunRequest) => runInSandbox(request));
+  const result = await runSandbox({ taskRef: parsed.taskRef, branch, command, runId });
   if (result.stdout) {
-    (options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk)))(result.stdout);
+    writeStdout(result.stdout);
   }
   if (result.stderr) {
-    (options.writeStderr ?? ((chunk: string) => process.stderr.write(chunk)))(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);
 }