@fitlab-ai/agent-infra 0.10.0 → 0.11.0

package/lib/platform/issue-comments.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 
 import { parseTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
@@ -16,6 +17,14 @@ import {
 } from './provider-bridge.ts';
 import { resourceIdentityNumber } from './resource-identity.ts';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.ts';
+import {
+  recordForArtifact,
+  recordForCancel,
+  recordForSummary,
+  recordForTask,
+  renderActivityRecoveryMetadata
+} from './activity-recovery.ts';
+import { projectTaskComment } from './task-comment-projection.ts';
 import {
   canonicalizeCommentBody,
   escapeHtmlText,
@@ -48,7 +57,7 @@ const MARKERS = {
   artifactChunk: (taskId: string, stem: string, part: number, total: number) =>
     `<!-- sync-issue:${taskId}:${stem}:${part}/${total} -->`,
   summary: (taskId: string) => `<!-- sync-issue:${taskId}:summary -->`,
-  cancel: (taskId: string) => `<!-- sync-issue:${taskId}:cancel -->`
+  cancel: (taskId: string) => `<!-- sync-issue:${taskId}:cancel -->`,
 };
 const COMMENT_BYTE_LIMIT = 60_000;
 
@@ -68,10 +77,6 @@ function normalizeCommentContent(content: string): string {
   return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
 }
 
-function isTaskCommentTooLarge(content: string): boolean {
-  return Buffer.byteLength(content, 'utf8') > COMMENT_BYTE_LIMIT;
-}
-
 function splitFrontmatter(content: string): { frontmatter: string | null; body: string } {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
   if (!match) return { frontmatter: null, body: content };
@@ -88,22 +93,55 @@ function footer(agent: string, taskId: string): string {
   return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
 }
 
-function renderTaskComment(content: string, taskId: string, agent: string): string {
+function taskFrontmatterSummary(language = ''): string {
+  return language === 'en' || language === 'en-US'
+    ? 'Metadata (frontmatter)'
+    : '元数据 (frontmatter)';
+}
+
+function renderTaskCommentResult(content: string, taskId: string, language = ''): { body: string; byteLength: number; sha256: string } {
   const split = splitFrontmatter(content);
-  const safeBody = sanitizeCommentBody(split.body, 'task body');
-  const taskBody = split.frontmatter === null
+  const projectedContent = split.frontmatter === null ? content : projectTaskComment(content).content;
+  const projected = splitFrontmatter(projectedContent);
+  const safeBody = sanitizeCommentBody(projected.body, 'task body');
+  const taskBody = projected.frontmatter === null
     ? safeBody
-    : `<details><summary>元数据 (frontmatter)</summary>\n\n${renderSafeCodeFence(`---\n${split.frontmatter}\n---`, 'yaml')}\n\n</details>\n\n${safeBody}`;
-  return normalizeCommentContent([
+    : `<details><summary>${taskFrontmatterSummary(language)}</summary>\n\n${renderSafeCodeFence(`---\n${projected.frontmatter}\n---`, 'yaml')}\n\n</details>\n\n${safeBody}`;
+  const recoveryMetadata = renderActivityRecoveryMetadata(recordForTask(taskId, content));
+  const body = normalizeCommentContent([
     MARKERS.task(taskId),
     '## 任务文件',
     '',
-    `> **${agent}** · ${taskId}`,
+    `> 任务同步 · ${taskId}`,
     '',
+    ...(recoveryMetadata ? [recoveryMetadata.replace(/\n+$/, ''), ''] : []),
     taskBody.replace(/\n+$/, ''),
     '',
-    footer(agent, taskId)
+    '---',
+    `*由 agent-infra 自动生成 · 内部追踪：${taskId}*`
   ].join('\n'));
+  return {
+    body,
+    byteLength: Buffer.byteLength(body, 'utf8'),
+    sha256: createHash('sha256').update(body, 'utf8').digest('hex')
+  };
+}
+
+function renderTaskComment(content: string, taskId: string, _agent: string, language = ''): string {
+  return renderTaskCommentResult(content, taskId, language).body;
+}
+
+function isTaskCommentTooLarge(content: string, taskId = 'TASK-UNKNOWN', _agent = 'codex'): boolean {
+  return renderTaskCommentResult(content, taskId).byteLength > COMMENT_BYTE_LIMIT;
+}
+
+function taskCommentLanguage(repoRoot: string): string {
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { language?: unknown };
+    return typeof config.language === 'string' ? config.language.trim() : '';
+  } catch {
+    return '';
+  }
 }
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
@@ -247,7 +285,8 @@ function buildArtifactChunk(
   total: number,
   chunked: boolean,
   backfill: boolean,
-  renderedContent = content
+  renderedContent = content,
+  recoveryMetadata = ''
 ): RenderedChunk {
   const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
   const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
@@ -259,6 +298,7 @@ function buildArtifactChunk(
     '',
     `> **${agent}** · ${taskId}`,
     '',
+    ...(recoveryMetadata ? [recoveryMetadata] : []),
     renderedContent,
     '',
     footer(agent, taskId)
@@ -273,12 +313,13 @@ function chunkArtifactComment(input: {
   body: string;
   byteLimit?: number;
   backfill?: boolean;
+  recoveryMetadata?: string;
 }): RenderedChunk[] {
   const byteLimit = input.byteLimit || COMMENT_BYTE_LIMIT;
   const identity = artifactIdentity(input.artifact);
   const safeBody = sanitizeCommentBody(input.body, 'artifact body');
   const single = buildArtifactChunk(
-    input.taskId, identity.stem, identity.title, input.agent, safeBody, 1, 1, false, Boolean(input.backfill)
+    input.taskId, identity.stem, identity.title, input.agent, safeBody, 1, 1, false, Boolean(input.backfill), safeBody, input.recoveryMetadata
   );
   if (Buffer.byteLength(single.body, 'utf8') <= byteLimit) return [single];
 
@@ -288,7 +329,7 @@ function chunkArtifactComment(input: {
   if (!ranges.ok) throw new Error(`${ranges.error.code}: artifact body: ${ranges.error.message} at offset ${ranges.error.offset}`);
   for (;;) {
     const probe = buildArtifactChunk(
-      input.taskId, identity.stem, identity.title, input.agent, '', total, total, true, Boolean(input.backfill)
+      input.taskId, identity.stem, identity.title, input.agent, '', 1, total, true, Boolean(input.backfill), '', input.recoveryMetadata
     );
     const available = byteLimit - Buffer.byteLength(probe.body, 'utf8');
     const sourceLimit = Math.min(available, payloadLimit);
@@ -308,7 +349,8 @@ function chunkArtifactComment(input: {
       total,
       true,
       Boolean(input.backfill),
-      independentChunkContent(piece, ranges.value, sourceLimit)
+      independentChunkContent(piece, ranges.value, sourceLimit),
+      index === 0 ? input.recoveryMetadata : ''
     ));
     const overflow = Math.max(...chunks.map((chunk) => Buffer.byteLength(chunk.body, 'utf8') - byteLimit));
     if (overflow <= 0) return chunks;
@@ -346,9 +388,11 @@ function hasResolvedPlatformContext(context: PlatformResult): boolean {
   return context.status === 'degraded' || (context.status === 'no-op' && context.error === null);
 }
 
-function bodyEnvelope(marker: string, title: string, taskId: string, agent: string, body: string): string {
+function bodyEnvelope(marker: string, title: string, taskId: string, agent: string, body: string, recoveryMetadata = ''): string {
   return normalizeCommentContent([
-    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '', sanitizeCommentBody(body, `${title} body`).replace(/\n+$/, ''), '', footer(agent, taskId)
+    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '',
+    ...(recoveryMetadata ? [recoveryMetadata.replace(/\n+$/, ''), ''] : []),
+    sanitizeCommentBody(body, `${title} body`).replace(/\n+$/, ''), '', footer(agent, taskId)
   ].join('\n'));
 }
 
@@ -368,10 +412,11 @@ function expectedComments(
   taskId: string,
   taskContent: string,
   taskDir: string,
+  repoRoot: string,
   options: SyncOptions
 ): RenderedChunk[] {
   if (options.kind === 'task') {
-    const body = renderTaskComment(taskContent, taskId, options.agent);
+    const body = renderTaskComment(taskContent, taskId, options.agent, taskCommentLanguage(repoRoot));
     return [{ marker: MARKERS.task(taskId), body, content: taskContent, part: 1, total: 1 }];
   }
   if (options.kind === 'artifact') {
@@ -381,13 +426,17 @@ function expectedComments(
       artifact: options.artifact,
       agent: options.agent,
       body: resolveArtifactBody(taskDir, options.artifact),
-      backfill: options.backfill
+      backfill: options.backfill,
+      recoveryMetadata: renderActivityRecoveryMetadata(recordForArtifact(taskId, taskContent, options.artifact))
     });
   }
   if (options.body === undefined) throw new Error(`${options.kind} sync requires a body`);
   const marker = options.kind === 'summary' ? MARKERS.summary(taskId) : MARKERS.cancel(taskId);
   const title = options.kind === 'summary' ? '交付摘要' : '任务取消';
-  const body = bodyEnvelope(marker, title, taskId, options.agent, options.body);
+  const recoveryMetadata = options.kind === 'summary'
+    ? renderActivityRecoveryMetadata(recordForSummary(taskId, taskContent))
+    : renderActivityRecoveryMetadata(recordForCancel(taskId, taskContent));
+  const body = bodyEnvelope(marker, title, taskId, options.agent, options.body, recoveryMetadata);
   return [{ marker, body, content: options.body, part: 1, total: 1 }];
 }
 
@@ -458,22 +507,22 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
       error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
     });
   }
-  if (options.kind === 'task' && isTaskCommentTooLarge(taskContent)) {
-    return platformResult('no-op', {
-      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask), identity: issueIdentityFromTask },
-      operations: [{ name: `comment:${MARKERS.task(resolved.taskId)}`, status: 'skipped', reasonCode: 'COMMENT_PAYLOAD_TOO_LARGE' }],
-      error: null
-    });
-  }
   let desired: RenderedChunk[];
   try {
-    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
+    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, resolved.repoRoot, options);
   } catch (error) {
     return platformResult('failed', {
       resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask) },
       error: { code: 'COMMENT_PAYLOAD_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false }
     });
   }
+  if (options.kind === 'task' && Buffer.byteLength(desired[0]!.body, 'utf8') > COMMENT_BYTE_LIMIT) {
+    return platformResult('failed', {
+      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask), identity: issueIdentityFromTask },
+      operations: [{ name: `comment:${MARKERS.task(resolved.taskId)}`, status: 'skipped', reasonCode: 'COMMENT_PAYLOAD_TOO_LARGE' }],
+      error: { code: 'COMMENT_PAYLOAD_TOO_LARGE', message: 'Projected task comment exceeds the platform byte limit', retryable: false }
+    });
+  }
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
   if (!hasResolvedPlatformContext(context) || !loaded.ok) return context;
@@ -505,6 +554,22 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     });
   }
 
+  if (options.kind === 'task' && existing.length === 1) {
+    const owner = existing[0]!.user?.login;
+    if (!owner || !context.platform.currentUser || owner !== context.platform.currentUser) {
+      return platformResult('blocked', {
+        ...contextFields(context),
+        resource: { kind: 'issue', number: issue, identity: issueIdentityFromTask },
+        error: {
+          code: 'COMMENT_OWNER_CONFLICT',
+          message: owner ? `Task comment is owned by '${owner}'` : 'Task comment owner is unavailable',
+          retryable: false
+        }
+      });
+    }
+  }
+
+
   // Backfill only supplies missing artifact comments; valid existing marker sets stay untouched.
   if (options.kind === 'artifact' && options.backfill && existing.length > 0) {
     const operations = existing.map((comment): PlatformOperation => ({
@@ -582,14 +647,15 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     operations.push({ name: `comment:${comment.id}`, status: 'applied', reasonCode: 'STALE_CHUNK_DELETED' });
   }
   const changed = operations.some((operation) => operation.status === 'applied');
-  return platformResult(changed ? 'applied' : 'no-op', {
+  const result = platformResult(changed ? 'applied' : 'no-op', {
     ...contextFields(context),
     changed,
     resource: { kind: 'issue', number: issue },
     operations,
-    comment: { kind: options.kind, marker: desired[0]!.marker, ids, parts: desired.length },
+    comment: { kind: options.kind, marker: desired[0]?.marker ?? markerPrefix(resolved.taskId, options), ids, parts: desired.length },
     error: null
   });
+  return result;
 }
 
 async function listPlatformComments(issue: string | number, cwd = process.cwd(), client?: PlatformClient): Promise<PlatformResult & { comments?: RemoteComment[] }> {
@@ -655,6 +721,7 @@ export {
   listPlatformComments,
   normalizeCommentContent,
   renderTaskComment,
+  renderTaskCommentResult,
   isTaskCommentTooLarge,
   syncPlatformComment,
   validateRelatedMarkerSet,

package/lib/platform/task-comment-projection.ts

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto';
+
+const SNAPSHOT_FRONTMATTER = new Set([
+  'id', 'type', 'branch', 'workflow', 'status', 'created_at', 'updated_at',
+  'priority', 'effort', 'start_date', 'target_date', 'current_step', 'assigned_to',
+  'platform_issue_identity', 'delivery_remote', 'delivery_base_ref', 'pr_delivery_fact'
+]);
+
+type TaskCommentProjection = {
+  content: string;
+  byteLength: number;
+  sha256: string;
+};
+
+const PROCESS_SECTION_ALIASES = new Set([
+  '活动日志', 'activity log',
+  '产物生命周期收据', 'artifact lifecycle receipts',
+  '审查分歧账本', 'review dispute ledger', 'review disagreement ledger',
+  '人工裁决', '人工裁决待办', 'human decisions', 'human decision pending', 'human decisions pending',
+  '实现输入', 'implementation input', 'implementation inputs',
+  '工作流告警', 'workflow warning', 'workflow warnings', 'warnings',
+  '返工意图', 'rework intent', 'rework intents',
+  '产物失效记录', 'artifact invalidation', 'artifact invalidation records',
+  '实现备注', 'implementation notes',
+  '审查反馈', 'review feedback'
+]);
+
+function normalize(content: string): string {
+  return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+
+function splitFrontmatter(content: string): { frontmatter: string; body: string } {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) throw new Error('task comment projection requires task frontmatter');
+  return { frontmatter: match[1]!, body: content.slice(match[0].length) };
+}
+
+function projectFrontmatter(frontmatter: string): string {
+  const lines = frontmatter.replace(/\r\n/g, '\n').split('\n');
+  const selected = lines.filter((line) => {
+    if (!line.trim() || line.trimStart().startsWith('#')) return false;
+    const match = /^([^:\s][^:]*):/.exec(line);
+    return Boolean(match && SNAPSHOT_FRONTMATTER.has(match[1]!.trim()));
+  });
+  if (!selected.some((line) => /^id:/.test(line))) throw new Error('task comment projection requires frontmatter id');
+  return selected.join('\n');
+}
+
+function projectBody(body: string): string {
+  const lines = body.replace(/\r\n/g, '\n').split('\n');
+  const kept: string[] = [];
+  let excludedLevel: number | null = null;
+  for (const line of lines) {
+    const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+    if (heading) {
+      const level = heading[1]!.length;
+      if (excludedLevel !== null && level <= excludedLevel) excludedLevel = null;
+      if (PROCESS_SECTION_ALIASES.has(heading[2]!.trim().toLowerCase())) {
+        excludedLevel = level;
+        continue;
+      }
+    }
+    if (excludedLevel === null) kept.push(line);
+  }
+  return kept.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function projectTaskComment(content: string): TaskCommentProjection {
+  const split = splitFrontmatter(content);
+  const projected = normalize(`---\n${projectFrontmatter(split.frontmatter)}\n---\n\n${projectBody(split.body)}`);
+  return {
+    content: projected,
+    byteLength: Buffer.byteLength(projected, 'utf8'),
+    sha256: createHash('sha256').update(projected, 'utf8').digest('hex')
+  };
+}
+
+export { projectTaskComment };
+export type { TaskCommentProjection };

package/lib/platform/task-recovery.ts

@@ -0,0 +1,54 @@
+import { parseActivityRecoveryMetadata } from './activity-recovery.ts';
+
+type RecoveryRemoteComment = { body: string; user?: { login?: string } };
+
+function normalized(body: string): string {
+  return body.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+
+function decodeRenderedText(value: string): string {
+  return value
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, '&');
+}
+
+function taskSnapshot(taskId: string, body: string): string {
+  const marker = `<!-- sync-issue:${taskId}:task -->`;
+  if (normalized(body).split('\n', 1)[0] !== marker) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot marker is invalid');
+  const frontmatter = body.match(/<details><summary>[^<]*<\/summary>\n\n```yaml\n---\n([\s\S]*?)\n---\n```\n\n<\/details>/);
+  if (!frontmatter) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot frontmatter is invalid');
+  const afterDetails = (frontmatter.index ?? 0) + frontmatter[0].length;
+  const footer = body.lastIndexOf('\n\n---\n*由 ');
+  if (footer <= afterDetails) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot envelope is invalid');
+  const projectedBody = body.slice(afterDetails, footer).replace(/^\n+|\n+$/g, '');
+  return `---\n${decodeRenderedText(frontmatter[1]!)}\n---\n\n${decodeRenderedText(projectedBody)}\n`;
+}
+
+function activityLine(entry: { time: string; step: string; agent: string; note: string }): string {
+  return `- ${entry.time} — **${entry.step}** by ${entry.agent} — ${entry.note}`;
+}
+
+function recoverTaskFromComments(input: { taskId: string; comments: readonly RecoveryRemoteComment[] }): string {
+  const marker = `<!-- sync-issue:${input.taskId}:task -->`;
+  const snapshots = input.comments.filter((comment) => normalized(comment.body).split('\n', 1)[0] === marker);
+  if (snapshots.length !== 1) throw new Error('RECOVERY_EVIDENCE_MISSING: exactly one task snapshot comment is required');
+  const author = snapshots[0]!.user?.login;
+  if (!author) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot author is unavailable');
+  const content = taskSnapshot(input.taskId, normalized(snapshots[0]!.body));
+  const entries = new Map<string, { time: string; step: string; agent: string; note: string }>();
+  for (const comment of input.comments) {
+    if (comment.user?.login !== author) continue;
+    const record = parseActivityRecoveryMetadata(comment.body);
+    if (!record) continue;
+    if (record.taskId !== input.taskId) throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata task identity is invalid');
+    for (const entry of record.entries) entries.set(JSON.stringify(entry), entry);
+  }
+  const restored = [...entries.values()].sort((left, right) => left.time.localeCompare(right.time));
+  return `${content.replace(/\n+$/, '')}\n\n## 活动日志\n\n${restored.map(activityLine).join('\n')}\n`;
+}
+
+export { recoverTaskFromComments };
+export type { RecoveryRemoteComment };

package/lib/platform/verification-sync.ts

@@ -12,7 +12,7 @@ import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.ts";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.ts";
 import { taskIssueIdentity } from "./task-identities.ts";
-import { isTaskCommentTooLarge } from "./issue-comments.ts";
+import { renderTaskCommentResult } from "./issue-comments.ts";
 import {
   CONTROL_MARKER_PATTERN,
   canonicalizeCommentBody,
@@ -542,10 +542,6 @@ function checkTaskCommentContent(context: any, remoteData: any, shared: Verifica
   if (!context.config.verify_task_comment_content) {
     return null;
   }
-  if (isTaskCommentTooLarge(context.task.content)) {
-    return null;
-  }
-
   const taskMarker = `<!-- sync-issue:${context.task.metadata.id}:task -->`;
   const comment = findCommentByMarker(remoteData.comments, taskMarker);
   if (!comment) {
@@ -555,14 +551,20 @@ function checkTaskCommentContent(context: any, remoteData: any, shared: Verifica
     );
   }
 
-  const expectedTaskBody = buildExpectedTaskBody(context.task.content, shared);
-  if (expectedTaskBody === null) {
-    return shared.failResult(CHECK_TYPE,
-      "Task content cannot be rendered safely for comment verification",
-      "check_failed"
+  let renderedTask: { body: string; byteLength: number };
+  try {
+    renderedTask = renderTaskCommentResult(
+      context.task.content,
+      context.task.metadata.id,
+      loadProjectLanguage(shared)
     );
+  } catch {
+    return shared.failResult(CHECK_TYPE, "Task content cannot be rendered safely for comment verification", "check_failed");
+  }
+  if (renderedTask.byteLength > 60_000) {
+    return shared.failResult(CHECK_TYPE, "Task comment exceeds the platform byte limit", "check_failed");
   }
-  const expectedBody = shared.normalizeContent(expectedTaskBody);
+  const expectedBody = shared.normalizeContent(extractCommentBody(renderedTask.body));
   const commentBody = shared.normalizeContent(extractCommentBody(comment.body || ""));
 
   if (expectedBody === commentBody) {
@@ -833,7 +835,7 @@ function extractCommentBody(commentBody: any): any {
     start += 1;
   }
 
-  if (start < lines.length && /^> \*\*.+\*\* · .+$/.test(lines[start]!.trim())) {
+  if (start < lines.length && (/^> \*\*.+\*\* · .+$/.test(lines[start]!.trim()) || /^> 任务同步 · .+$/.test(lines[start]!.trim()))) {
     start += 1;
   }
 
@@ -841,6 +843,16 @@ function extractCommentBody(commentBody: any): any {
     start += 1;
   }
 
+  if (lines[start]?.trim() === "<details><summary>恢复元数据</summary>") {
+    const metadataEnd = lines.indexOf("</details>", start + 1);
+    if (metadataEnd >= 0) {
+      start = metadataEnd + 1;
+      while (start < lines.length && lines[start]!.trim() === "") {
+        start += 1;
+      }
+    }
+  }
+
   let end = lines.length;
   for (let index = lines.length - 1; index >= start; index -= 1) {
     const trimmed = lines[index]!.trim();
@@ -1042,7 +1054,9 @@ function computeExpectedInLabels(taskDir: any, repositoryLabels: string[], mappi
   if (!baseRef) {
     return { ok: false, type: "check_failed", message: "Task has no delivery_base_ref for in-label evidence" };
   }
-  const changedFilesResult = gitText(["diff", `${baseRef}...HEAD`, "--name-only"], taskDir);
+  const branch = typeof task.metadata?.branch === "string" ? task.metadata.branch.trim() : "";
+  const gitCwd = branch ? worktreeForBranch(shared.repoRoot, branch) ?? taskDir : taskDir;
+  const changedFilesResult = gitText(["diff", `${baseRef}...HEAD`, "--name-only"], gitCwd);
   if (!changedFilesResult.ok) {
     return { ...changedFilesResult, type: "network_error" };
   }
@@ -1069,6 +1083,25 @@ function computeExpectedInLabels(taskDir: any, repositoryLabels: string[], mappi
   return { ok: true, labels: planned.target, mode: "mapped" };
 }
 
+function worktreeForBranch(repositoryRoot: string, branch: string): string | null {
+  try {
+    const records = execFileSync("git", ["worktree", "list", "--porcelain"], {
+      cwd: repositoryRoot,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split(/\r?\n\r?\n/);
+    const expectedRef = `refs/heads/${branch}`;
+    for (const record of records) {
+      const worktree = /^worktree (.+)$/m.exec(record)?.[1];
+      const branchRef = /^branch (.+)$/m.exec(record)?.[1];
+      if (worktree && branchRef === expectedRef) return worktree;
+    }
+  } catch {
+    // Fall back to taskDir so ordinary in-repository task workspaces retain their behavior.
+  }
+  return null;
+}
+
 function loadInLabelMapping(shared: VerificationShared): any {
   const configPath = path.join(shared.repoRoot, ".agents", ".airc.json");
   if (!fs.existsSync(configPath)) {

package/lib/sandbox/control/executor.ts

@@ -188,7 +188,9 @@ export async function prepareSandboxControlExecution(params: {
         owner: gateOwner,
         requestId: params.request.id,
         operationId: authority?.operationId ?? params.request.id,
-        phase: authority?.phase ?? (params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
+        phase: authority?.phase ?? (params.request.family === 'task-workflow'
+          && params.request.workflow?.operation === 'artifact-preflight' ? 'artifact.preflight'
+          : params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
         authority
       } satisfies SandboxControlExecutorGateV2);
     },
@@ -235,7 +237,7 @@ function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner
         return;
       }
       if (typeof value.requestId !== 'string' || typeof value.operationId !== 'string'
-        || !['orchestration.prepare', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase as string)
+        || !['orchestration.prepare', 'artifact.preflight', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase as string)
         || (value.authority !== null && value.authority !== undefined && (() => {
           try { validateLifecycleRecoveryAttestation(value.authority); return false; } catch { return true; }
         })())) {

package/lib/sandbox/control/protocol.ts

@@ -62,7 +62,7 @@ export type SandboxControlExecutorGateV2 = Readonly<{
   owner: SandboxControlBrokerOwner;
   requestId: string;
   operationId: string;
-  phase: 'orchestration.prepare' | 'artifact.finalize-local' | 'task-event.completed';
+  phase: 'orchestration.prepare' | 'artifact.preflight' | 'artifact.finalize-local' | 'task-event.completed';
   authority: LifecycleRecoveryAttestationV1 | null;
 }>;
 type RequestBase = Readonly<{

package/lib/sandbox/control/task-workflow.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
-import { readStableFile, SecureFileError, writeAtomicFile } from '../../host-control/secure-fs.ts';
+import { readStableFile, SecureFileError, writeAtomicFile } from '../../task/secure-fs.ts';
 
 import { TASK_WORKFLOW_COMMANDS, TASK_WORKFLOW_OPERATIONS, type TaskWorkflowOperation, type WorkflowCommand } from '../../task/workflow-command.ts';