@fitlab-ai/agent-infra 0.7.7 → 0.8.1

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/task/index.js

@@ -2,6 +2,7 @@ const USAGE = `Usage: ai task <command> [options]
 
 Commands:
   cat <ref> <artifact | N>               Print a task artifact (by name or number)
+  decisions, d <ref> [selector]          List human-decision (HD-) items, or show one's detail
   files <ref>                            List artifacts in a task dir (numbered)
   grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
   issue-body <ref> [--template <path>]   Print a deterministic Issue body from task.md (描述 + 需求, or an Issue Form)
@@ -13,6 +14,8 @@ Commands:
 Examples:
   ai task cat 11 analysis
   ai task cat 11 3
+  ai task decisions 11
+  ai task d 11 HD-3 --format markdown
   ai task files 11
   ai task grep resolveArtifact
   ai task grep resolveArtifact 11
@@ -42,6 +45,12 @@ export async function runTask(args) {
             cat(rest);
             break;
         }
+        case 'decisions':
+        case 'd': {
+            const { decisions } = await import("./commands/decisions.js");
+            decisions(rest);
+            break;
+        }
         case 'files': {
             const { files } = await import("./commands/files.js");
             files(rest);

package/dist/lib/task/ledger.js

@@ -0,0 +1,66 @@
+// Shared parser for the task.md `## 审查分歧账本` (Review Disagreement Ledger).
+// Single source of truth for ledger row parsing across `ai task` commands
+// (log, decisions) — see the plan's D1 constraint "no third parser". The gate
+// parser in `.agents/scripts/validate-artifact.js` is a separate concern and
+// must be kept semantically in sync by hand (noted in review-handshake.md).
+// The ledger H2 heading is language-dependent (zh template / en template).
+const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
+const NEXT_H2_RE = /^##\s/;
+// Terminal statuses the completion gates treat as resolved.
+const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
+// Statuses that represent an executor-raised human-decision row (pending or done).
+const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
+// Parse all rows of the disagreement ledger table. Skips the heading, the
+// header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
+// Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
+function parseLedger(content) {
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]))
+        i += 1;
+    if (i >= lines.length)
+        return [];
+    const rows = [];
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (NEXT_H2_RE.test(lines[j]))
+            break;
+        const line = lines[j].trim();
+        if (!line.startsWith('|'))
+            continue;
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+        if (cells.length < 6)
+            continue;
+        if (cells[0] === 'id' || /^-+$/.test(cells[0] ?? ''))
+            continue;
+        rows.push({
+            id: cells[0],
+            stage: cells[1],
+            round: cells[2],
+            severity: cells[3],
+            status: cells[4],
+            evidence: cells[5]
+        });
+    }
+    return rows;
+}
+// Allocate the next globally-unique human-decision id. Scans every `HD-<n>`
+// already present in the ledger (across all stages) and returns `HD-{max+1}`,
+// or `HD-1` when none exist. Global monotonic allocation prevents id collisions
+// across the analysis / plan / code stages (plan PL-2).
+function nextHdId(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const m = /^HD-(\d+)$/.exec(row.id);
+        if (!m)
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        if (n > max)
+            max = n;
+    }
+    return `HD-${max + 1}`;
+}
+export { parseLedger, nextHdId, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+//# sourceMappingURL=ledger.js.map

package/dist/lib/task/sections.js

@@ -40,5 +40,34 @@ function findSectionHeading(content, aliases) {
     }
     return aliases[0];
 }
-export { extractSection, findSectionHeading };
+/**
+ * Return the body of the first `### {headingPrefix}` sub-section, from the
+ * heading line (inclusive) to the next `### ` / `## ` heading or EOF. Used to
+ * pull a single `### HD-N` human-decision detail block out of an artifact. The
+ * prefix must be followed by a word boundary so `HD-1` does not match `HD-10`
+ * (e.g. `### HD-1`, `### HD-1：标题`, `### HD-1 [needs-human-decision]`). Leading
+ * and trailing blank lines are trimmed. Returns '' when no match is present.
+ */
+function extractSubSection(content, headingPrefix) {
+    const lines = content.split('\n');
+    const headRe = new RegExp(`^###\\s+${escapeRegExp(headingPrefix)}(?![\\w-])`);
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (headRe.test(lines[i].trim())) {
+            start = i;
+            break;
+        }
+    }
+    if (start === -1)
+        return '';
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+        if (/^###?\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+export { extractSection, findSectionHeading, extractSubSection };
 //# sourceMappingURL=sections.js.map

package/lib/decide.ts

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { VERSION } from './version.ts';
+import { resolveTaskRef } from './task/resolve-ref.ts';
+
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+
+type DecideOptions = {
+  repoRoot?: string;
+  now?: () => string;
+  version?: string;
+};
+
+function detectRepoRoot(): string {
+  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe']
+  }).trim();
+}
+
+function defaultNow(): string {
+  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: string, ref: string): string {
+  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: string, field: string, value: string): string {
+  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: string, hdId: string): { content: string; found: boolean; pending: boolean } {
+  const lines = content.split('\n');
+  let found = false;
+  let pending = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] as string;
+    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: string, heading: string, block: string): string {
+  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: string[], options: DecideOptions = {}): Promise<number> {
+  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: string[]): Promise<void> {
+  process.exitCode = await decide(args);
+}

package/lib/run/host.ts

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type RunProcessResult = {
+  exitCode: number | null;
+  signal?: NodeJS.Signals | null;
+  stdout?: string;
+  stderr?: string;
+};
+
+function resolveCommand(file: string): string {
+  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: string): boolean {
+  return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+
+export async function runHostCommand(command: string[]): Promise<RunProcessResult> {
+  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 }));
+  });
+}