@fitlab-ai/agent-infra 0.9.12 → 0.9.13

package/lib/sandbox/control/state.ts

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { buildProcessTreeStopCommand } from '../../server/process-control.ts';
 import { getProcessIdentityState } from '../../server/process-state.ts';
 import type { ProcessIdentity, ProcessIdentityProbe } from '../../server/process-state.ts';
@@ -9,8 +9,20 @@ import type {
   SandboxControlExecution,
   SandboxControlLease,
   SandboxControlManifest,
+  SandboxControlPayload,
+  SandboxControlReservation,
+  SandboxControlResultEvidence,
   SandboxControlStatus
 } from './protocol.ts';
+import {
+  parseSandboxControlResultEvidence,
+  parseSandboxControlPayload,
+  parseSandboxControlReservation,
+  SANDBOX_CONTROL_MAX_RESPONSE_BYTES,
+  SANDBOX_CONTROL_MAX_LOGICAL_RECORDS,
+  SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES,
+  SANDBOX_CONTROL_RESERVATION_BYTES
+} from './protocol.ts';
 
 export const SANDBOX_CONTROL_AUDIT_MAX_BYTES = 1024 * 1024;
 export const SANDBOX_CONTROL_EXECUTION_STOP_MS = 2_000;
@@ -31,11 +43,249 @@ export function atomicWriteJson(filePath: string, value: unknown, mode = 0o600,
   }
 }
 
+export function sandboxControlEncodedJsonBytes(value: unknown): number {
+  return Buffer.byteLength(`${JSON.stringify(value)}\n`, 'utf8');
+}
+
+export function atomicWriteJsonNoReplace(
+  filePath: string,
+  value: unknown,
+  mode = 0o600,
+  createParent = true
+): void {
+  atomicCreateJson(filePath, value, 'SANDBOX_CONTROL_TERMINAL_ALREADY_EXISTS', mode, createParent);
+}
+
+function atomicCreateJson(
+  filePath: string,
+  value: unknown,
+  duplicateCode: string,
+  mode = 0o600,
+  createParent = true
+): void {
+  if (createParent) fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temporary = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode, flag: 'wx' });
+    try {
+      fs.linkSync(temporary, filePath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
+        throw new Error(duplicateCode);
+      }
+      throw error;
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
 export function readJsonFile(filePath: string): unknown {
   assertRegularFile(filePath);
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
 
+export function resultEvidencePath(manifest: SandboxControlManifest, requestId: string): string {
+  if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+  return path.join(manifest.processingDir, requestId, 'result.json');
+}
+
+export function payloadPath(manifest: SandboxControlManifest, requestId: string): string {
+  if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+  return path.join(manifest.channelDir, 'responses', `${requestId}.payload.json`);
+}
+
+export function reservationPath(manifest: SandboxControlManifest, requestId: string): string {
+  if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) throw new Error('SANDBOX_CONTROL_RESERVATION_INVALID');
+  return path.join(manifest.processingDir, requestId, 'reservation.json');
+}
+
+export function readSandboxControlResultEvidence(filePath: string): SandboxControlResultEvidence {
+  assertRegularFile(filePath);
+  const raw = fs.readFileSync(filePath, 'utf8');
+  if (Buffer.byteLength(raw, 'utf8') > SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
+    throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_TOO_LARGE');
+  }
+  try {
+    return parseSandboxControlResultEvidence(JSON.parse(raw));
+  } catch (error) {
+    if (error instanceof Error && error.message === 'SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID') throw error;
+    throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+  }
+}
+
+export function sanitizeSandboxControlOutput(manifest: SandboxControlManifest, output: string): string {
+  return manifest.token.length === 0 ? output : output.split(manifest.token).join('[REDACTED]');
+}
+
+export function sanitizeSandboxControlResult(
+  manifest: SandboxControlManifest,
+  result: Readonly<{ exitCode: number; stdout: string; stderr: string }>
+): { exitCode: number; stdout: string; stderr: string } {
+  return {
+    exitCode: result.exitCode,
+    stdout: sanitizeSandboxControlOutput(manifest, result.stdout),
+    stderr: sanitizeSandboxControlOutput(manifest, result.stderr)
+  };
+}
+
+export function writeSandboxControlResultEvidence(
+  manifest: SandboxControlManifest,
+  requestId: string,
+  result: Readonly<{ exitCode: number; stdout: string; stderr: string }>
+): SandboxControlResultEvidence {
+  const normalized = sanitizeSandboxControlResult(manifest, result);
+  const stdout = normalized.stdout;
+  const stderr = normalized.stderr;
+  if (!/^[a-f0-9-]{16,64}$/u.test(requestId)
+    || !Number.isSafeInteger(result.exitCode)
+    || Buffer.byteLength(stdout, 'utf8') + Buffer.byteLength(stderr, 'utf8') > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+    throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+  }
+  const evidence: SandboxControlResultEvidence = {
+    version: 1,
+    id: requestId,
+    generation: manifest.generation,
+    exitCode: result.exitCode,
+    stdoutBytes: Buffer.byteLength(stdout, 'utf8'),
+    stderrBytes: Buffer.byteLength(stderr, 'utf8'),
+    stdoutSha256: createHash('sha256').update(stdout, 'utf8').digest('hex'),
+    stderrSha256: createHash('sha256').update(stderr, 'utf8').digest('hex'),
+    captureState: 'metadata-only'
+  };
+  if (sandboxControlEncodedJsonBytes(evidence) > SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
+    throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_TOO_LARGE');
+  }
+  atomicCreateJson(
+    resultEvidencePath(manifest, requestId), evidence,
+    'SANDBOX_CONTROL_RESULT_EVIDENCE_ALREADY_EXISTS'
+  );
+  return readSandboxControlResultEvidence(resultEvidencePath(manifest, requestId));
+}
+
+export function writeSandboxControlPayload(
+  manifest: SandboxControlManifest,
+  requestId: string,
+  result: Readonly<{ stdout: string; stderr: string }>
+): SandboxControlPayload {
+  const payload = createSandboxControlPayload(manifest, requestId, result);
+  atomicCreateJson(payloadPath(manifest, requestId), payload, 'SANDBOX_CONTROL_PAYLOAD_ALREADY_EXISTS');
+  return readSandboxControlPayload(payloadPath(manifest, requestId));
+}
+
+export function createSandboxControlPayload(
+  manifest: SandboxControlManifest,
+  requestId: string,
+  result: Readonly<{ stdout: string; stderr: string }>
+): SandboxControlPayload {
+  const stdout = sanitizeSandboxControlOutput(manifest, result.stdout);
+  const stderr = sanitizeSandboxControlOutput(manifest, result.stderr);
+  const payload: SandboxControlPayload = {
+    version: 1,
+    id: requestId,
+    generation: manifest.generation,
+    stdout,
+    stderr,
+    stdoutBytes: Buffer.byteLength(stdout, 'utf8'),
+    stderrBytes: Buffer.byteLength(stderr, 'utf8'),
+    stdoutSha256: createHash('sha256').update(stdout, 'utf8').digest('hex'),
+    stderrSha256: createHash('sha256').update(stderr, 'utf8').digest('hex')
+  };
+  if (payload.stdoutBytes + payload.stderrBytes > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+    throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+  }
+  if (sandboxControlEncodedJsonBytes(payload) > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+    throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+  }
+  return payload;
+}
+
+export function readSandboxControlPayload(filePath: string): SandboxControlPayload {
+  assertRegularFile(filePath);
+  const raw = fs.readFileSync(filePath, 'utf8');
+  if (Buffer.byteLength(raw, 'utf8') > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+    throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+  }
+  try {
+    return parseSandboxControlPayload(JSON.parse(raw));
+  } catch {
+    throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+  }
+}
+
+export function writeSandboxControlReservation(
+  manifest: SandboxControlManifest,
+  requestId: string,
+  usage: Readonly<{ logicalRecords: number; bytes: number }>,
+  now = Date.now()
+): SandboxControlReservation {
+  if (usage.logicalRecords >= SANDBOX_CONTROL_MAX_LOGICAL_RECORDS
+    || usage.bytes + SANDBOX_CONTROL_RESERVATION_BYTES > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+    throw new Error('SANDBOX_CONTROL_CAPACITY_EXHAUSTED');
+  }
+  const reservation: SandboxControlReservation = {
+    version: 1,
+    id: requestId,
+    generation: manifest.generation,
+    logicalRecords: 1,
+    bytes: SANDBOX_CONTROL_RESERVATION_BYTES,
+    createdAt: now
+  };
+  atomicCreateJson(reservationPath(manifest, requestId), reservation, 'SANDBOX_CONTROL_RESERVATION_ALREADY_EXISTS');
+  return parseSandboxControlReservation(readJsonFile(reservationPath(manifest, requestId)));
+}
+
+export function readSandboxControlReservation(filePath: string): SandboxControlReservation {
+  return parseSandboxControlReservation(readJsonFile(filePath));
+}
+
+export function sandboxControlGenerationUsage(manifest: SandboxControlManifest): { logicalRecords: number; bytes: number } {
+  const records = new Map<string, { baseBytes: number; payloadBytes: number; logical: boolean }>();
+  const responsesDir = path.join(manifest.channelDir, 'responses');
+  if (fs.existsSync(responsesDir)) {
+    for (const entry of fs.readdirSync(responsesDir, { withFileTypes: true })) {
+      if (!entry.isFile()) continue;
+      const terminal = entry.name.match(/^([a-f0-9-]{16,64})\.json$/u);
+      const accepted = entry.name.match(/^([a-f0-9-]{16,64})\.accepted\.json$/u);
+      const payload = entry.name.match(/^([a-f0-9-]{16,64})\.payload\.json$/u);
+      if (!terminal && !accepted && !payload) continue;
+      const id = (terminal ?? accepted ?? payload)![1]!;
+      const previous = records.get(id) ?? { baseBytes: 0, payloadBytes: 0, logical: false };
+      const fileBytes = fs.statSync(path.join(responsesDir, entry.name)).size;
+      if (payload) previous.payloadBytes += fileBytes;
+      else previous.baseBytes += fileBytes;
+      previous.logical ||= Boolean(terminal || accepted);
+      records.set(id, previous);
+    }
+  }
+  if (fs.existsSync(manifest.processingDir)) {
+    for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/u.test(entry.name)) continue;
+      const resultPath = resultEvidencePath(manifest, entry.name);
+      const filePath = reservationPath(manifest, entry.name);
+      const previous = records.get(entry.name) ?? { baseBytes: 0, payloadBytes: 0, logical: false };
+      if (fs.existsSync(resultPath)) {
+        const result = readSandboxControlResultEvidence(resultPath);
+        if (result.id !== entry.name || result.generation !== manifest.generation) {
+          throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+        }
+        previous.baseBytes += fs.statSync(resultPath).size;
+        previous.logical = true;
+      }
+      if (fs.existsSync(filePath)) {
+        const reservation = readSandboxControlReservation(filePath);
+        previous.baseBytes = Math.max(previous.baseBytes, reservation.bytes);
+        previous.logical = true;
+      }
+      records.set(entry.name, previous);
+    }
+  }
+  return {
+    logicalRecords: [...records.values()].filter((record) => record.logical).length,
+    bytes: [...records.values()].reduce((total, record) => total + record.baseBytes + record.payloadBytes, 0)
+  };
+}
+
 export function statusPath(manifest: SandboxControlManifest): string {
   return path.join(manifest.publicStatusDir, 'status.json');
 }

package/lib/server/protocol.ts

@@ -20,6 +20,27 @@ function taskSubcommand(subcommand: string): string {
   return subcommand === 'list' ? 'ls' : subcommand;
 }
 
+function splitRunArguments(args: readonly string[]): { hostArgs: string[]; skillArgs: string[] } {
+  const hostArgs: string[] = [];
+  const skillArgs: string[] = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i] as string;
+    if (arg === '--tui') {
+      hostArgs.push(arg);
+      const value = args[i + 1];
+      if (value !== undefined) {
+        hostArgs.push(value);
+        i += 1;
+      }
+    } else if (arg === '--recreate') {
+      hostArgs.push(arg);
+    } else {
+      skillArgs.push(arg);
+    }
+  }
+  return { hostArgs, skillArgs };
+}
+
 export function commandHelp(): string {
   return [
     `agent-infra ${VERSION}`,
@@ -88,7 +109,21 @@ export function parseCommand(text: string): CommandPlan {
   if (command === '/run') {
     const spec = getSkillRunSpec(subcommand);
     if (!spec) return { kind: 'error', message: `Unknown skill: ${subcommand}` };
-    return { kind: 'ai', role: spec.role, argv: ['run', subcommand, ...rest] };
+    if (spec.kind === 'create') {
+      return { kind: 'ai', role: spec.role, argv: ['run', '--skill', subcommand, ...rest] };
+    }
+    const [taskRef, ...skillArgs] = rest;
+    if (!taskRef) return { kind: 'error', message: '/run task skills require a task-ref' };
+    const { hostArgs, skillArgs: forwardedSkillArgs } = splitRunArguments(skillArgs);
+    return {
+      kind: 'ai',
+      role: spec.role,
+      argv: [
+        'run', '--skill', subcommand, '--task', taskRef,
+        ...hostArgs,
+        ...(forwardedSkillArgs.length > 0 ? ['--', ...forwardedSkillArgs] : [])
+      ]
+    };
   }
 
   return { kind: 'error', message: `Unknown command: ${command}` };

package/lib/task/activity-log.ts

@@ -5,6 +5,7 @@ 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-]+)$/;
+const LIFECYCLE_STEP_RE = /^(?:Complete Manual Validation|(?:Analyze Task|Review Analysis|Plan Task|Review Plan|Code Task|Review Code|Run Manual Validation) \(Round [1-9]\d*(?:(?:, fix for review-code(?:-r[2-9]|-r[1-9]\d+)?\.md)|(?:, decision II-[1-9]\d*))?\))$/;
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
 type StepRow = { step: string; agent: string; started: string; done: string; note: string; attempt?: string };
@@ -93,9 +94,16 @@ function startedBackedRows(rows: StepRow[]): StepRow[] {
   return rows.filter((row) => row.started !== '');
 }
 
+function hasOpenLifecycleExecution(content: string): boolean {
+  const section = locateActivityLog(content);
+  if (!section) return false;
+  return pairEntries(section.entries).some((row) => row.done === '' && LIFECYCLE_STEP_RE.test(row.step));
+}
+
 export {
   activityAttempt,
   appendActivityEntry,
+  hasOpenLifecycleExecution,
   commitAttemptStartedNote,
   locateActivityLog,
   pairEntries,

package/lib/task/artifact-lifecycle.ts

@@ -8,6 +8,8 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
 import { receiptForOutput, sha256File } from './artifact-receipts.ts';
+import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.ts';
+import type { InvalidationDocument } from './invalidation.ts';
 
 const artifactFamilyCatalog = [
   { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
@@ -47,7 +49,7 @@ type ArtifactErrorCode =
   | 'ARTIFACT_REFERENCE_INVALID' | 'ARTIFACT_PATH_INVALID'
   | 'ARTIFACT_IDENTITY_INVALID' | 'ARTIFACT_NOT_FOUND'
   | 'ARTIFACT_NOT_REGULAR' | 'ARTIFACT_NOT_READABLE' | 'ARTIFACT_VERDICT_INVALID'
-  | 'ARTIFACT_MODE_REFUSED';
+  | 'ARTIFACT_MODE_REFUSED' | 'ARTIFACT_INVALIDATION_INVALID';
 type ArtifactError = { code: ArtifactErrorCode; message: string };
 type ArtifactInventoryResult = {
   status: 'ready' | 'failed';
@@ -154,7 +156,23 @@ function inspectArtifactDirectory(
       taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
     });
   }
+  let invalidation: InvalidationDocument = { operations: [], targets: [] };
+  try {
+    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const parsed = parseInvalidationDocument(taskContent);
+    if (!parsed.ok) {
+      return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: parsed.message }, {
+        taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+      });
+    }
+    invalidation = parsed.document;
+  } catch (error) {
+    return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: String(error) }, {
+      taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+    });
+  }
   const artifacts: ArtifactIdentity[] = [];
+  const knownArtifacts: ArtifactIdentity[] = [];
   const diagnostics: ArtifactDiagnostic[] = [];
   for (const entry of entries) {
     const parsed = parseArtifactName(entry.name);
@@ -184,17 +202,20 @@ function inspectArtifactDirectory(
         diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, `artifact is not readable: ${entry.name}`));
         continue;
       }
-      artifacts.push({ ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs });
+      const identity = { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
+      knownArtifacts.push(identity);
+      if (!isArtifactInvalidated(invalidation, family, entry.name)) artifacts.push(identity);
     } catch (error) {
       diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, String(error)));
     }
   }
   artifacts.sort((left, right) => left.round - right.round);
-  const rounds = new Set(artifacts.map((item) => item.round));
-  if (artifacts.length > 0 && !rounds.has(1)) diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
-  const max = artifacts.at(-1)?.round ?? 0;
+  knownArtifacts.sort((left, right) => left.round - right.round);
+  const knownRounds = new Set(knownArtifacts.map((item) => item.round));
+  if (knownArtifacts.length > 0 && !knownRounds.has(1)) diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
+  const max = knownArtifacts.at(-1)?.round ?? 0;
   for (let round = 1; round <= max; round += 1) {
-    if (!rounds.has(round)) diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
+    if (!knownRounds.has(round)) diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
   }
   const latest = artifacts.at(-1) ?? null;
   const reviewedInput = family.startsWith('review-') && latest
@@ -230,6 +251,11 @@ function resolveReviewedInput(
     const stat = fs.lstatSync(abs);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('referenced input is not a regular file');
     const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const invalidation = parseInvalidationDocument(taskContent);
+    if (!invalidation.ok) throw new Error(invalidation.message);
+    if (isArtifactInvalidated(invalidation.document, expectedFamily, parsed.name)) {
+      throw new Error(`${parsed.name} is invalidated`);
+    }
     const receipt = receiptForOutput(taskContent, review.name);
     if (!receipt) throw new Error(`receipt for ${review.name} is missing`);
     const expectedEvent = reviewEventName(review.family);