@fitlab-ai/agent-infra 0.9.11 → 0.9.12

package/lib/platform/verification-required.ts

@@ -6,6 +6,7 @@ import { hasPlatformCapability } from "./adapters.ts";
 import { inspectRequiredChecks } from "./pr-checks.ts";
 import { resolvePlatformContext } from "./context.ts";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
+import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
 
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
@@ -34,7 +35,13 @@ function readHead(repoRoot: any): any {
 
 export function evaluateRequiredChecks(context: any, shared: any): any {
   const { metadata, localHead, inspection, prFlow } = context;
-  if (prFlow === "disabled" || metadata.pr_status === "skipped" || !validPrNumber(metadata.pr_number)) {
+  const factRead = readPrDeliveryFact(metadata);
+  if (factRead.status === "invalid") {
+    return shared.failResult(CHECK_TYPE, factRead.error.message, "check_failed");
+  }
+  const fact = factRead.status === "valid" ? factRead.fact : null;
+  const prNumber = fact?.state === "bound" ? fact.identity.number : null;
+  if (prFlow === "disabled" || fact?.state === "skipped" || !validPrNumber(prNumber)) {
     return shared.passResult(CHECK_TYPE, "Skipped: required checks are not applicable to this task");
   }
 
@@ -87,7 +94,10 @@ export function check({ taskDir }: any, shared: any): any {
   const task = shared.loadTask(taskDir);
   if (!task.ok) return shared.failResult(CHECK_TYPE, task.message);
   const prFlow = readPrFlow(shared.repoRoot);
-  if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
+  const factRead = readPrDeliveryFact(task.metadata);
+  if (factRead.status === "invalid") return shared.failResult(CHECK_TYPE, factRead.error.message, "check_failed");
+  const bound = factRead.status === "valid" && factRead.fact.state === "bound";
+  if (prFlow === "disabled" || (factRead.status === "valid" && factRead.fact.state === "skipped") || !bound) {
     return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
   }
   const platform = resolvePlatformContext({ cwd: shared.repoRoot });

package/lib/platform/verification-sync.ts

@@ -10,6 +10,7 @@ import { inspectGitHubIssueMetadata, requirementSectionAnchors } from "./issues.
 import { listRemoteComments } from "./issue-comments.ts";
 import { taskTypeLabel } from "./metadata-labels.ts";
 import { inspectGitHubPullRequest } from "./pull-requests.ts";
+import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
 
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
@@ -151,12 +152,16 @@ function buildSyncContext({ taskDir, config, artifactFile }: any): any {
   }
 
   const issueNumber = parseIssueNumber(task.metadata.issue_number);
-  const prNumber = parsePrNumber(task.metadata.pr_number);
+  const fact = readPrDeliveryFact(task.metadata);
+  if (fact.status === "invalid") {
+    return { earlyReturn: failResult(CHECK_TYPE, fact.error.message, "check_failed") };
+  }
+  const prNumber = fact.status === "valid" && fact.fact.state === "bound" ? fact.fact.identity.number : null;
   if (config.when === "issue_number_exists" && !issueNumber) {
     return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no issue_number") };
   }
-  if (config.when === "pr_number_exists" && !prNumber) {
-    return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no pr_number") };
+  if (config.when === "pr_fact_bound" && !prNumber) {
+    return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no verified bound pull request") };
   }
 
   if (!issueNumber) {
@@ -322,7 +327,7 @@ function fetchRemoteData(context: any): any {
   if (context.prMarker) {
     if (!context.prNumber) {
       return {
-        earlyReturn: failResult(CHECK_TYPE, "Expected a valid pr_number for PR comment verification", "check_failed")
+        earlyReturn: failResult(CHECK_TYPE, "Expected a verified bound pull request for PR comment verification", "check_failed")
       };
     }
 

package/lib/pr-review/evidence-grading.ts

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { parseTaskFrontmatter } from '../task/frontmatter.ts';
+import { parseTypedTaskFrontmatter } from '../task/frontmatter.ts';
+import { readPrDeliveryFact } from '../task/pr-delivery-fact.ts';
 
 // ---------------------------------------------------------------------------
 // Host resolution (PL-4): PR -> unique / ambiguous / none.
@@ -62,7 +63,7 @@ export function extractClosingIssueNumbers(body: string): number[] {
 /**
  * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
  * PR number or to one of the PR's closing issues. A task is emitted at most once;
- * a direct `pr_number` hit takes priority over the issue-number reverse lookup.
+ * a verified fact identity hit takes priority over the issue-number reverse lookup.
  */
 export function collectHostCandidates(input: {
   prNumber: number;
@@ -87,9 +88,11 @@ export function collectHostCandidates(input: {
     } catch {
       continue;
     }
-    const frontmatter = parseTaskFrontmatter(content);
+    let frontmatter: ReturnType<typeof parseTypedTaskFrontmatter>;
+    try { frontmatter = parseTypedTaskFrontmatter(content); } catch { continue; }
     const issueNumber = toPositiveNumber(frontmatter.issue_number);
-    const prNumber = toPositiveNumber(frontmatter.pr_number);
+    const fact = readPrDeliveryFact(frontmatter);
+    const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
     if (prNumber === input.prNumber) {
       candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
     } else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {

package/lib/sandbox/config.ts

@@ -63,6 +63,7 @@ export type SandboxConfig = {
   tools: string[];
   customTools: SandboxTool[];
   agentClientState: AgentClientState;
+  delivery?: { remote: string; baseRef: string };
   refreshIntervalDays: number;
   dockerfile: string | null;
   vm: SandboxVmConfig;
@@ -73,6 +74,7 @@ type AircConfig = {
   org?: unknown;
   agentClients?: unknown;
   sandbox?: SandboxConfigInput;
+  delivery?: { remote?: unknown; baseRef?: unknown };
 };
 
 function detectRepoRoot(): string {
@@ -135,6 +137,7 @@ export function loadConfig({
   const agentClients = normalizeAgentClients(airc);
   const defaults = cloneDefaults();
   const sandbox = airc.sandbox ?? {};
+  const delivery = airc.delivery ?? {};
   const engine = validateSandboxEngine(sandbox.engine ?? defaults.engine, { platformFn });
   const project = airc.project;
 
@@ -188,6 +191,10 @@ export function loadConfig({
     tools,
     customTools,
     agentClientState: agentClients.state,
+    delivery: {
+      remote: typeof delivery.remote === 'string' ? delivery.remote : 'origin',
+      baseRef: typeof delivery.baseRef === 'string' ? delivery.baseRef : 'main'
+    },
     refreshIntervalDays: asNonNegativeIntegerOrDefault(
       sandbox.refreshIntervalDays,
       defaults.refreshIntervalDays

package/lib/sandbox/control/lifecycle.ts

@@ -494,30 +494,32 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
   } catch {
     throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
-  const candidate = manifest as Partial<SandboxControlManifest> & { version?: unknown };
+  const candidate = manifest as Partial<SandboxControlManifest>;
   const expectedKeys = [
     'branch', 'channelDir', 'container', 'containerIdentity', 'engine', 'generation',
     'mode', 'processingDir', 'project', 'publicStatusDir', 'repoRoot', 'runtimeDir',
     'taskId', 'token', 'worktreeRoot'
   ];
-  if ('version' in candidate || typeof candidate.runtimeDir !== 'string'
-    || Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
-    throw new Error('SANDBOX_CONTROL_MANIFEST_REBUILD_REQUIRED: container-only recreation/rebuild is required');
+  if (Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
+    throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
   if (typeof candidate.containerIdentity !== 'object' || candidate.containerIdentity === null
     || Array.isArray(candidate.containerIdentity)) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   const containerIdentity = candidate.containerIdentity as Record<string, unknown>;
-  if (typeof candidate.engine !== 'string' || candidate.engine.length === 0
+  if (Object.keys(containerIdentity).sort().join(',') !== 'id,labels'
+    || typeof candidate.engine !== 'string' || candidate.engine.length === 0
     || typeof candidate.repoRoot !== 'string' || typeof candidate.worktreeRoot !== 'string'
     || typeof candidate.project !== 'string' || typeof candidate.container !== 'string'
     || typeof containerIdentity.id !== 'string' || containerIdentity.id.length === 0
     || typeof containerIdentity.labels !== 'object' || containerIdentity.labels === null
     || Array.isArray(containerIdentity.labels)
     || Object.values(containerIdentity.labels).some((value) => typeof value !== 'string')
-    || typeof candidate.branch !== 'string' || !['task-bound', 'branch-only'].includes(candidate.mode ?? '')
+    || typeof candidate.branch !== 'string'
+    || (candidate.mode !== 'task-bound' && candidate.mode !== 'branch-only')
     || (candidate.taskId !== null && typeof candidate.taskId !== 'string')
     || typeof candidate.channelDir !== 'string' || typeof candidate.publicStatusDir !== 'string'
-    || typeof candidate.processingDir !== 'string' || typeof candidate.token !== 'string'
+    || typeof candidate.processingDir !== 'string' || typeof candidate.runtimeDir !== 'string'
+    || typeof candidate.token !== 'string'
     || typeof candidate.generation !== 'string'
     || (candidate.mode === 'task-bound' && (typeof candidate.taskId !== 'string' || candidate.taskId.length === 0))
     || (candidate.mode === 'branch-only' && candidate.taskId !== null)) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
@@ -530,7 +532,27 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
   if (path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
     throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
-  return candidate as SandboxControlManifest;
+  const normalized: SandboxControlManifest = {
+    engine: candidate.engine,
+    repoRoot: candidate.repoRoot,
+    worktreeRoot: candidate.worktreeRoot,
+    project: candidate.project,
+    container: candidate.container,
+    containerIdentity: {
+      id: containerIdentity.id as string,
+      labels: { ...(containerIdentity.labels as Record<string, string>) }
+    },
+    branch: candidate.branch,
+    mode: candidate.mode,
+    taskId: candidate.taskId,
+    token: candidate.token,
+    generation: candidate.generation,
+    channelDir: candidate.channelDir,
+    publicStatusDir: candidate.publicStatusDir,
+    processingDir: candidate.processingDir,
+    runtimeDir: candidate.runtimeDir
+  };
+  return normalized;
 }
 
 export function readSandboxControlManifest(manifestPath: string): SandboxControlManifest {

package/lib/server/process-state.ts

@@ -85,8 +85,8 @@ export function isProcessAlive(pid: number, platform: NodeJS.Platform = process.
   }
 }
 
-function parseDarwinStartTime(output: string): number | null {
-  const match = output.trim().match(/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2}) (\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/);
+export function parseDarwinStartTime(output: string): number | null {
+  const match = output.trim().match(/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2})\s+(\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/);
   if (!match) return null;
   const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
   const month = months.indexOf(match[1]!);

package/lib/task/artifact-lifecycle.ts

@@ -482,9 +482,9 @@ function buildArtifactLinkSection(content: string, artifact: ArtifactIdentity):
   const label = english
     ? `${spec.labels[1]} (Round ${artifact.round})`
     : `${spec.labels[0]}（Round ${artifact.round}）`;
-  const link = `[${label}](${artifact.name})`;
+  const link = `${label}：\`${artifact.name}\``;
   let body = extractSection(content, aliases);
-  if (body.includes(`](${artifact.name})`)) return { aliases, heading, body };
+  if (body.includes(link)) return { aliases, heading, body };
   const placeholders = new Set([
     '[分析阶段的发现。哪些文件受影响？范围是什么？]',
     '[Findings from the analysis phase. Which files are affected? What is the scope?]',

package/lib/task/commit-intent.ts

@@ -0,0 +1,137 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type CheckpointIntentState = 'prepared' | 'committed' | 'synced';
+
+export type CheckpointIntent = Readonly<{
+  version: 1;
+  taskId: string;
+  branch: string;
+  mode: 'local';
+  expectedHead: string;
+  expectedTree: string;
+  paths: readonly string[];
+  message: string;
+  round: number;
+  digest: string;
+  state: CheckpointIntentState;
+  committedHead: string | null;
+  createdAt: string;
+  updatedAt: string;
+}>;
+
+type IntentIdentity = Readonly<{
+  taskId: string;
+  branch: string;
+  mode: 'local';
+  expectedHead: string;
+  expectedTree: string;
+  paths: readonly string[];
+  message: string;
+  round: number;
+}>;
+
+function intentRoot(repoRoot: string): string {
+  return path.join(repoRoot, '.agents', 'workspace', '.task-commit-intents');
+}
+
+function intentPath(repoRoot: string, taskId: string): string {
+  return path.join(intentRoot(repoRoot), `${taskId}.json`);
+}
+
+function checkpointIntentDigest(identity: IntentIdentity): string {
+  return createHash('sha256').update(JSON.stringify({
+    taskId: identity.taskId,
+    branch: identity.branch,
+    mode: identity.mode,
+    expectedHead: identity.expectedHead,
+    expectedTree: identity.expectedTree,
+    paths: [...identity.paths],
+    message: identity.message,
+    round: identity.round
+  })).digest('hex');
+}
+
+function isIntent(value: unknown): value is CheckpointIntent {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const intent = value as Record<string, unknown>;
+  return intent.version === 1
+    && typeof intent.taskId === 'string' && intent.taskId.length > 0
+    && typeof intent.branch === 'string' && intent.branch.length > 0
+    && intent.mode === 'local'
+    && typeof intent.expectedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedHead)
+    && typeof intent.expectedTree === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedTree)
+    && Array.isArray(intent.paths) && intent.paths.every((item) => typeof item === 'string' && item.length > 0)
+    && typeof intent.message === 'string' && intent.message.length > 0
+    && Number.isSafeInteger(intent.round) && Number(intent.round) > 0
+    && typeof intent.digest === 'string' && /^[a-f0-9]{64}$/.test(intent.digest)
+    && ['prepared', 'committed', 'synced'].includes(String(intent.state))
+    && (intent.committedHead === null || (typeof intent.committedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.committedHead)))
+    && typeof intent.createdAt === 'string' && intent.createdAt.length > 0
+    && typeof intent.updatedAt === 'string' && intent.updatedAt.length > 0
+    && intent.digest === checkpointIntentDigest(intent as unknown as IntentIdentity);
+}
+
+function readCheckpointIntent(repoRoot: string, taskId: string): CheckpointIntent | null {
+  const target = intentPath(repoRoot, taskId);
+  if (!fs.existsSync(target)) return null;
+  const value = JSON.parse(fs.readFileSync(target, 'utf8')) as unknown;
+  if (!isIntent(value)) throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+  return value;
+}
+
+function writeCheckpointIntent(repoRoot: string, value: CheckpointIntent): void {
+  if (!isIntent(value)) throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+  const directory = intentRoot(repoRoot);
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const target = intentPath(repoRoot, value.taskId);
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+  try { fs.renameSync(temporary, target); }
+  catch (error) {
+    try { fs.unlinkSync(temporary); } catch { /* preserve primary error */ }
+    throw error;
+  }
+}
+
+function updateCheckpointIntent(
+  value: CheckpointIntent,
+  patch: Partial<Pick<CheckpointIntent, 'state' | 'committedHead' | 'updatedAt'>>
+): CheckpointIntent {
+  const next = { ...value, ...patch };
+  if (next.state === 'prepared' && next.committedHead !== null) throw new Error('COMMIT_INTENT_INVALID: prepared intent cannot have a committed head');
+  if (next.state !== 'prepared' && !next.committedHead) throw new Error('COMMIT_INTENT_INVALID: committed intent requires a committed head');
+  return next;
+}
+
+function removeCheckpointIntent(repoRoot: string, taskId: string): void {
+  const target = intentPath(repoRoot, taskId);
+  try { fs.unlinkSync(target); } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+}
+
+function sameCheckpointIntent(left: CheckpointIntent, right: IntentIdentity): boolean {
+  return left.digest === checkpointIntentDigest(right)
+    && left.taskId === right.taskId
+    && left.branch === right.branch
+    && left.mode === right.mode
+    && left.expectedHead === right.expectedHead
+    && left.expectedTree === right.expectedTree
+    && left.message === right.message
+    && left.round === right.round
+    && JSON.stringify(left.paths) === JSON.stringify(right.paths);
+}
+
+export {
+  checkpointIntentDigest,
+  intentPath,
+  intentRoot,
+  isIntent,
+  readCheckpointIntent,
+  removeCheckpointIntent,
+  sameCheckpointIntent,
+  updateCheckpointIntent,
+  writeCheckpointIntent
+};