@fitlab-ai/agent-infra 0.11.5 → 0.11.7

package/dist/lib/task/artifact-receipts.js

@@ -5,17 +5,21 @@ import { extractSection, findSectionHeading, parseTable } from './sections.js';
 const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'];
 const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'];
 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' }
 };
 class ArtifactReceiptError extends Error {
     code = 'ARTIFACT_RECEIPT_INVALID';
@@ -37,8 +41,16 @@ function validateReceiptShape(event, output, input) {
         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}`);
     }
@@ -52,7 +64,9 @@ function parseArtifactReceipts(content) {
         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) {
@@ -84,29 +98,55 @@ function parseArtifactReceipts(content) {
             completedAt
         };
     });
+    const edges = new Set();
+    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, output) {
+    return parseArtifactReceipts(content).rows.filter((row) => row.output === output);
+}
 function receiptForOutput(content, output) {
-    const parsed = parseArtifactReceipts(content);
-    return parsed.rows.find((row) => row.output === output) ?? null;
+    return receiptsForOutput(content, output)[0] ?? null;
 }
 function upsertArtifactReceipt(content, receipt) {
-    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`);
+    return upsertArtifactReceipts(content, [receipt]);
+}
+function upsertArtifactReceipts(content, receiptsToAdd) {
+    if (receiptsToAdd.length === 0)
+        throw new ArtifactReceiptError('at least one receipt is required');
+    const additions = new Map();
+    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);
+        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 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(' | ')} |`,
@@ -115,5 +155,5 @@ function upsertArtifactReceipt(content, receipt) {
     ].join('\n');
     return { aliases: [...RECEIPT_SECTION_ALIASES], heading, body };
 }
-export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, sha256Bytes, sha256File, upsertArtifactReceipt };
+export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, receiptsForOutput, sha256Bytes, sha256File, upsertArtifactReceipt, upsertArtifactReceipts };
 //# sourceMappingURL=artifact-receipts.js.map

package/dist/lib/task/capabilities.js

@@ -12,6 +12,8 @@ import { hasOpenLifecycleExecution } from './activity-log.js';
 import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
 import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.js';
 import { parseImplementationInputs } from './implementation-inputs.js';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { inspectReviewIdentity } from './review-identity.js';
 const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 const REASONS = new Set([
     'user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'
@@ -139,13 +141,15 @@ function canStart(action, facts, trigger) {
         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'))
+        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)
@@ -309,7 +313,13 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                     continue;
                 }
                 const audit = parseQualificationAudit(auditContent);
-                if (!audit.ok || !audit.audit.present || !audit.audit.snapshot) {
+                if (!audit.ok) {
+                    qualificationStaleArtifacts.push(name);
+                    continue;
+                }
+                if (!audit.audit.present)
+                    continue;
+                if (!audit.audit.snapshot) {
                     qualificationStaleArtifacts.push(name);
                     continue;
                 }
@@ -324,6 +334,7 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         }
         const reviews = {};
         const reviewedInputs = {};
+        let reviewCodeIdentityValid = false;
         for (const family of ['review-analysis', 'review-plan', 'review-code']) {
             const latest = latestArtifact(artifacts[family] ?? []);
             if (!latest)
@@ -337,6 +348,12 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                 && (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;
@@ -407,7 +424,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             qualificationStaleArtifacts,
             pathState,
             reworkClassificationRequired,
-            resolvedHumanDecisions
+            resolvedHumanDecisions,
+            reviewCodeIdentityValid
         };
         facts.recommendedAction = recommendNext(facts).action;
         return { ok: true, facts };

package/dist/lib/task/completion-facts.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import { canonicalSemanticDigest } from './artifact-operations.js';
+import { inspectActivityLog } from './activity-log.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { parseArtifactName } from './artifact-name.js';
+import { sha256File } from './artifact-receipts.js';
+export function parseCompletionFacts(value) {
+    if (typeof value !== 'string')
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((fact) => Boolean(fact && typeof fact === 'object' && !Array.isArray(fact)
+            && typeof fact.event === 'string'
+            && typeof fact.output === 'string'
+            && /^[a-f0-9]{64}$/u.test(fact.outputSha256)
+            && /^[a-f0-9]{64}$/u.test(fact.semanticDigest)
+            && typeof fact.requestId === 'string'
+            && typeof fact.result === 'string'));
+    }
+    catch {
+        return [];
+    }
+}
+export function hasArtifactCompletionFact(taskContent, artifactPath, event) {
+    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, artifact, event) {
+    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}`));
+}
+//# sourceMappingURL=completion-facts.js.map

package/dist/lib/task/create-service.js

@@ -48,9 +48,10 @@ export function parseTaskCreateResult(value) {
     if (!['applied', 'no-op', 'degraded', 'failed', 'blocked'].includes(result.status)
         || typeof result.changed !== 'boolean'
         || !result.task || typeof result.task !== 'object' || Array.isArray(result.task)
-        || !exactKeys(result.task, ['id', 'shortId'])
+        || !exactKeys(result.task, ['id', 'shortId', 'state'])
         || !validTaskReference(result.task.id)
         || !validTaskReference(result.task.shortId)
+        || ![null, 'active', 'blocked', 'completed', 'archive'].includes(result.task.state)
         || !Array.isArray(result.operations)
         || !result.operations.every((operation) => {
             if (!operation || typeof operation !== 'object' || Array.isArray(operation))
@@ -93,7 +94,7 @@ export function taskCreateFailure(error, control) {
     return {
         status: error.retryable ? 'blocked' : 'failed',
         changed: false,
-        task: { id: null, shortId: null },
+        task: { id: null, shortId: null, state: null },
         issue: null,
         operations: [],
         warnings: [],
@@ -156,6 +157,9 @@ async function createTask(value, options) {
     const operations = [{
             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 = null;
     const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
     operations.push(...platformOperations('platform-create', created.operations));

package/dist/lib/task/create.js

@@ -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.js';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
@@ -7,6 +8,8 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.js';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.js';
+import { enumerateAllTaskDirs } from './resolve-ref.js';
+import { parseTaskFrontmatter } from './frontmatter.js';
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'];
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'];
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'];
@@ -292,10 +295,27 @@ function ensureRealDirectory(directory, code) {
     }
     fs.mkdirSync(directory, { mode: 0o700 });
 }
-function withCreateLock(repoRoot, workspaceRoot, operation) {
-    const lockRoot = path.join(workspaceRoot, '.task-create.lock');
-    fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
-    assertRealDirectory(lockRoot, 'TASK_CREATE_LOCK_FAILED');
+function createLockRoot(project) {
+    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.code !== 'EEXIST')
+                throw error;
+            assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
+        }
+    }
+    return directories.at(-1);
+}
+function withCreateLock(repoRoot, project, operation) {
+    const lockRoot = createLockRoot(project);
     let callbackError;
     try {
         return withTaskExecutionLock(repoRoot, 'task-create', 'task-create', () => {
@@ -306,7 +326,7 @@ function withCreateLock(repoRoot, workspaceRoot, operation) {
                 callbackError = error;
                 throw error;
             }
-        }, { lockRoot });
+        }, { lockRoot, identityScope: `task-create\0${project}` });
     }
     catch (error) {
         if (callbackError !== undefined)
@@ -318,45 +338,24 @@ function withCreateLock(repoRoot, workspaceRoot, operation) {
         throw new Error(`TASK_CREATE_LOCK_FAILED: ${message}`);
     }
 }
-function writeReceipt(receiptPath, value) {
-    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, repoRoot, keyDigest, candidateDigest) {
-    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, keyDigest, candidateDigest) {
+    for (const task of enumerateAllTaskDirs(repoRoot)) {
+        const taskMd = path.join(task.taskDir, 'task.md');
         const taskStat = fs.lstatSync(taskMd);
         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;
-        const content = fs.readFileSync(taskMd, 'utf8');
-        if (!content.includes(`task_create_key_digest: ${keyDigest}`))
-            continue;
-        if (!content.includes(`task_create_candidate_digest: ${candidateDigest}`)) {
+        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;
 }
@@ -376,30 +375,10 @@ function createLocalTask(value, options) {
     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'));
-            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();
         let taskDate = new Date(base.getTime());
@@ -418,32 +397,17 @@ function createLocalTask(value, options) {
             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;
-        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' } };
     });
 }
 export { canonicalTaskCreateCandidate, createLocalTask, validateTaskCreateCandidate };