@fitlab-ai/agent-infra 0.9.2 → 0.9.3

package/dist/lib/task/events.js

@@ -7,7 +7,9 @@ import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.
 import { parseReviewSummary } from './review-artifacts.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { findSectionHeading } from './sections.js';
-import { completeOrchestrationStage, validateOrchestrationStage } from './orchestration.js';
+import { validateLifecycleExecution } from './lifecycle-execution.js';
+import { commitOrchestrationStageCompletion } from './orchestration.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 const eventCatalog = [
     'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
@@ -22,17 +24,17 @@ const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun']);
 const SCHEMAS = {
     'analyze.started': { optional: ['round'] },
     'analyze.awaiting-input': { required: ['question'] },
-    'analyze.completed': { required: ['artifact'], optional: ['round'] },
+    'analyze.completed': { required: ['artifact'], optional: ['round', 'orchestrated'] },
     'review-analysis.started': { optional: ['round'] },
-    'review-analysis.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
+    'review-analysis.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
     'plan.started': { optional: ['round'] },
-    'plan.completed': { required: ['artifact'], optional: ['round'] },
+    'plan.completed': { required: ['artifact'], optional: ['round', 'orchestrated'] },
     'review-plan.started': { optional: ['round'] },
-    'review-plan.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
+    'review-plan.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
     'code.started': { optional: ['round', 'fixFor', 'implementationInput'] },
-    'code.completed': { required: ['artifact'], optional: ['round', 'fixFor', 'implementationInput', 'filesModified', 'testsPassed', 'blockers', 'major', 'minor', 'manualValidation'] },
+    'code.completed': { required: ['artifact'], optional: ['round', 'fixFor', 'implementationInput', 'filesModified', 'testsPassed', 'blockers', 'major', 'minor', 'manualValidation', 'orchestrated'] },
     'review-code.started': { optional: ['round'] },
-    'review-code.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
+    'review-code.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
     'manual-validation.started': { optional: ['round'] },
     'manual-validation.completed': { required: ['artifact', 'summaryResult'], optional: ['round'] }
 };
@@ -229,7 +231,7 @@ function openStartedIdentity(rows, family) {
     });
     return matches.length === 1 ? matches[0] : matches.length > 1 ? { conflict: true } : null;
 }
-function applyTaskEvent(request, options = {}) {
+function applyTaskEventUnlocked(request, options = {}) {
     const invalid = validateTaskEventRequest(request);
     if (invalid)
         return failed(request, invalid);
@@ -326,20 +328,27 @@ function applyTaskEvent(request, options = {}) {
     const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
     if (findingCountError)
         return failed(normalized, findingCountError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-    if (eventIdentity.phase === 'completed' && !normalized.dryRun && eventIdentity.family !== 'manual-validation') {
+    let orchestrationCompletion = null;
+    if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation') {
         const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
-        const provenance = validateOrchestrationStage(normalized.taskRef, {
-            stage: orchestrationStage,
-            round: normalized.round,
-            artifact: normalized.artifact,
-            role: eventIdentity.family.startsWith('review-') ? 'reviewer' : 'executor'
+        const execution = validateLifecycleExecution(normalized.taskRef, {
+            mode: normalized.orchestrated ? 'orchestrated' : 'standalone',
+            identity: {
+                stage: orchestrationStage,
+                round: normalized.round,
+                artifact: normalized.artifact,
+                role: eventIdentity.family.startsWith('review-') ? 'reviewer' : 'executor'
+            },
+            agent: normalized.agent,
+            dryRun: normalized.dryRun
         }, { repoRoot: options.repoRoot });
-        if (provenance.status === 'failed' || provenance.status === 'paused') {
+        if (!execution.ok) {
             return failed(normalized, {
                 code: 'EVENT_TRANSITION_INVALID',
-                message: provenance.error?.message ?? provenance.run?.pause?.message ?? 'orchestration provenance validation failed'
+                message: `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`
             }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
         }
+        orchestrationCompletion = execution.completionPlan;
     }
     let metadata;
     try {
@@ -379,19 +388,26 @@ function applyTaskEvent(request, options = {}) {
     const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
-    if (eventIdentity.phase === 'completed' && !normalized.dryRun && eventIdentity.family !== 'manual-validation') {
-        const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
-        const orchestration = completeOrchestrationStage(normalized.taskRef, {
-            stage: orchestrationStage,
-            round: normalized.round,
-            artifact: normalized.artifact,
-            agent: normalized.agent
-        }, { repoRoot: options.repoRoot });
-        if (orchestration.status === 'failed' || orchestration.status === 'paused') {
+    if (!normalized.dryRun && orchestrationCompletion) {
+        try {
+            (options.commitOrchestrationCompletion ?? commitOrchestrationStageCompletion)(orchestrationCompletion);
+        }
+        catch (error) {
             return failed(normalized, {
-                code: 'EVENT_TRANSITION_INVALID',
-                message: orchestration.error?.message ?? orchestration.run?.pause?.message ?? 'orchestration provenance validation failed'
-            }, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
+                code: 'EVENT_ORCHESTRATION_COMMIT_FAILED',
+                message: `task.md was written but orchestration completion could not be persisted; manual recovery is required: ${error instanceof Error ? error.message : String(error)}`
+            }, {
+                taskId: result.taskId,
+                taskMdPath: result.taskMdPath,
+                fromStep: currentStep,
+                toStep: step,
+                action: eventIdentity.action,
+                phase: eventIdentity.phase,
+                timestamp: result.timestamp,
+                agentInfraVersion: result.agentInfraVersion,
+                operations: result.operations,
+                artifactContext
+            });
         }
     }
     return {
@@ -404,6 +420,29 @@ function applyTaskEvent(request, options = {}) {
         agentInfraVersion: result.agentInfraVersion, operations: result.operations, error: null
     };
 }
+function applyTaskEvent(request, options = {}) {
+    const invalid = validateTaskEventRequest(request);
+    if (invalid)
+        return failed(request, invalid);
+    const parts = eventParts(request.event);
+    if (request.dryRun || parts.phase !== 'completed' || parts.family === 'manual-validation') {
+        return applyTaskEventUnlocked(request, options);
+    }
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return applyTaskEventUnlocked(request, options);
+    try {
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, () => applyTaskEventUnlocked(request, options));
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        return failed(request, {
+            code: 'EVENT_TRANSITION_INVALID',
+            message: `${error.code}: ${error.message}`
+        }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+    }
+}
 function successNoOp(request, taskId, taskMdPath, currentStep, eventIdentity, timestamp, frontmatter, artifactContext) {
     return {
         ...failed(request, { code: 'EVENT_LOG_CONFLICT', message: '' }), status: 'no-op', error: null,

package/dist/lib/task/finalization-artifacts.js

@@ -0,0 +1,35 @@
+import { assertWritableInventory, inspectTaskArtifacts } from './artifact-lifecycle.js';
+const COMPLETION_BACKFILL_FAMILIES = [
+    'analysis',
+    'review-analysis',
+    'plan',
+    'review-plan',
+    'code',
+    'review-code',
+    'manual-validation'
+];
+function inspectCompletionArtifacts(taskRef, options = {}) {
+    const artifacts = [];
+    let taskId = null;
+    let taskDir = null;
+    for (const family of COMPLETION_BACKFILL_FAMILIES) {
+        const inventory = inspectTaskArtifacts(taskRef, family, options);
+        taskId = inventory.taskId ?? taskId;
+        taskDir = inventory.taskDir ?? taskDir;
+        if (inventory.status === 'failed') {
+            return { status: 'failed', changed: false, taskId, taskDir, artifacts: [], error: inventory.error };
+        }
+        const writableError = assertWritableInventory(inventory);
+        const brokenReference = inventory.diagnostics.find((item) => item.code === 'BROKEN_REFERENCE');
+        const error = writableError ?? (brokenReference ? {
+            code: 'ARTIFACT_REFERENCE_INVALID',
+            message: brokenReference.message
+        } : null);
+        if (error)
+            return { status: 'failed', changed: false, taskId, taskDir, artifacts: [], error };
+        artifacts.push(...inventory.artifacts);
+    }
+    return { status: 'ready', changed: false, taskId, taskDir, artifacts, error: null };
+}
+export { COMPLETION_BACKFILL_FAMILIES, inspectCompletionArtifacts };
+//# sourceMappingURL=finalization-artifacts.js.map

package/dist/lib/task/lifecycle-execution.js

@@ -0,0 +1,46 @@
+import { inspectOrchestrationStage, pauseOrchestration, planOrchestrationStageCompletion, readRun } from './orchestration.js';
+import { resolveTaskRef } from './resolve-ref.js';
+function failure(mode, code, message) {
+    return { ok: false, mode, completionPlan: null, error: { code, message } };
+}
+function inspectLifecycleExecution(taskRef, request, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failure(request.mode, resolved.code, resolved.message);
+    if (request.mode === 'standalone') {
+        try {
+            const run = readRun(resolved.taskDir);
+            if (run?.pendingDelegation) {
+                return failure(request.mode, 'ORCHESTRATION_STANDALONE_BUSY', 'standalone lifecycle execution is blocked by a pending orchestration delegation');
+            }
+            return { ok: true, mode: request.mode, completionPlan: null, error: null };
+        }
+        catch (error) {
+            return failure(request.mode, 'ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (request.agent) {
+        const planned = planOrchestrationStageCompletion(taskRef, {
+            ...request.identity,
+            agent: request.agent
+        }, options);
+        if (planned.plan) {
+            return { ok: true, mode: request.mode, completionPlan: planned.plan, error: null };
+        }
+        return failure(request.mode, planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', planned.result.error?.message ?? 'orchestration provenance validation failed');
+    }
+    const inspected = inspectOrchestrationStage(taskRef, request.identity, options);
+    if (inspected.status !== 'failed') {
+        return { ok: true, mode: request.mode, completionPlan: null, error: null };
+    }
+    return failure(request.mode, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed');
+}
+function validateLifecycleExecution(taskRef, request, options = {}) {
+    const inspected = inspectLifecycleExecution(taskRef, request, options);
+    if (inspected.ok || request.mode === 'standalone' || request.dryRun)
+        return inspected;
+    const paused = pauseOrchestration(taskRef, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed', true, options);
+    return failure(request.mode, paused.run?.pause?.code ?? inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', paused.run?.pause?.message ?? inspected.error?.message ?? 'orchestration provenance validation failed');
+}
+export { inspectLifecycleExecution, validateLifecycleExecution };
+//# sourceMappingURL=lifecycle-execution.js.map