@fitlab-ai/agent-infra 0.11.6 → 0.11.8

package/dist/lib/task/create.js

@@ -1,12 +1,15 @@
 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';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
+import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 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);
+    function createUnderRepositoryLock() {
+        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,34 @@ 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;
-        }
+        const allocated = mutateShortIdRegistry(repoRoot, taskId, 'alloc');
+        if (!allocated.shortId)
+            throw new Error('TASK_CREATE_SHORT_ID_FAILED');
+        return { status: 'applied', changed: true, task: { id: taskId, shortId: allocated.shortId, state: 'active' } };
+    }
+    return withCreateLock(repoRoot, projectConfig.project, () => {
+        let callbackError;
         try {
-            writeReceipt(receiptPath, { version: 1, candidateDigest, taskId, shortId, status: 'created' });
+            return withRepositoryMutationLock(repoRoot, () => {
+                try {
+                    return createUnderRepositoryLock();
+                }
+                catch (error) {
+                    callbackError = error;
+                    throw error;
+                }
+            });
         }
         catch (error) {
-            mutateShortIdRegistry(repoRoot, taskId, 'release');
-            fs.rmSync(destination, { recursive: true, force: true });
+            if (callbackError !== undefined)
+                throw callbackError;
             throw error;
         }
-        return { status: 'applied', changed: true, task: { id: taskId, shortId } };
     });
 }
 export { canonicalTaskCreateCandidate, createLocalTask, validateTaskCreateCandidate };