@fitlab-ai/agent-infra 0.9.6 → 0.9.7

package/lib/task/artifact-lifecycle.ts

@@ -7,6 +7,7 @@ import { locateActivityLog } from './activity-log.ts';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.ts';
 import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
+import { receiptForOutput, sha256File } from './artifact-receipts.ts';
 
 const artifactFamilyCatalog = [
   { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
@@ -218,11 +219,7 @@ function resolveReviewedInput(
     diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, String(error)));
     return null;
   }
-  const lines = content.split(/\r?\n/);
-  const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
-  const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
-  const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]!);
-  const parsed = candidates.map((name) => parseArtifactName(name)).find((item) => item?.family === expectedFamily);
+  const parsed = parseReviewedInputReference(content, expectedFamily);
   if (!parsed) {
     diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${review.name} does not reference a canonical ${expectedFamily} artifact`));
     return null;
@@ -231,9 +228,16 @@ function resolveReviewedInput(
   try {
     const stat = fs.lstatSync(abs);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('referenced input is not a regular file');
-    if (stat.mtimeMs > review.mtimeMs) {
-      diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${parsed.name} is newer than ${review.name}`));
-      return null;
+    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const receipt = receiptForOutput(taskContent, review.name);
+    if (!receipt) throw new Error(`receipt for ${review.name} is missing`);
+    const expectedEvent = reviewEventName(review.family);
+    if (receipt.event !== expectedEvent || receipt.input !== parsed.name) {
+      throw new Error(`receipt for ${review.name} does not match ${parsed.name}`);
+    }
+    const actualSha256 = sha256File(abs);
+    if (actualSha256 !== receipt.inputSha256) {
+      throw new Error(`${parsed.name} content digest does not match receipt`);
     }
     return { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
   } catch (error) {
@@ -242,6 +246,54 @@ function resolveReviewedInput(
   }
 }
 
+function parseReviewedInputReference(content: string, expectedFamily: ArtifactFamily): { family: ArtifactFamily; round: number; name: string } | null {
+  const lines = content.split(/\r?\n/);
+  const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
+  const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
+  const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]!);
+  return candidates
+    .map((name) => parseArtifactName(name))
+    .find((item) => item?.family === expectedFamily) ?? null;
+}
+
+function parseCodePlanInputReference(content: string): { family: 'plan'; round: number; name: string } | null {
+  const lines = content.split(/\r?\n/);
+  const sectionStart = lines.findIndex((line) => /^##\s+(?:实现输入|Implementation Input)\s*$/.test(line.trim()));
+  if (sectionStart < 0) return null;
+  const bodyLines = lines.slice(sectionStart + 1);
+  const nextSection = bodyLines.findIndex((line) => /^##\s+/.test(line.trim()));
+  const body = (nextSection < 0 ? bodyLines : bodyLines.slice(0, nextSection)).join('\n');
+  const match = body.match(/\*\*(?:方案输入|Plan Input)\*\*[:：]\s*`([^`]+\.md)`/);
+  if (!match) return null;
+  const parsed = parseArtifactName(match[1]!);
+  return parsed?.family === 'plan' ? { ...parsed, family: 'plan' } : null;
+}
+
+function reviewEventName(family: ArtifactFamily): 'review-analysis.completed' | 'review-plan.completed' | 'review-code.completed' {
+  if (family === 'review-analysis') return 'review-analysis.completed';
+  if (family === 'review-plan') return 'review-plan.completed';
+  if (family === 'review-code') return 'review-code.completed';
+  throw new Error(`unsupported review family '${family}'`);
+}
+
+function resolveCodeInputReceipt(taskDir: string, code: ArtifactIdentity): { input: ArtifactIdentity; inputSha256: string } | null {
+  let taskContent: string;
+  try { taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'); }
+  catch { return null; }
+  let receipt;
+  try { receipt = receiptForOutput(taskContent, code.name); }
+  catch { return null; }
+  if (!receipt || receipt.event !== 'code.completed') return null;
+  const plan = inspectArtifactDirectory(taskDir, 'plan');
+  if (plan.status !== 'ready') return null;
+  const input = plan.artifacts.find((artifact) => artifact.name === receipt.input);
+  return input ? { input, inputSha256: receipt.inputSha256 } : null;
+}
+
+function resolveCodePlanInput(taskDir: string, code: ArtifactIdentity): { input: ArtifactIdentity; inputSha256: string } | null {
+  return resolveCodeInputReceipt(taskDir, code);
+}
+
 function assertWritableInventory(inventory: ArtifactInventoryResult): ArtifactError | null {
   if (inventory.status === 'failed') return inventory.error;
   const blockers = inventory.diagnostics.filter((item) => BLOCKING_DIAGNOSTICS.has(item.code));
@@ -312,11 +364,21 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
     return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, null, null,
       'No prior code artifact. Starting initial implementation (round 1 -> code.md).');
   }
+  const codePlanInput = resolveCodePlanInput(inventory.taskDir!, latestCode);
+  if (!codePlanInput) {
+    return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `code completion receipt for ${latestCode.name} is missing or does not match the current plan`, latestCode.name);
+  }
+  if (reviewPlan.latest && !reviewPlan.reviewedInput) {
+    return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `${reviewPlan.latest.name} has no valid reviewed input`, reviewPlan.latest.name);
+  }
   if (reviewPlan.latest && reviewPlan.reviewedInput?.name === plan.latest.name) {
     const verdict = parseVerdict(reviewPlan.latest.path);
-    if (verdict.ok && verdict.verdict === 'Approved' && reviewPlan.latest.mtimeMs > latestCode.mtimeMs) {
+    const reviewedPlanSha256 = sha256File(reviewPlan.reviewedInput.path);
+    if (verdict.ok && verdict.verdict === 'Approved' && (
+      codePlanInput.input.name !== plan.latest.name || codePlanInput.inputSha256 !== reviewedPlanSha256
+    )) {
       return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name,
-        `Latest ${reviewPlan.latest.name} is approved and newer than the latest code artifact. Entering replan-driven init.`);
+        `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
     }
   }
   if (reviewMax < codeMax) {
@@ -440,6 +502,7 @@ function buildArtifactLinkSection(content: string, artifact: ArtifactIdentity):
 export {
   artifactFamilyCatalog, artifactName, parseArtifactName, familySpec,
   inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext,
+  parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName,
   assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection
 };
 export type {

package/lib/task/artifact-receipts.ts

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+
+import { extractSection, findSectionHeading, parseTable } from './sections.ts';
+
+const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'] as const;
+const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'] as const;
+const RECEIPT_EVENTS = new Set([
+  'review-analysis.completed',
+  'review-plan.completed',
+  'review-code.completed',
+  'code.completed'
+]);
+const SHA256_RE = /^[a-f0-9]{64}$/;
+const ARTIFACT_NAME_RE = /^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r([2-9]|[1-9]\d+))?\.md$/;
+const RECEIPT_SHAPES = {
+  'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
+  'review-plan.completed': { output: 'review-plan', input: 'plan' },
+  'review-code.completed': { output: 'review-code', input: 'code' },
+  'code.completed': { output: 'code', input: 'plan' }
+} as const;
+
+type ArtifactReceiptEvent =
+  | 'review-analysis.completed'
+  | 'review-plan.completed'
+  | 'review-code.completed'
+  | 'code.completed';
+type ArtifactReceipt = {
+  event: ArtifactReceiptEvent;
+  output: string;
+  input: string;
+  inputSha256: string;
+  completedAt: string;
+};
+type ArtifactReceiptParseResult = {
+  present: boolean;
+  rows: readonly ArtifactReceipt[];
+};
+type ReceiptSectionMutation = {
+  aliases: readonly string[];
+  heading: string;
+  body: string;
+};
+
+class ArtifactReceiptError extends Error {
+  readonly code = 'ARTIFACT_RECEIPT_INVALID';
+
+  constructor(message: string) {
+    super(message);
+    this.name = 'ArtifactReceiptError';
+  }
+}
+
+function sha256Bytes(value: Buffer): string {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function sha256File(filePath: string): string {
+  return sha256Bytes(fs.readFileSync(filePath));
+}
+
+function parseReceiptArtifactName(name: string): { family: string } | null {
+  const match = ARTIFACT_NAME_RE.exec(name);
+  if (!match) return null;
+  const roundText = match[2];
+  if (roundText !== undefined) {
+    const round = Number(roundText);
+    if (!Number.isSafeInteger(round) || String(round) !== roundText) return null;
+  }
+  return { family: match[1]! };
+}
+
+function validateReceiptShape(event: ArtifactReceiptEvent, output: string, input: string): void {
+  const outputIdentity = parseReceiptArtifactName(output);
+  const inputIdentity = parseReceiptArtifactName(input);
+  if (!outputIdentity || !inputIdentity) throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
+  const shape = RECEIPT_SHAPES[event];
+  if (outputIdentity.family !== shape.output || inputIdentity.family !== shape.input) {
+    throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
+  }
+}
+
+function parseArtifactReceipts(content: string): ArtifactReceiptParseResult {
+  const section = extractSection(content, [...RECEIPT_SECTION_ALIASES]);
+  if (!section) return { present: false, rows: [] };
+
+  let table;
+  try {
+    table = parseTable(content, {
+      sectionAliases: [...RECEIPT_SECTION_ALIASES],
+      columns: [...RECEIPT_COLUMNS],
+      keyColumn: 'output'
+    });
+  } catch (error) {
+    throw new ArtifactReceiptError(error instanceof Error ? error.message : String(error));
+  }
+  if (!table) throw new ArtifactReceiptError('receipt section has no receipt table');
+
+  const rows = table.rows.map((row) => {
+    const event = row.values.event ?? '';
+    const output = row.values.output ?? '';
+    const input = row.values.input ?? '';
+    const inputSha256 = row.values.input_sha256 ?? '';
+    const completedAt = row.values.completed_at ?? '';
+    if (!RECEIPT_EVENTS.has(event)) throw new ArtifactReceiptError(`unknown receipt event '${event}'`);
+    if (!output || !input) throw new ArtifactReceiptError('receipt output and input are required');
+    validateReceiptShape(event as ArtifactReceiptEvent, output, input);
+    if (!SHA256_RE.test(inputSha256)) throw new ArtifactReceiptError(`receipt digest for '${output}' is invalid`);
+    if (!completedAt || Number.isNaN(Date.parse(completedAt.replace(' ', 'T')))) {
+      throw new ArtifactReceiptError(`receipt completion time for '${output}' is invalid`);
+    }
+    return {
+      event: event as ArtifactReceiptEvent,
+      output,
+      input,
+      inputSha256,
+      completedAt
+    };
+  });
+  return { present: true, rows };
+}
+
+function receiptForOutput(content: string, output: string): ArtifactReceipt | null {
+  const parsed = parseArtifactReceipts(content);
+  return parsed.rows.find((row) => row.output === output) ?? null;
+}
+
+function upsertArtifactReceipt(content: string, receipt: ArtifactReceipt): ReceiptSectionMutation {
+  if (!RECEIPT_EVENTS.has(receipt.event)) throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
+  if (!receipt.output || !receipt.input) throw new ArtifactReceiptError('receipt output and input are required');
+  validateReceiptShape(receipt.event, receipt.output, receipt.input);
+  if (!SHA256_RE.test(receipt.inputSha256)) throw new ArtifactReceiptError(`receipt digest for '${receipt.output}' is invalid`);
+  if (!receipt.completedAt || Number.isNaN(Date.parse(receipt.completedAt.replace(' ', 'T')))) {
+    throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
+  }
+
+  const existing = parseArtifactReceipts(content).rows;
+  const previous = existing.find((row) => row.output === receipt.output);
+  if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) {
+    throw new ArtifactReceiptError(`receipt for '${receipt.output}' already exists with different evidence`);
+  }
+  const rows = previous ? existing : [...existing, receipt];
+  const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
+  const body = [
+    `| ${RECEIPT_COLUMNS.join(' | ')} |`,
+    `| ${RECEIPT_COLUMNS.map(() => '---').join(' | ')} |`,
+    ...rows.map((row) => `| ${row.event} | ${row.output} | ${row.input} | ${row.inputSha256} | ${row.completedAt} |`)
+  ].join('\n');
+  return { aliases: [...RECEIPT_SECTION_ALIASES], heading, body };
+}
+
+export {
+  ArtifactReceiptError,
+  RECEIPT_SECTION_ALIASES,
+  parseArtifactReceipts,
+  receiptForOutput,
+  sha256Bytes,
+  sha256File,
+  upsertArtifactReceipt
+};
+export type { ArtifactReceipt, ArtifactReceiptEvent, ArtifactReceiptParseResult, ReceiptSectionMutation };

package/lib/task/codex-orchestration.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+
 import {
   preflightCodexLifecycleEvidence,
   resolveCodexSpawnedChild,
@@ -5,9 +7,16 @@ import {
   resolveCodexThread
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
+import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
+import type { LifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
+import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
+import { resolveTaskRef } from './resolve-ref.ts';
 import {
   activateMatchingOrchestrationDelegation,
+  hasActivatableOrchestrationDelegation,
+  hasSealableOrchestrationDelegation,
   pauseMatchingOrchestrationDelegation,
   prepareOrchestrationDelegation,
   reconcileMatchingOrchestrationDelegation,
@@ -16,12 +25,15 @@ import {
 import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 
 type LifecycleStore = ReturnType<typeof createCodexLifecycleStore>;
+type CapabilityStore = ReturnType<typeof createCodexCapabilityStore>;
 type CodexBridgeOptions = Readonly<{
   repoRoot?: string;
   store?: LifecycleStore;
   preflight?: typeof preflightCodexLifecycleEvidence;
   resolveThread?: typeof resolveCodexThread;
   resolveTerminal?: typeof resolveCodexTerminal;
+  capabilityStore?: CapabilityStore;
+  buildIdentity?: LifecycleBuildIdentity;
   orchestrationOptions?: OrchestrationOptions;
 }>;
 
@@ -59,25 +71,68 @@ function requiredStore(options: CodexBridgeOptions): LifecycleStore {
   return options.store;
 }
 
+function controllerContext(taskId: string, repoRoot: string) {
+  const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+  return contextPath
+    ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
+    : null;
+}
+
 async function prepareCodexOrchestrationDelegation(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
     requestedModel?: string;
     requestedReasoningEffort?: string;
+    capabilityToken?: string;
   }>,
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   if (input.client !== 'codex') return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
   try {
-    await (options.preflight ?? preflightCodexLifecycleEvidence)(options.repoRoot ?? process.cwd());
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const resolved = resolveTaskRef(taskRef, { repoRoot });
+    if (!resolved.ok) return bridgeFailure(resolved.code, resolved.message);
+    const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+    if (!input.capabilityToken) {
+      return bridgeFailure(
+        'ORCHESTRATION_CODEX_CAPABILITY_REQUIRED',
+        'Codex prepare requires a current-session capability token'
+      );
+    }
+    const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+    const controller = controllerContext(resolved.taskId, repoRoot);
+    const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
+    const consumed = capabilityStore.consume(input.capabilityToken, {
+      taskId: resolved.taskId,
+      hookDefinitionHash: preflight.hookDefinitionHash,
+      buildIdentity,
+      ...(controller ? { controller: {
+        instanceDigest: controller.controllerInstanceDigest,
+        controlGeneration: controller.controlGeneration
+      } } : {})
+    });
+    return prepareOrchestrationDelegation(taskRef, {
+      ...input,
+      lifecycleProvenance: {
+        ...consumed.buildIdentity,
+        hookDefinitionHash: preflight.hookDefinitionHash,
+        ...preflight.hookProvenance,
+        capabilitySessionId: consumed.sessionId!,
+        capabilityTurnId: consumed.turnId!,
+        capabilityToolUseId: consumed.toolUseId!,
+        controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+        controlGeneration: controller?.controlGeneration ?? null
+      }
+    }, coreOptions(options));
   } catch (error) {
     return bridgeFailure(
-      'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
+      error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+        ? error.name
+        : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
       error instanceof Error ? error.message : String(error)
     );
   }
-  return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
 }
 
 async function activateCodexOrchestrationDelegation(
@@ -85,6 +140,9 @@ async function activateCodexOrchestrationDelegation(
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   try {
+    if (!hasActivatableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+      return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+    }
     const store = requiredStore(options);
     const resolved = await (options.resolveThread ?? resolveCodexThread)(childThreadId);
     store.apply(resolved.resolution.thread);
@@ -95,6 +153,23 @@ async function activateCodexOrchestrationDelegation(
     if (record.state.status !== 'start-ready' || !evidence) {
       return pauseBridge('ORCHESTRATION_CODEX_START_EVIDENCE_INVALID', 'Codex lifecycle start evidence is not ready', options);
     }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot, {
+      sessionId: evidence.parentThreadId,
+      turnId: evidence.parentTurnId,
+      toolUseId: evidence.spawnToolUseId
+    });
+    const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    const contextTaskId = contextPath
+      ? (JSON.parse(fs.readFileSync(contextPath, 'utf8')) as { taskId?: unknown }).taskId
+      : null;
+    if (contextPath && typeof contextTaskId !== 'string') {
+      throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    const controller = contextPath
+      ? verifyCodexSandboxControllerContext(contextPath, contextTaskId as string, { repoRoot })
+      : null;
     return activateMatchingOrchestrationDelegation('codex', {
       nativeAgent: evidence.nativeAgent,
       childId: evidence.childThreadId,
@@ -107,9 +182,17 @@ async function activateCodexOrchestrationDelegation(
         ? { reasoningEffortFallbackReason: evidence.reasoningEffortFallbackReason }
         : {}),
       hostEvidence: {
-        kind: 'codex-lifecycle-v1',
+        kind: 'codex-lifecycle-v2',
         hookDefinitionHash: evidence.hookDefinitionHash,
-        startRevision: record.revision
+        startRevision: record.revision,
+        ...buildIdentity,
+        ...preflight.hookProvenance,
+        capabilitySessionId: evidence.parentThreadId,
+        capabilityTurnId: evidence.parentTurnId,
+        spawnToolUseId: evidence.spawnToolUseId,
+        spawnObservedAt: record.spawnObservedAt ?? undefined,
+        controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+        controlGeneration: controller?.controlGeneration ?? null
       }
     }, coreOptions(options));
   } catch (error) {
@@ -149,6 +232,9 @@ async function sealCodexOrchestrationDelegation(
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   try {
+    if (!hasSealableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+      return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+    }
     const store = requiredStore(options);
     const existing = store.read(childThreadId);
     if (!existing.consumer) {

package/lib/task/commands/validate.ts

@@ -169,7 +169,7 @@ function inplaceValidation(config: ReturnType<typeof loadConfig>, target: Return
   const nonce = randomUUID();
   const issuedAt = Date.now();
   const lease: SandboxControlLease = {
-    version: 1, generation: manifest.generation, nonce,
+    version: 2, generation: manifest.generation, nonce,
     owner: { pid: process.pid, startTime }, issuedAt,
     expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
     taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,

package/lib/task/create.ts

@@ -231,6 +231,14 @@ function assertRealDirectory(directory: string, code: string): void {
   if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(code);
 }
 
+function ensureRealDirectory(directory: string, code: string): void {
+  if (fs.existsSync(directory)) {
+    assertRealDirectory(directory, code);
+    return;
+  }
+  fs.mkdirSync(directory, { mode: 0o700 });
+}
+
 function withCreateLock<T>(repoRoot: string, workspaceRoot: string, operation: () => T): T {
   const lockRoot = path.join(workspaceRoot, '.task-create.lock');
   fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
@@ -289,8 +297,9 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   const repoRoot = fs.realpathSync.native(options.repoRoot);
   const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
   const activeRoot = path.join(workspaceRoot, 'active');
-  assertRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-  assertRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   const project = readProject(repoRoot);
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);