@fitlab-ai/agent-infra 0.11.6 → 0.11.7

package/lib/task/artifact-receipts.ts

@@ -7,24 +7,30 @@ 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([
+  'analysis.completed',
+  'plan.completed',
   'review-analysis.completed',
   'review-plan.completed',
+  'code.completed',
   'review-code.completed',
-  'code.completed'
 ]);
 const SHA256_RE = /^[a-f0-9]{64}$/;
 const RECEIPT_SHAPES = {
+  'analysis.completed': { output: 'analysis', input: 'review-analysis' },
+  'plan.completed': { output: 'plan', input: 'analysis' },
   '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' }
+  'code.completed': { output: 'code', input: 'plan' },
+  'review-code.completed': { output: 'review-code', input: 'code' }
 } as const;
 
 type ArtifactReceiptEvent =
+  | 'analysis.completed'
+  | 'plan.completed'
   | 'review-analysis.completed'
   | 'review-plan.completed'
-  | 'review-code.completed'
-  | 'code.completed';
+  | 'code.completed'
+  | 'review-code.completed';
 type ArtifactReceipt = {
   event: ArtifactReceiptEvent;
   output: string;
@@ -65,8 +71,16 @@ function validateReceiptShape(event: ArtifactReceiptEvent, output: string, input
   if (!outputIdentity || !inputIdentity) throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
   const shape = RECEIPT_SHAPES[event];
   const inputMatches = event === 'code.completed'
-    ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan'
-    : inputIdentity.family === shape.input;
+    ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan' || inputIdentity.family === 'review-code'
+    : event === 'plan.completed'
+      ? inputIdentity.family === 'analysis' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan'
+      : event === 'analysis.completed'
+        ? inputIdentity.family === 'review-analysis'
+        : event === 'review-plan.completed'
+          ? inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis'
+          : event === 'review-code.completed'
+            ? inputIdentity.family === 'code' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-plan'
+        : inputIdentity.family === shape.input;
   if (outputIdentity.family !== shape.output || !inputMatches) {
     throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
   }
@@ -81,7 +95,9 @@ function parseArtifactReceipts(content: string): ArtifactReceiptParseResult {
     table = parseTable(content, {
       sectionAliases: [...RECEIPT_SECTION_ALIASES],
       columns: [...RECEIPT_COLUMNS],
-      keyColumn: 'output'
+      // A completed artifact can have multiple lifecycle inputs. Pair
+      // uniqueness is checked below because the table parser supports one key.
+      keyColumn: null
     });
   } catch (error) {
     throw new ArtifactReceiptError(error instanceof Error ? error.message : String(error));
@@ -109,15 +125,31 @@ function parseArtifactReceipts(content: string): ArtifactReceiptParseResult {
       completedAt
     };
   });
+  const edges = new Set<string>();
+  for (const row of rows) {
+    const edge = `${row.output}\0${row.input}`;
+    if (edges.has(edge)) throw new ArtifactReceiptError(`duplicate receipt edge '${row.output}' <- '${row.input}'`);
+    edges.add(edge);
+  }
   return { present: true, rows };
 }
 
+function receiptsForOutput(content: string, output: string): readonly ArtifactReceipt[] {
+  return parseArtifactReceipts(content).rows.filter((row) => row.output === output);
+}
+
 function receiptForOutput(content: string, output: string): ArtifactReceipt | null {
-  const parsed = parseArtifactReceipts(content);
-  return parsed.rows.find((row) => row.output === output) ?? null;
+  return receiptsForOutput(content, output)[0] ?? null;
 }
 
 function upsertArtifactReceipt(content: string, receipt: ArtifactReceipt): ReceiptSectionMutation {
+  return upsertArtifactReceipts(content, [receipt]);
+}
+
+function upsertArtifactReceipts(content: string, receiptsToAdd: readonly ArtifactReceipt[]): ReceiptSectionMutation {
+  if (receiptsToAdd.length === 0) throw new ArtifactReceiptError('at least one receipt is required');
+  const additions = new Map<string, ArtifactReceipt>();
+  for (const receipt of receiptsToAdd) {
   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);
@@ -126,12 +158,18 @@ function upsertArtifactReceipt(content: string, receipt: ArtifactReceipt): Recei
     throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
   }
 
+    const key = `${receipt.output}\0${receipt.input}`;
+    const duplicate = additions.get(key);
+    if (duplicate && JSON.stringify(duplicate) !== JSON.stringify(receipt)) throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' has conflicting evidence`);
+    additions.set(key, receipt);
+  }
   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`);
+  for (const receipt of additions.values()) {
+    const previous = existing.find((row) => row.output === receipt.output && row.input === receipt.input);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' already exists with different evidence`);
   }
-  const rows = previous ? existing : [...existing, receipt];
+  const rows = [...existing];
+  for (const receipt of additions.values()) if (!rows.some((row) => row.output === receipt.output && row.input === receipt.input)) rows.push(receipt);
   const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
   const body = [
     `| ${RECEIPT_COLUMNS.join(' | ')} |`,
@@ -146,8 +184,10 @@ export {
   RECEIPT_SECTION_ALIASES,
   parseArtifactReceipts,
   receiptForOutput,
+  receiptsForOutput,
   sha256Bytes,
   sha256File,
-  upsertArtifactReceipt
+  upsertArtifactReceipt,
+  upsertArtifactReceipts
 };
 export type { ArtifactReceipt, ArtifactReceiptEvent, ArtifactReceiptParseResult, ReceiptSectionMutation };

package/lib/task/capabilities.ts

@@ -17,6 +17,8 @@ import type { QualificationAudit, TaskQualification } from './qualification-audi
 import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.ts';
 import type { LifecyclePathState } from './lifecycle-path.ts';
 import { parseImplementationInputs } from './implementation-inputs.ts';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.ts';
+import { inspectReviewIdentity } from './review-identity.ts';
 
 const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 
@@ -55,6 +57,7 @@ type LifecycleFacts = {
   pathState?: LifecyclePathState;
   reworkClassificationRequired?: readonly ('analysis' | 'plan' | 'code')[];
   resolvedHumanDecisions?: Partial<Record<'analysis' | 'plan' | 'code', 'review' | 'implementation'>>;
+  reviewCodeIdentityValid?: boolean;
 };
 type CapabilityResult = {
   allowed: boolean;
@@ -176,11 +179,12 @@ function canStart(action: LifecycleAction, facts: LifecycleFacts, trigger: Expli
     return allow('plan-review-approved');
   }
   if (action === 'review-code') {
-    return hasArtifact(facts, 'code') ? allow('code-artifact') : deny('CODE_ARTIFACT_REQUIRED');
+    return allow(hasArtifact(facts, 'code') ? 'optional-code-context' : 'review-current-git-diff');
   }
   if (action === 'manual-validation' || action === 'validation-run') {
     if (!hasArtifact(facts, 'review-code')) return deny('CODE_REVIEW_REQUIRED');
-    if (!reviewMatchesLatest(facts, 'code', 'review-code')) return deny('CODE_REVIEW_NOT_LATEST');
+    if (hasArtifact(facts, 'code') && !reviewMatchesLatest(facts, 'code', 'review-code')) return deny('CODE_REVIEW_NOT_LATEST');
+    if (!facts.reviewCodeIdentityValid) return deny('CODE_REVIEW_IDENTITY_INVALID');
     if (facts.reviews['review-code'] !== 'approved') return deny('CODE_REVIEW_NOT_APPROVED');
     if (facts.unresolvedLedger.code > 0) return deny('CODE_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.code}`);
     return allow('code-review-approved');
@@ -334,7 +338,9 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
         try { auditContent = fs.readFileSync(path.join(taskDir, name), 'utf8'); }
         catch { qualificationStaleArtifacts.push(name); continue; }
         const audit = parseQualificationAudit(auditContent);
-        if (!audit.ok || !audit.audit.present || !audit.audit.snapshot) { qualificationStaleArtifacts.push(name); continue; }
+        if (!audit.ok) { qualificationStaleArtifacts.push(name); continue; }
+        if (!audit.audit.present) continue;
+        if (!audit.audit.snapshot) { qualificationStaleArtifacts.push(name); continue; }
         const constraintsChanged = audit.audit.constraintDependencies.some((dependency) => constraints.get(dependency.constraintId) !== dependency.constraintDigest);
         const taskInputChanged = audit.audit.snapshot.taskInputDigest !== qualification.qualification.taskInputDigest;
         if (audit.audit.snapshot.nonConstraintInputDigest !== qualification.qualification.nonConstraintInputDigest
@@ -345,6 +351,7 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
     }
     const reviews: LifecycleFacts['reviews'] = {};
     const reviewedInputs: NonNullable<LifecycleFacts['reviewedInputs']> = {};
+    let reviewCodeIdentityValid = false;
     for (const family of ['review-analysis', 'review-plan', 'review-code'] as const) {
       const latest = latestArtifact(artifacts[family] ?? []);
       if (!latest) continue;
@@ -358,6 +365,12 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
         && (artifacts[expectedFamily] ?? []).includes(input)
         && artifactHashes[input] === receipt.inputSha256
       ) reviewedInputs[family] = input;
+      if (family === 'review-code') {
+        const identity = inspectReviewIdentity(taskDir, reviewContent);
+        reviewCodeIdentityValid = identity.status === 'matched'
+          && hasArtifactCompletionFact(content, path.join(taskDir, latest), 'review-code.completed')
+          && hasArtifactCompletionLog(content, latest, 'review-code.completed');
+      }
       const parsed = parseReviewSummary(reviewContent);
       if (!parsed.ok) continue;
       const verdict = resolveCanonicalVerdict(parsed.summary);
@@ -423,6 +436,7 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       , pathState
       , reworkClassificationRequired
       , resolvedHumanDecisions
+      , reviewCodeIdentityValid
     };
     facts.recommendedAction = recommendNext(facts).action;
     return { ok: true, facts };

package/lib/task/completion-facts.ts

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+
+import { canonicalSemanticDigest } from './artifact-operations.ts';
+import { inspectActivityLog } from './activity-log.ts';
+import { parseTypedTaskFrontmatter } from './frontmatter.ts';
+import { parseArtifactName } from './artifact-name.ts';
+import { sha256File } from './artifact-receipts.ts';
+
+export type CompletionFact = Readonly<{
+  event: string;
+  output: string;
+  outputSha256: string;
+  semanticDigest: string;
+  requestId: string;
+  result: string;
+  lifecycleInputs?: readonly Readonly<{ name: string; sha256: string }>[];
+}>;
+
+export function parseCompletionFacts(value: unknown): CompletionFact[] {
+  if (typeof value !== 'string') return [];
+  try {
+    const parsed: unknown = JSON.parse(value);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((fact): fact is CompletionFact => Boolean(
+      fact && typeof fact === 'object' && !Array.isArray(fact)
+      && typeof (fact as CompletionFact).event === 'string'
+      && typeof (fact as CompletionFact).output === 'string'
+      && /^[a-f0-9]{64}$/u.test((fact as CompletionFact).outputSha256)
+      && /^[a-f0-9]{64}$/u.test((fact as CompletionFact).semanticDigest)
+      && typeof (fact as CompletionFact).requestId === 'string'
+      && typeof (fact as CompletionFact).result === 'string'
+    ));
+  } catch {
+    return [];
+  }
+}
+
+export function hasArtifactCompletionFact(taskContent: string, artifactPath: string, event: string): boolean {
+  try {
+    const frontmatter = parseTypedTaskFrontmatter(taskContent);
+    const output = artifactPath.split(/[\\/]/u).at(-1) ?? '';
+    const content = fs.readFileSync(artifactPath, 'utf8');
+    const outputSha256 = sha256File(artifactPath);
+    const semanticDigest = canonicalSemanticDigest(content);
+    return parseCompletionFacts(frontmatter.completion_facts).some((fact) =>
+      fact.event === event && fact.output === output
+      && fact.outputSha256 === outputSha256 && fact.semanticDigest === semanticDigest
+      && fact.requestId.length > 0
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function hasArtifactCompletionLog(taskContent: string, artifact: string, event: string): boolean {
+  const identity = parseArtifactName(artifact);
+  if (!identity) return false;
+  const action = event === 'review-code.completed' ? 'Review Code'
+    : event === 'review-plan.completed' ? 'Review Plan'
+      : event === 'review-analysis.completed' ? 'Review Analysis' : null;
+  if (!action) return false;
+  const { section, invalidEntries } = inspectActivityLog(taskContent);
+  if (!section || invalidEntries.length > 0) return false;
+  const expected = `${action} (Round ${identity.round})`;
+  return section.entries.some((entry) => entry.step === expected && entry.note.includes(`→ ${artifact}`));
+}

package/lib/task/create-service.ts

@@ -19,7 +19,7 @@ type TaskCreateError = { code: string; message: string; retryable: boolean };
 type TaskCreateResult = Readonly<{
   status: TaskCreateStatus;
   changed: boolean;
-  task: { id: string | null; shortId: string | null };
+  task: { id: string | null; shortId: string | null; state: 'active' | 'blocked' | 'completed' | 'archive' | null };
   issue: { number: number; url: string } | null;
   operations: readonly TaskCreateOperation[];
   warnings: readonly TaskCreateWarning[];
@@ -87,9 +87,10 @@ export function parseTaskCreateResult(value: unknown): TaskCreateResult {
   if (!['applied', 'no-op', 'degraded', 'failed', 'blocked'].includes(result.status as string)
     || typeof result.changed !== 'boolean'
     || !result.task || typeof result.task !== 'object' || Array.isArray(result.task)
-    || !exactKeys(result.task as Record<string, unknown>, ['id', 'shortId'])
+    || !exactKeys(result.task as Record<string, unknown>, ['id', 'shortId', 'state'])
     || !validTaskReference((result.task as { id?: unknown }).id)
     || !validTaskReference((result.task as { shortId?: unknown }).shortId)
+    || ![null, 'active', 'blocked', 'completed', 'archive'].includes((result.task as { state?: unknown }).state as string | null)
     || !Array.isArray(result.operations)
     || !result.operations.every((operation) => {
       if (!operation || typeof operation !== 'object' || Array.isArray(operation)) return false;
@@ -136,7 +137,7 @@ export function taskCreateFailure(
   return {
     status: error.retryable ? 'blocked' : 'failed',
     changed: false,
-    task: { id: null, shortId: null },
+    task: { id: null, shortId: null, state: null },
     issue: null,
     operations: [],
     warnings: [],
@@ -206,6 +207,9 @@ async function createTask(value: unknown, options: CreateTaskOptions): Promise<T
   const operations: TaskCreateOperation[] = [{
     name: 'task:local', status: local.status, reasonCode: null
   }];
+  if (local.status === 'no-op' && local.task.state !== 'active') {
+    return { status: 'no-op', changed: false, task: local.task, issue: null, operations, warnings: [], error: null };
+  }
   let issue: TaskCreateResult['issue'] = null;
   const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
   operations.push(...platformOperations('platform-create', created.operations));

package/lib/task/create.ts

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 import { isValidAgentInfraVersion, VERSION } from '../version.ts';
@@ -8,6 +9,8 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.ts';
+import { enumerateAllTaskDirs } from './resolve-ref.ts';
+import { parseTaskFrontmatter } from './frontmatter.ts';
 
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'] as const;
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'] as const;
@@ -41,7 +44,7 @@ type TaskCreateCandidateV1 = Readonly<{
 type LocalTaskCreateResult = Readonly<{
   status: 'applied' | 'no-op';
   changed: boolean;
-  task: { id: string; shortId: string };
+  task: { id: string; shortId: string | null; state: 'active' | 'blocked' | 'completed' | 'archive' };
 }>;
 
 type LocalTaskCreateOptions = Readonly<{
@@ -345,16 +348,32 @@ function ensureRealDirectory(directory: string, code: string): void {
   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 });
-  assertRealDirectory(lockRoot, 'TASK_CREATE_LOCK_FAILED');
+function createLockRoot(project: string): string {
+  const root = path.join(os.homedir(), '.agent-infra');
+  const directories = [root, path.join(root, 'run'), path.join(root, 'run', project), path.join(root, 'run', project, 'task-create-locks')];
+  for (const directory of directories) {
+    if (fs.existsSync(directory)) {
+      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
+      continue;
+    }
+    try {
+      fs.mkdirSync(directory, { mode: 0o700 });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
+    }
+  }
+  return directories.at(-1)!;
+}
+
+function withCreateLock<T>(repoRoot: string, project: string, operation: () => T): T {
+  const lockRoot = createLockRoot(project);
   let callbackError: unknown;
   try {
     return withTaskExecutionLock(repoRoot, 'task-create', 'task-create', () => {
       try { return operation(); }
       catch (error) { callbackError = error; throw error; }
-    }, { lockRoot });
+    }, { lockRoot, identityScope: `task-create\0${project}` });
   } catch (error) {
     if (callbackError !== undefined) throw callbackError;
     if (error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY') {
@@ -365,35 +384,21 @@ function withCreateLock<T>(repoRoot: string, workspaceRoot: string, operation: (
   }
 }
 
-function writeReceipt(receiptPath: string, value: unknown): void {
-  const temporary = `${receiptPath}.tmp.${process.pid}.${randomUUID()}`;
-  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { flag: 'wx', mode: 0o600 });
-  try { fs.renameSync(temporary, receiptPath); }
-  catch (error) {
-    try { fs.unlinkSync(temporary); } catch { /* best effort */ }
-    throw error;
-  }
-}
-
-function recoverPublishedTask(activeRoot: string, repoRoot: string, keyDigest: string, candidateDigest: string): { taskId: string; shortId: string } | null {
-  for (const name of fs.readdirSync(activeRoot)) {
-    if (!/^TASK-\d{8}-\d{6}$/.test(name)) continue;
-    const taskDir = path.join(activeRoot, name);
-    const stat = fs.lstatSync(taskDir);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
-    const taskMd = path.join(taskDir, 'task.md');
-    if (!fs.existsSync(taskMd)) continue;
+function recoverPublishedTask(repoRoot: string, keyDigest: string, candidateDigest: string): { taskId: string; shortId: string | null; state: 'active' | 'blocked' | 'completed' | 'archive' } | null {
+  for (const task of enumerateAllTaskDirs(repoRoot)) {
+    const taskMd = path.join(task.taskDir, 'task.md');
     const taskStat = fs.lstatSync(taskMd);
-    if (!taskStat.isFile() || taskStat.isSymbolicLink()) continue;
-    const content = fs.readFileSync(taskMd, 'utf8');
-    if (!content.includes(`task_create_key_digest: ${keyDigest}`)) continue;
-    if (!content.includes(`task_create_candidate_digest: ${candidateDigest}`)) {
+    if (!taskStat.isFile() || taskStat.isSymbolicLink()) throw new Error('TASK_CREATE_TASK_INVALID');
+    const frontmatter = parseTaskFrontmatter(fs.readFileSync(taskMd, 'utf8'));
+    if (frontmatter.task_create_key_digest !== keyDigest) continue;
+    if (frontmatter.task_create_candidate_digest !== candidateDigest) {
       throw new Error('TASK_CREATE_IDEMPOTENCY_CONFLICT');
     }
-    const shortId = loadShortIdByTaskId(repoRoot).get(name)
-      ?? mutateShortIdRegistry(repoRoot, name, 'alloc').shortId;
-    if (!shortId) throw new Error('TASK_CREATE_RECEIPT_INVALID');
-    return { taskId: name, shortId };
+    const shortId = task.state === 'active'
+      ? loadShortIdByTaskId(repoRoot).get(task.taskId) ?? mutateShortIdRegistry(repoRoot, task.taskId, 'alloc').shortId
+      : null;
+    if (task.state === 'active' && !shortId) throw new Error('TASK_CREATE_SHORT_ID_FAILED');
+    return { taskId: task.taskId, shortId, state: task.state };
   }
   return null;
 }
@@ -414,29 +419,10 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);
   const keyDigest = sha256(candidate.idempotencyKey);
-  const receipts = path.join(workspaceRoot, '.task-create');
-
-  return withCreateLock(repoRoot, workspaceRoot, () => {
-    if (fs.existsSync(receipts)) assertRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
-    const receiptPath = path.join(receipts, `${keyDigest}.json`);
-    if (fs.existsSync(receiptPath)) {
-      const stat = fs.lstatSync(receiptPath);
-      if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('TASK_CREATE_RECEIPT_INVALID');
-      const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8')) as { candidateDigest?: string; taskId?: string; shortId?: string };
-      if (receipt.candidateDigest !== candidateDigest) throw new Error('TASK_CREATE_IDEMPOTENCY_CONFLICT');
-      if (!receipt.taskId || !receipt.shortId || !fs.existsSync(path.join(activeRoot, receipt.taskId, 'task.md'))) {
-        throw new Error('TASK_CREATE_RECEIPT_INVALID');
-      }
-      return { status: 'no-op', changed: false, task: { id: receipt.taskId, shortId: receipt.shortId } };
-    }
-
-    const recovered = recoverPublishedTask(activeRoot, repoRoot, keyDigest, candidateDigest);
+  return withCreateLock(repoRoot, projectConfig.project, () => {
+    const recovered = recoverPublishedTask(repoRoot, keyDigest, candidateDigest);
     if (recovered) {
-      ensureRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
-      writeReceipt(receiptPath, {
-        version: 1, candidateDigest, taskId: recovered.taskId, shortId: recovered.shortId, status: 'recovered'
-      });
-      return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId } };
+      return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId, state: recovered.state } };
     }
 
     const base = options.now?.() ?? new Date();
@@ -455,29 +441,16 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
       agentInfraVersion, keyDigest, candidateDigest
     });
     validateRenderedQualification(rendered, candidate);
-    ensureRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
     const temporary = path.join(workspaceRoot, `.task-create.tmp.${process.pid}.${randomUUID()}`);
     fs.mkdirSync(temporary, { mode: 0o700 });
     fs.writeFileSync(path.join(temporary, 'task.md'), rendered, { flag: 'wx', mode: 0o600 });
     const destination = path.join(activeRoot, taskId);
     fs.renameSync(temporary, destination);
     let shortId: string;
-    try {
-      const allocated = mutateShortIdRegistry(repoRoot, taskId, 'alloc');
-      if (!allocated.shortId) throw new Error('TASK_CREATE_SHORT_ID_FAILED');
-      shortId = allocated.shortId;
-    } catch (error) {
-      fs.rmSync(destination, { recursive: true, force: true });
-      throw error;
-    }
-    try {
-      writeReceipt(receiptPath, { version: 1, candidateDigest, taskId, shortId, status: 'created' });
-    } catch (error) {
-      mutateShortIdRegistry(repoRoot, taskId, 'release');
-      fs.rmSync(destination, { recursive: true, force: true });
-      throw error;
-    }
-    return { status: 'applied', changed: true, task: { id: taskId, shortId } };
+    const allocated = mutateShortIdRegistry(repoRoot, taskId, 'alloc');
+    if (!allocated.shortId) throw new Error('TASK_CREATE_SHORT_ID_FAILED');
+    shortId = allocated.shortId;
+    return { status: 'applied', changed: true, task: { id: taskId, shortId, state: 'active' } };
   });
 }