@fitlab-ai/agent-infra 0.9.4 → 0.9.5

package/lib/sandbox/control/server.ts

@@ -2,6 +2,8 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getProcessStartTime } from '../../server/process-state.ts';
+import { createTask } from '../../task/create-service.ts';
+import { assertGitWorktreeBinding } from '../../git/worktree-identity.ts';
 import {
   bindSandboxControlTask,
   validateSandboxControlRequest,
@@ -13,9 +15,12 @@ function readManifest(manifestPath: string): SandboxControlManifest {
   const stat = fs.lstatSync(manifestPath);
   if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as SandboxControlManifest;
+  if (manifest.version !== 2) {
+    throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 2; recreate the sandbox');
+  }
   if (
-    manifest.version !== 1
-    || typeof manifest.repoRoot !== 'string'
+    typeof manifest.repoRoot !== 'string'
+    || typeof manifest.worktreeRoot !== 'string'
     || typeof manifest.channelDir !== 'string'
     || typeof manifest.token !== 'string'
   ) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
@@ -39,8 +44,28 @@ function writeResponse(directory: string, response: SandboxControlResponse): voi
   fs.renameSync(temporary, path.join(directory, `${response.id}.json`));
 }
 
+export function sandboxControlSafeEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      ([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')
+    )
+  );
+}
+
+function consumeRequest(directory: string, id: string): void {
+  try {
+    fs.writeFileSync(path.join(directory, id), '', { flag: 'wx', mode: 0o600 });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
+      throw new Error('SANDBOX_CONTROL_REQUEST_REPLAYED');
+    }
+    throw error;
+  }
+}
+
 export function serveSandboxControl(manifestPath: string, signal: AbortSignal = new AbortController().signal): void {
   const manifest = readManifest(manifestPath);
+  assertGitWorktreeBinding(manifest.repoRoot, manifest.worktreeRoot, manifest.branch);
   const brokerPath = path.join(path.dirname(manifestPath), 'broker.json');
   const startTime = getProcessStartTime(process.pid);
   if (!startTime) throw new Error('SANDBOX_CONTROL_BROKER_IDENTITY_UNAVAILABLE');
@@ -52,15 +77,18 @@ export function serveSandboxControl(manifestPath: string, signal: AbortSignal =
   })}\n`, { mode: 0o600, flag: 'wx' });
   const requestsDir = path.join(manifest.channelDir, 'requests');
   const responsesDir = path.join(manifest.channelDir, 'responses');
+  const consumedDir = path.join(path.dirname(manifestPath), 'consumed');
   assertRealDirectory(manifest.channelDir);
   fs.mkdirSync(requestsDir, { recursive: true, mode: 0o700 });
   fs.mkdirSync(responsesDir, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
   assertRealDirectory(requestsDir, manifest.channelDir);
   assertRealDirectory(responsesDir, manifest.channelDir);
-  const consumed = new Set<string>();
+  assertRealDirectory(consumedDir, path.dirname(manifestPath));
   while (!signal.aborted) {
     const current = readManifest(manifestPath);
     if (current.token !== manifest.token) return;
+    assertGitWorktreeBinding(current.repoRoot, current.worktreeRoot, current.branch);
     assertRealDirectory(requestsDir, manifest.channelDir);
     assertRealDirectory(responsesDir, manifest.channelDir);
     for (const name of fs.readdirSync(requestsDir).sort()) {
@@ -76,26 +104,36 @@ export function serveSandboxControl(manifestPath: string, signal: AbortSignal =
           manifest
         );
         id = request.id;
-        if (consumed.has(id)) throw new Error('SANDBOX_CONTROL_REQUEST_REPLAYED');
-        consumed.add(id);
-        const result = spawnSync(
-          process.execPath,
-          ['--experimental-strip-types', '--no-warnings', process.argv[1]!, request.family, ...bindSandboxControlTask(request, manifest.taskId!)],
-          {
-            cwd: manifest.repoRoot,
-            encoding: 'utf8',
-            env: Object.fromEntries(
-              Object.entries(process.env).filter(([key]) => !key.startsWith('AGENT_INFRA_CONTROL_'))
-            )
+        consumeRequest(consumedDir, id);
+        if (request.family === 'task-create') {
+          const result = createTask(request.candidate, { repoRoot: manifest.repoRoot });
+          response = {
+            version: 1, id,
+            exitCode: result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0,
+            stdout: `${JSON.stringify(result)}\n`, stderr: ''
+          };
+        } else {
+          const boundArgs = bindSandboxControlTask(request, manifest.taskId!);
+          if (request.family === 'task-orchestration') {
+            boundArgs.push('--git-worktree-root', manifest.worktreeRoot);
           }
-        );
-        response = {
-          version: 1,
-          id,
-          exitCode: result.status ?? 1,
-          stdout: result.stdout ?? '',
-          stderr: result.stderr ?? ''
-        };
+          const result = spawnSync(
+            process.execPath,
+            ['--experimental-strip-types', '--no-warnings', process.argv[1]!, request.family, ...boundArgs],
+            {
+              cwd: manifest.repoRoot,
+              encoding: 'utf8',
+              env: sandboxControlSafeEnv()
+            }
+          );
+          response = {
+            version: 1,
+            id,
+            exitCode: result.status ?? 1,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? ''
+          };
+        }
       } catch (error) {
         response = {
           version: 1,

package/lib/sandbox/workspace-view.ts

@@ -113,6 +113,7 @@ export function materializeSandboxWorkspaceView(params: Readonly<{
 export function materializeSandboxControl(params: Readonly<{
   base: string;
   repoRoot: string;
+  worktreeRoot: string;
   project: string;
   container: string;
   branch: string;
@@ -120,6 +121,10 @@ export function materializeSandboxControl(params: Readonly<{
 }>): SandboxControlSetup {
   const { root, channelDir, manifestPath } = sandboxControlPaths(params);
   assertSafeDirectory(root, path.resolve(params.base));
+  const consumedDir = path.join(root, 'consumed');
+  assertSafeDirectory(consumedDir, root);
+  fs.rmSync(consumedDir, { recursive: true, force: true });
+  fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
   for (const queue of ['requests', 'responses']) {
     const directory = path.join(channelDir, queue);
     assertSafeDirectory(directory, root);
@@ -127,9 +132,11 @@ export function materializeSandboxControl(params: Readonly<{
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
   }
   const token = randomBytes(32).toString('hex');
+  const repoRoot = fs.realpathSync.native(params.repoRoot);
   const manifest: SandboxControlManifest = {
-    version: 1,
-    repoRoot: fs.realpathSync.native(params.repoRoot),
+    version: 2,
+    repoRoot,
+    worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
     project: params.project,
     container: params.container,
     branch: params.branch,

package/lib/task/activity-log.ts

@@ -2,10 +2,14 @@ const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
 const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+const ABORTED_SUFFIX_RE = /\s*\[aborted\]\s*$/;
+const ATTEMPT_RE = /(?:^|;\s*)attempt=([A-Za-z0-9-]{8,64})(?:;|$)/;
+const COMMIT_STARTED_RE = /^started; attempt=([A-Za-z0-9-]{8,64}); baseline=([a-f0-9]{40,64}); agent=([a-z-]+)$/;
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
-type StepRow = { step: string; agent: string; started: string; done: string; note: string };
+type StepRow = { step: string; agent: string; started: string; done: string; note: string; attempt?: string };
 type ActivityLogSection = { heading: string; body: string; entries: LogEntry[] };
+type CommitAttempt = Readonly<{ attempt: string; baseline: string; agent: string }>;
 
 function parseActivityLog(content: string): { sectionFound: boolean; entries: LogEntry[] } {
   const section = locateActivityLog(content);
@@ -37,26 +41,61 @@ function appendActivityEntry(section: ActivityLogSection, entry: LogEntry): stri
   return section.body ? `${section.body}\n${line}` : line;
 }
 
+function activityAttempt(note: string): string | null {
+  return ATTEMPT_RE.exec(note)?.[1] ?? null;
+}
+
+function parseCommitAttemptStarted(note: string): CommitAttempt | null {
+  const match = COMMIT_STARTED_RE.exec(note);
+  return match ? { attempt: match[1]!, baseline: match[2]!, agent: match[3]! } : null;
+}
+
+function commitAttemptStartedNote(attempt: CommitAttempt): string {
+  return `started; attempt=${attempt.attempt}; baseline=${attempt.baseline}; agent=${attempt.agent}`;
+}
+
 function pairEntries(entries: LogEntry[]): StepRow[] {
   const rows: StepRow[] = [];
   const open = new Map<string, StepRow[]>();
   for (const entry of entries) {
     const started = STARTED_SUFFIX_RE.test(entry.step);
-    const base = entry.step.replace(STARTED_SUFFIX_RE, '');
+    const aborted = ABORTED_SUFFIX_RE.test(entry.step);
+    const base = entry.step.replace(STARTED_SUFFIX_RE, '').replace(ABORTED_SUFFIX_RE, '');
     if (started) {
-      const row = { step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note };
+      const attempt = activityAttempt(entry.note);
+      const row: StepRow = {
+        step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note,
+        ...(attempt ? { attempt } : {})
+      };
       rows.push(row);
       const queue = open.get(base) ?? [];
       queue.push(row);
       open.set(base, queue);
     } else {
-      const pending = open.get(base)?.shift();
+      const queue = open.get(base) ?? [];
+      const terminalAttempt = aborted ? activityAttempt(entry.note) : null;
+      const pendingIndex = terminalAttempt === null
+        ? 0
+        : queue.findIndex((row) => row.attempt === terminalAttempt);
+      const pending = pendingIndex >= 0 ? queue.splice(pendingIndex, 1)[0] : undefined;
       if (pending) Object.assign(pending, { done: entry.time, agent: entry.agent, note: entry.note });
-      else rows.push({ step: base, agent: entry.agent, started: '', done: entry.time, note: entry.note });
+      else rows.push({
+        step: aborted ? entry.step : base,
+        agent: entry.agent, started: '', done: entry.time, note: entry.note,
+        ...(terminalAttempt ? { attempt: terminalAttempt } : {})
+      });
     }
   }
   return rows;
 }
 
-export { parseActivityLog, locateActivityLog, appendActivityEntry, pairEntries };
-export type { LogEntry, StepRow, ActivityLogSection };
+export {
+  activityAttempt,
+  appendActivityEntry,
+  commitAttemptStartedNote,
+  locateActivityLog,
+  pairEntries,
+  parseActivityLog,
+  parseCommitAttemptStarted
+};
+export type { ActivityLogSection, CommitAttempt, LogEntry, StepRow };

package/lib/task/commit-finalization.ts

@@ -2,7 +2,13 @@ import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { locateActivityLog, appendActivityEntry, pairEntries } from './activity-log.ts';
+import {
+  locateActivityLog,
+  appendActivityEntry,
+  pairEntries,
+  parseCommitAttemptStarted
+} from './activity-log.ts';
+import type { CommitAttempt } from './activity-log.ts';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.ts';
 import type { CommitIntent } from './commit-intent.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
@@ -10,7 +16,8 @@ import { parseReviewSummary } from './review-artifacts.ts';
 import {
   extractReviewBaseline,
   extractReviewedSnapshotTree,
-  findAuthoritativeReviewCodeArtifact
+  findAuthoritativeReviewCodeArtifact,
+  parseReviewedGitTree
 } from './review-fingerprint.ts';
 import type { TaskMutation } from './write.ts';
 
@@ -20,6 +27,7 @@ type CommitFinalizationDisposition =
   | 'recoverable'
   | 'invalid'
   | 'conflict'
+  | 'retryable-start'
   | 'orphaned-start';
 
 type CommitFinalizationCode =
@@ -39,6 +47,7 @@ type CommitFinalizationInspection = Readonly<{
   needsLog: boolean;
   intent: CommitIntent | null;
   intentDigest: string | null;
+  attempt: CommitAttempt | null;
 }>;
 
 type CreatePrCommitGate = Readonly<{
@@ -93,6 +102,7 @@ function outcome(
     needsLog: false,
     intent: null,
     intentDigest: null,
+    attempt: null,
     ...overrides
   };
 }
@@ -128,6 +138,16 @@ function inspectCommitFinalization(
   const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
   const file = commitIntentPath(taskDir);
   if (!fs.existsSync(file)) {
+    if (openRows.length === 1) {
+      const attempt = parseCommitAttemptStarted(openRows[0]!.note);
+      if (attempt && attempt.baseline === currentHead) {
+        return outcome('retryable-start', {
+          message: 'a structured Commit attempt can be safely reused',
+          currentHead,
+          attempt
+        });
+      }
+    }
     if (openRows.length > 0) {
       return outcome('orphaned-start', {
         code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
@@ -204,7 +224,7 @@ function inspectCommitFinalization(
     const summary = parseReviewSummary(reviewContent);
     const reviewBaseline = extractReviewBaseline(reviewContent);
     const reviewTree = extractReviewedSnapshotTree(reviewContent);
-    if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !SHA_RE.test(reviewTree)) {
+    if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
       return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
     }
     const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);

package/lib/task/create-service.ts

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { syncPlatformComment } from '../platform/issue-comments.ts';
+import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.ts';
+import type { PlatformResult } from '../platform/types.ts';
+import { VERSION } from '../version.ts';
+import { applyWorkflowWarningIntent } from './workflow-warning-intents.ts';
+import { createLocalTask, type TaskCreateCandidateV1 } from './create.ts';
+import { verifyTaskEvent } from './verification.ts';
+
+type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
+type TaskCreateOperation = { name: string; status: string; reasonCode: string | null };
+type TaskCreateWarning = { code: string; severity: string; action: string };
+type TaskCreateResult = Readonly<{
+  status: TaskCreateStatus;
+  changed: boolean;
+  task: { id: string | null; shortId: string | null };
+  issue: { number: number; url: string } | null;
+  operations: readonly TaskCreateOperation[];
+  warnings: readonly TaskCreateWarning[];
+  error: { code: string; message: string; retryable: boolean } | null;
+}>;
+
+type CreateTaskOptions = Readonly<{
+  repoRoot: string;
+  agentInfraVersion?: string;
+  dependencies?: Partial<TaskCreateDependencies>;
+}>;
+
+type TaskCreateDependencies = Readonly<{
+  createIssue: typeof createPlatformIssue;
+  syncIssue: typeof syncPlatformIssue;
+  syncComment: typeof syncPlatformComment;
+  addWarning: typeof applyWorkflowWarningIntent;
+}>;
+
+const DEFAULT_DEPENDENCIES: TaskCreateDependencies = {
+  createIssue: createPlatformIssue,
+  syncIssue: syncPlatformIssue,
+  syncComment: syncPlatformComment,
+  addWarning: applyWorkflowWarningIntent
+};
+
+function verifyCreatedTask(repoRoot: string, taskId: string): { operation: TaskCreateOperation; error: TaskCreateResult['error'] } {
+  const verification = verifyTaskEvent(
+    { taskRef: taskId, event: 'create-task.completed' },
+    { repoRoot }
+  );
+  if (verification.status === 'pass') {
+    return { operation: { name: 'task:verify', status: 'pass', reasonCode: null }, error: null };
+  }
+  const blocked = verification.status === 'blocked';
+  return {
+    operation: {
+      name: 'task:verify', status: verification.status,
+      reasonCode: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED'
+    },
+    error: {
+      code: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED',
+      message: `Created task did not pass the ${verification.event} gate`,
+      retryable: blocked
+    }
+  };
+}
+
+function platformOperations(prefix: string, operations: readonly { name: string; status: string; reasonCode?: string | null }[]): TaskCreateOperation[] {
+  return operations.map((operation) => ({
+    name: `${prefix}:${operation.name}`,
+    status: operation.status,
+    reasonCode: operation.reasonCode ?? null
+  }));
+}
+
+function issueFromTask(repoRoot: string, taskId: string): { number: number; url: string } | null {
+  const content = fs.readFileSync(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), 'utf8');
+  const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
+  return match ? { number: Number(match[1]), url: '' } : null;
+}
+
+function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResult {
+  const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
+  let candidate: TaskCreateCandidateV1;
+  let local;
+  try {
+    candidate = value as TaskCreateCandidateV1;
+    local = createLocalTask(candidate, {
+      repoRoot: options.repoRoot,
+      agentInfraVersion: options.agentInfraVersion ?? VERSION
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+    return {
+      status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+      operations: [], warnings: [], error: { code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' }
+    };
+  }
+
+  const operations: TaskCreateOperation[] = [{
+    name: 'task:local', status: local.status, reasonCode: null
+  }];
+  let issue = issueFromTask(options.repoRoot, local.task.id);
+  const created = dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
+  operations.push(...platformOperations('platform-create', created.operations));
+  if (created.issue) issue = { number: created.issue.number, url: created.issue.url };
+
+  let platformFailure: PlatformResult | null = created.status === 'failed' || created.status === 'blocked' ? created : null;
+  if (!platformFailure && (created.task.issueNumber || issue)) {
+    const synced = dependencies.syncIssue(local.task.id, {
+      cwd: options.repoRoot,
+      agent: candidate.agent,
+      status: 'waiting-for-triage',
+      assignees: 'current',
+      milestone: 'initial',
+      issueType: true,
+      fields: true
+    });
+    operations.push(...platformOperations('platform-sync', synced.operations));
+    if (synced.issue) issue = { number: synced.issue.number, url: synced.issue.url };
+    if (synced.status === 'failed' || synced.status === 'blocked') platformFailure = synced;
+    if (!platformFailure) {
+      const commented = dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
+      operations.push(...platformOperations('platform-comment', commented.operations));
+      if (commented.status === 'failed' || commented.status === 'blocked') platformFailure = commented;
+    }
+  }
+
+  if (platformFailure) {
+    const error = platformFailure.error ?? { code: 'ISSUE_CREATE_FAILED', message: 'Platform operation failed', retryable: false };
+    dependencies.addWarning({
+      kind: 'add', taskRef: local.task.id, step: 'create-task', severity: 'ACTION_REQUIRED',
+      code: 'ISSUE_CREATE_FAILED', target: 'issue', message: `${error.code}: ${error.message}`,
+      action: 'Fix platform authentication or connectivity, then retry Issue creation for this task.'
+    }, { repoRoot: options.repoRoot });
+    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    operations.push(verified.operation);
+    if (verified.error) return {
+      status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+      task: local.task, issue, operations, warnings: [], error: verified.error
+    };
+    return {
+      status: platformFailure.status === 'blocked' ? 'blocked' : 'degraded',
+      changed: local.changed,
+      task: local.task,
+      issue,
+      operations,
+      warnings: [{ code: 'ISSUE_CREATE_FAILED', severity: 'ACTION_REQUIRED', action: 'Retry Issue creation after fixing the platform failure.' }],
+      error
+    };
+  }
+
+  const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+  operations.push(verified.operation);
+  if (verified.error) return {
+    status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+    task: local.task, issue, operations, warnings: [], error: verified.error
+  };
+  return {
+    status: local.status,
+    changed: local.changed,
+    task: local.task,
+    issue,
+    operations,
+    warnings: [],
+    error: null
+  };
+}
+
+export { createTask };
+export type { CreateTaskOptions, TaskCreateDependencies, TaskCreateOperation, TaskCreateResult, TaskCreateStatus, TaskCreateWarning };