@fitlab-ai/agent-infra 0.7.2 → 0.7.4

package/lib/task/commands/status.ts

@@ -0,0 +1,302 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { enumerateArtifacts, type Artifact } from '../artifacts.ts';
+import { parseTaskFrontmatter, extractTitle, type Frontmatter } from '../frontmatter.ts';
+import { loadShortIdByTaskId } from '../short-id.ts';
+
+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.
+  <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.
+`;
+
+const DASH = '-';
+
+// Subprocess boundary: the single place this command shells out. Injectable so
+// the collectors below can be unit-tested without spawning git/gh. Returns the
+// command's stdout; throws (like execFileSync) on a non-zero exit or spawn error.
+type Runner = (file: string, args: string[]) => string;
+
+function makeRunner(cwd: string): Runner {
+  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
+// degrades only its own field instead of aborting the whole view.
+function tryRun(run: Runner, file: string, args: string[]): string | null {
+  try {
+    return run(file, args);
+  } catch {
+    return null;
+  }
+}
+
+// Frontmatter keys shown in the Metadata section, in a fixed display order.
+const METADATA_KEYS = [
+  'type',
+  'status',
+  'current_step',
+  'priority',
+  'effort',
+  'branch',
+  'assigned_to',
+  'created_at',
+  'updated_at',
+  'issue_number',
+  'pr_status'
+] as const;
+
+function collectMetadata(fm: Frontmatter): [string, string][] {
+  return METADATA_KEYS.map((key) => [key, fm[key] ? fm[key]! : DASH]);
+}
+
+// Workflow stages in timeline order; artifacts are bucketed by filename prefix.
+// `review-*` prefixes are matched before their bare counterparts so that, e.g.,
+// `review-analysis.md` is never swallowed by the `analysis` bucket.
+const STAGE_ORDER = [
+  'analysis',
+  'review-analysis',
+  'plan',
+  'review-plan',
+  'code',
+  'review-code',
+  'task',
+  'other'
+] as const;
+
+function stageOf(name: string): string {
+  const stem = name.replace(/\.md$/, '');
+  if (stem === 'task') return 'task';
+  if (stem.startsWith('review-analysis')) return 'review-analysis';
+  if (stem.startsWith('review-plan')) return 'review-plan';
+  if (stem.startsWith('review-code')) return 'review-code';
+  if (stem.startsWith('analysis')) return 'analysis';
+  if (stem.startsWith('plan')) return 'plan';
+  if (stem.startsWith('code')) return 'code';
+  return 'other';
+}
+
+// Group artifacts by workflow stage, preserving the input order (mtime ascending
+// from enumerateArtifacts) within each stage and dropping empty stages.
+function groupArtifacts(artifacts: Artifact[]): { stage: string; files: string[] }[] {
+  const byStage = new Map<string, string[]>();
+  for (const artifact of artifacts) {
+    const stage = stageOf(artifact.name);
+    const bucket = byStage.get(stage);
+    if (bucket) bucket.push(artifact.name);
+    else byStage.set(stage, [artifact.name]);
+  }
+  const groups: { stage: string; files: string[] }[] = [];
+  for (const stage of STAGE_ORDER) {
+    const files = byStage.get(stage);
+    if (files && files.length > 0) groups.push({ stage, files });
+  }
+  return groups;
+}
+
+type GitInfo = {
+  current: string;
+  frontmatter: string;
+  match: string;
+  exists: string;
+  uncommitted: string;
+  aheadBehind: string;
+};
+
+// `frontmatterBranch` is the task.md `branch` field (caller passes '' when absent).
+// It is read straight from frontmatter and never depends on a subprocess, so it
+// keeps its value even when every git call fails. All other fields degrade to '-'
+// on failure of their own command.
+function collectGit(frontmatterBranch: string, run: Runner): GitInfo {
+  const frontmatter = frontmatterBranch ? frontmatterBranch : DASH;
+
+  let current = DASH;
+  const cur = tryRun(run, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (cur !== null && cur.trim()) current = cur.trim();
+
+  let match = DASH;
+  if (current !== DASH && frontmatter !== DASH) {
+    match = current === frontmatter ? 'yes' : 'no';
+  }
+
+  let exists = DASH;
+  if (frontmatter !== DASH) {
+    const verified = tryRun(run, 'git', ['rev-parse', '--verify', '--quiet', `refs/heads/${frontmatter}`]);
+    exists = verified === null ? 'no' : 'yes';
+  }
+
+  let uncommitted = DASH;
+  const porcelain = tryRun(run, 'git', ['status', '--porcelain']);
+  if (porcelain !== null) {
+    const changed = porcelain.split('\n').filter((line) => line.trim() !== '');
+    uncommitted = changed.length === 0 ? 'clean' : `${changed.length} file(s)`;
+  }
+
+  let aheadBehind = DASH;
+  if (frontmatter !== DASH) {
+    const counts = tryRun(run, 'git', [
+      'rev-list',
+      '--left-right',
+      '--count',
+      `${frontmatter}...${frontmatter}@{upstream}`
+    ]);
+    if (counts !== null) {
+      const parts = counts.trim().split(/\s+/);
+      if (parts.length === 2) aheadBehind = `${parts[0]} ahead / ${parts[1]} behind`;
+    }
+  }
+
+  return { current, frontmatter, match, exists, uncommitted, aheadBehind };
+}
+
+type PlatformInfo = { issue: string; pr: string };
+
+function collectPlatform(fm: Frontmatter, run: Runner): PlatformInfo {
+  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: { name: string }) => label.name).join(', ')
+          : '';
+        issue = labels ? `${data.state} [${labels}]` : `${data.state}`;
+      } catch {
+        issue = DASH;
+      }
+    }
+  }
+
+  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: { conclusion?: string; state?: string }) =>
+            check.conclusion === 'SUCCESS' || check.state === 'SUCCESS'
+        ).length;
+        pr = rollup.length > 0 ? `${data.state}, checks: ${passed}/${rollup.length}` : `${data.state}`;
+      } catch {
+        pr = DASH;
+      }
+    }
+  }
+
+  return { issue, pr };
+}
+
+type StatusModel = {
+  taskId: string;
+  shortId: string;
+  title: string;
+  issueNumber: string;
+  metadata: [string, string][];
+  artifacts: { count: number; groups: { stage: string; files: string[] }[] };
+  git: GitInfo;
+  platform: PlatformInfo;
+};
+
+// 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.
+function renderPairs(rows: [string, string][]): string[] {
+  const width = rows.reduce((max, [label]) => Math.max(max, label.length), 0);
+  return rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value}`.trimEnd());
+}
+
+function renderStatus(model: StatusModel): string[] {
+  const lines: string[] = [];
+
+  lines.push(`Task ${model.taskId}  (${model.shortId})`);
+  if (model.title) lines.push(model.title);
+
+  lines.push('', 'Metadata', ...renderPairs(model.metadata));
+
+  lines.push('', `Artifacts (${model.artifacts.count})`);
+  if (model.artifacts.groups.length === 0) {
+    lines.push('  (none)');
+  } else {
+    lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
+  }
+
+  lines.push(
+    '',
+    'Git',
+    ...renderPairs([
+      ['current', model.git.current],
+      ['frontmatter', model.git.frontmatter],
+      ['match', model.git.match],
+      ['exists', model.git.exists],
+      ['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: string[] = []): void {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    if (args.length === 0) process.exitCode = 1;
+    return;
+  }
+
+  const resolved = resolveTaskRef(args[0]!);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task status: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const fm = parseTaskFrontmatter(content);
+  const run = makeRunner(resolved.repoRoot);
+  const artifacts = enumerateArtifacts(resolved.taskDir);
+
+  const model: StatusModel = {
+    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)
+  };
+
+  for (const line of renderStatus(model)) {
+    process.stdout.write(`${line}\n`);
+  }
+}
+
+export {
+  status,
+  makeRunner,
+  collectMetadata,
+  groupArtifacts,
+  collectGit,
+  collectPlatform,
+  renderStatus,
+  METADATA_KEYS
+};
+export type { Runner, GitInfo, PlatformInfo, StatusModel };

package/lib/task/index.ts

@@ -1,13 +1,25 @@
 const USAGE = `Usage: ai task <command> [options]
 
 Commands:
+  cat <ref> <artifact | N>               Print a task artifact (by name or number)
+  files <ref>                            List artifacts in a task dir (numbered)
+  grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
+  log <ref>                              Render a task's activity log as a timeline
   ls [--all | --blocked | --completed]   List tasks (default: active)
   show <N | #N | TASK-id>                Print a task.md
+  status <ref>                           Aggregated status view (metadata / artifacts / git / platform)
 
 Examples:
+  ai task cat 11 analysis
+  ai task cat 11 3
+  ai task files 11
+  ai task grep resolveArtifact
+  ai task grep resolveArtifact 11
+  ai task log 11
   ai task ls
   ai task show 11
   ai task show TASK-20260612-162737
+  ai task status 11
 
 Run 'ai task <command> --help' for details.`;
 
@@ -36,6 +48,31 @@ export async function runTask(args: string[]): Promise<void> {
       show(rest);
       break;
     }
+    case 'files': {
+      const { files } = await import('./commands/files.ts');
+      files(rest);
+      break;
+    }
+    case 'cat': {
+      const { cat } = await import('./commands/cat.ts');
+      cat(rest);
+      break;
+    }
+    case 'grep': {
+      const { grep } = await import('./commands/grep.ts');
+      grep(rest);
+      break;
+    }
+    case 'log': {
+      const { log } = await import('./commands/log.ts');
+      log(rest);
+      break;
+    }
+    case 'status': {
+      const { status } = await import('./commands/status.ts');
+      status(rest);
+      break;
+    }
     default:
       process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
       process.stdout.write(`${USAGE}\n`);

package/lib/task/resolve-ref.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { normalizeShortIdInput } from './short-id.ts';
+
+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'] as const;
+
+type ResolveRefResult =
+  | {
+      ok: true;
+      repoRoot: string;
+      taskId: string;
+      taskDir: string;
+      taskMdPath: string;
+    }
+  | { ok: false; message: string };
+
+function detectRepoRoot(): string {
+  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: string): number {
+  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: string, repoRoot: string): string {
+  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: string, width: number): string[] {
+  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: string, taskId: string): string | null {
+  // 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: string, taskId: string): string | null {
+  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);
+}
+
+/**
+ * Enumerate every task directory under the flat workspace states
+ * (active / blocked / completed) — archive is intentionally excluded so a
+ * full-tree scan never pulls in cold data. Ordered by state, then task id
+ * ascending, giving callers a deterministic traversal.
+ */
+function enumerateTaskDirs(repoRoot: string): { taskId: string; taskDir: string }[] {
+  const out: { taskId: string; taskDir: string }[] = [];
+  for (const sub of FLAT_WORKSPACE_DIRS) {
+    const base = path.join(repoRoot, '.agents', 'workspace', sub);
+    if (!fs.existsSync(base)) continue;
+    for (const entry of fs.readdirSync(base).sort()) {
+      if (!TASK_ID_RE.test(entry)) continue;
+      const taskDir = path.join(base, entry);
+      if (!fs.existsSync(path.join(taskDir, 'task.md'))) continue;
+      out.push({ taskId: entry, taskDir });
+    }
+  }
+  return out;
+}
+
+/**
+ * Resolve a task ref (bare short id, `#N`, or `TASK-YYYYMMDD-HHMMSS`) to its
+ * task directory across active / blocked / completed / archive.
+ *
+ * The returned `message` on failure is command-agnostic (no `ai task <cmd>:`
+ * prefix); callers prepend their own prefix so each command keeps its existing
+ * stderr wording byte-for-byte.
+ */
+function resolveTaskRef(arg: string): ResolveRefResult {
+  const repoRoot = detectRepoRoot();
+  let taskId: string;
+  if (TASK_ID_RE.test(arg)) {
+    taskId = arg;
+  } else {
+    const shortIdLength = readShortIdLength(repoRoot);
+    const normalized = normalizeShortIdInput(arg, { shortIdLength });
+    if (normalized.kind === 'error') {
+      return { ok: false, message: normalized.message };
+    }
+    if (normalized.kind === 'pass') {
+      return {
+        ok: false,
+        message:
+          `'${arg}' is not a valid short id or TASK-id; ` +
+          `expected bare digits, '#N', or 'TASK-YYYYMMDD-HHMMSS'`
+      };
+    }
+    try {
+      taskId = resolveShortIdToTaskId(normalized.value, repoRoot);
+    } catch (e) {
+      return { ok: false, message: (e as Error).message };
+    }
+  }
+  const taskMdPath = findTaskMd(repoRoot, taskId);
+  if (!taskMdPath) {
+    return {
+      ok: false,
+      message: `task ${taskId} not found in active / blocked / completed / archive`
+    };
+  }
+  return { ok: true, repoRoot, taskId, taskDir: path.dirname(taskMdPath), taskMdPath };
+}
+
+export { resolveTaskRef, detectRepoRoot, enumerateTaskDirs, TASK_ID_RE };
+export type { ResolveRefResult };

package/lib/task/short-id.ts

@@ -70,6 +70,16 @@ function loadShortIdByTaskId(repoRoot: string): Map<string, string> {
   return map;
 }
 
+/**
+ * Resolve a branch to its active-task short id (`#NN`), or `null` when no
+ * active task is bound to that branch.
+ *
+ * Two-state semantics: this only consults the active registry
+ * (`active/.short-ids.json`) plus each `active/{taskId}/task.md`. Tasks moved
+ * to completed/blocked/cancelled/archive have already released their short id,
+ * so their branches return `null` — in `ai sandbox ls` that surfaces as `-`,
+ * meaning the sandbox is free to remove.
+ */
 function lookupShortIdByBranch(
   branch: string,
   repoRoot: string,

package/lib/update.ts

@@ -17,7 +17,8 @@ type UpdateConfig = {
   org: string;
   language: string;
   platform?: { type?: string };
-  requiresPullRequest?: boolean;
+  requiresPullRequest?: boolean;       // legacy field; read-only, migrated to prFlow then removed
+  prFlow?: 'required' | 'disabled';
   sandbox?: Record<string, unknown>;
   task?: { shortIdLength: number };
   labels?: Record<string, unknown>;
@@ -27,7 +28,6 @@ type UpdateConfig = {
 
 type Defaults = {
   platform: { type: string };
-  requiresPullRequest: boolean;
   sandbox: Record<string, unknown>;
   task: { shortIdLength: number };
   labels: Record<string, unknown>;
@@ -41,6 +41,25 @@ const defaults = JSON.parse(
 const CONFIG_DIR = '.agents';
 const CONFIG_PATH = path.join(CONFIG_DIR, '.airc.json');
 
+// 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
+// already-migrated config is left untouched (idempotent). Returns the new
+// prFlow value when a migration happened, otherwise null.
+function migratePrFlow(config: UpdateConfig): 'required' | 'disabled' | null {
+  if (config.requiresPullRequest === true) {
+    delete config.requiresPullRequest;
+    config.prFlow = 'required';
+    return 'required';
+  }
+  if (config.requiresPullRequest === false) {
+    delete config.requiresPullRequest;
+    config.prFlow = 'disabled';
+    return 'disabled';
+  }
+  return null;
+}
+
 function isPathOwnedByOtherPlatform(relativePath: string, platformType: string): boolean {
   const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
   if (!top.startsWith('.')) return false;
@@ -195,7 +214,7 @@ async function cmdUpdate(): Promise<void> {
   const sandboxAdded = !config.sandbox;
   const taskAdded = !config.task;
   const labelsAdded = !config.labels;
-  const requiresPullRequestAdded = config.requiresPullRequest === undefined;
+  const prFlowMigrated = migratePrFlow(config);
   let configChanged = changed;
 
   if (platformAdded) {
@@ -218,8 +237,7 @@ async function cmdUpdate(): Promise<void> {
     configChanged = true;
   }
 
-  if (requiresPullRequestAdded) {
-    config.requiresPullRequest = defaults.requiresPullRequest;
+  if (prFlowMigrated) {
     configChanged = true;
   }
 
@@ -233,7 +251,7 @@ async function cmdUpdate(): Promise<void> {
       for (const entry of added.merged) {
         ok(`  merged: ${entry}`);
       }
-    } else if (platformAdded || sandboxAdded || taskAdded || labelsAdded || requiresPullRequestAdded) {
+    } else if (platformAdded || sandboxAdded || taskAdded || labelsAdded || prFlowMigrated) {
       if (platformAdded) {
         info(`Default platform config added to ${CONFIG_PATH}.`);
       }
@@ -246,8 +264,8 @@ async function cmdUpdate(): Promise<void> {
       if (labelsAdded) {
         info(`Default labels.in config added to ${CONFIG_PATH}.`);
       }
-      if (requiresPullRequestAdded) {
-        info(`Default requiresPullRequest=${defaults.requiresPullRequest} added to ${CONFIG_PATH}.`);
+      if (prFlowMigrated) {
+        info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
       }
     } else {
       info(`File registry changed in ${CONFIG_PATH}.`);
@@ -264,8 +282,8 @@ async function cmdUpdate(): Promise<void> {
     if (hasNewEntries && platformAdded) {
       info(`Default platform config added to ${CONFIG_PATH}.`);
     }
-    if (hasNewEntries && requiresPullRequestAdded) {
-      info(`Default requiresPullRequest=${defaults.requiresPullRequest} added to ${CONFIG_PATH}.`);
+    if (hasNewEntries && prFlowMigrated) {
+      info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
     }
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
     ok(`Updated ${CONFIG_PATH}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Gemini CLI, and OpenCode",
   "license": "MIT",
   "type": "module",

package/templates/.agents/README.en.md

@@ -34,6 +34,7 @@ This dual-config approach ensures every AI tool receives appropriate project con
     bug-fix.yaml                # Bug fix workflow
     code-review.yaml            # Code review workflow
     refactoring.yaml            # Refactoring workflow
+  rules/                        # Collaboration rule index (see rules/README.md)
   workspace/                    # Runtime workspace (git-ignored)
     active/                     # Currently active tasks
     blocked/                    # Blocked tasks

package/templates/.agents/README.zh-CN.md

@@ -34,6 +34,7 @@
     bug-fix.yaml                # 缺陷修复工作流
     code-review.yaml            # 代码审查工作流
     refactoring.yaml            # 重构工作流
+  rules/                        # 协作规则索引（见 rules/README.md）
   workspace/                    # 运行时工作区（已被 git ignore）
     active/                     # 当前活跃任务
     blocked/                    # 被阻塞的任务

package/templates/.agents/hooks/auto-resume.sh

@@ -80,8 +80,25 @@ until curl -s -o /dev/null --max-time 3 "$PROBE_URL"; do
 done
 log "probe ok after ${waited}s (error=$error)"
 
-# Inject: Escape first to leave any non-input TUI state, then the resume text.
-tmux send-keys -t "$TMUX_PANE" Escape 2>/dev/null
-tmux send-keys -t "$TMUX_PANE" "$RESUME_TEXT" Enter 2>/dev/null
-log "send-keys done (error=$error)"
+# Inject the resume message with a deliberately timing-insensitive sequence:
+#   1. Escape leaves any non-input TUI state.
+#   2. A 1s settle covers every known TUI escape timeout (vim 1000ms,
+#      xterm/readline 50ms) so the next bytes are delivered as fresh input
+#      instead of being folded into the escape sequence (the dropped-`U` race).
+#   3. The text travels through a NAMED paste buffer pasted with bracketed
+#      paste (-p): the TUI ingests it as a single paste rather than per-character
+#      keypresses, so no leading char is eaten and the body is not read as a
+#      submit. The named buffer (-b) guarantees we paste exactly this text, and
+#      -d deletes it afterward so the user's anonymous paste stack is untouched.
+#   4. Enter is a separate send-keys after the paste, so the submit signal is
+#      never merged into the pasted content (the must-press-Enter race).
+# Every step stays non-blocking (2>/dev/null, exit 0 below) and logs a WARN on
+# failure so the log can localize which tmux step broke.
+log "tmux inject start (error=$error)"
+tmux send-keys -t "$TMUX_PANE" Escape 2>/dev/null || log "WARN: tmux Escape failed (error=$error)"
+sleep 1
+tmux set-buffer -b auto-resume -- "$RESUME_TEXT" 2>/dev/null || log "WARN: tmux set-buffer failed (error=$error)"
+tmux paste-buffer -t "$TMUX_PANE" -b auto-resume -p -d 2>/dev/null || log "WARN: tmux paste-buffer failed (error=$error)"
+tmux send-keys -t "$TMUX_PANE" Enter 2>/dev/null || log "WARN: tmux Enter failed (error=$error)"
+log "tmux inject done (error=$error)"
 exit 0