@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/dist/lib/task/ledger-intents.js

@@ -4,6 +4,7 @@ import { declareImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplemen
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
+import { allowsManualOverride } from './guard-override.js';
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
@@ -84,7 +85,8 @@ function applyLedgerIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    if (resolved.state !== 'active')
+    const stateOverride = allowsManualOverride(options.manualOverride, 'ledger-intent', 'TASK_STATE_MISMATCH');
+    if (resolved.state !== 'active' && !stateOverride)
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -176,7 +178,8 @@ function applyLedgerIntent(intent, options = {}) {
                         ? new Set(['confirmed', 'open', 'needs-human-decision'])
                         : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
                 const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
-                if ((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot))) {
+                if (((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot)))
+                    && !allowsManualOverride(options.manualOverride, 'ledger-intent', 'LEDGER_TRANSITION_INVALID')) {
                     return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
                 }
                 after = { ...before, status: intent.status, evidence };
@@ -209,7 +212,7 @@ function applyLedgerIntent(intent, options = {}) {
         }
     }
     const result = writeTask({
-        taskRef: intent.taskRef, expectedState: 'active',
+        taskRef: intent.taskRef, expectedState: stateOverride ? resolved.state : 'active',
         mutations: [...ledgerSectionMutation(content), rowMutation(after), ...(implementationMutation ? [implementationMutation] : [])],
         dryRun: 'dryRun' in intent ? intent.dryRun : false
     }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });

package/dist/lib/task/lifecycle.js

@@ -10,6 +10,36 @@ import { captureTaskWriteMetadata, writeTask } from './write.js';
 const lifecycleIntentCatalog = [
     'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ];
+const lifecycleFailureCatalog = [
+    'LIFECYCLE_DIRECTORY_RENAME_FAILED',
+    'LIFECYCLE_DOCUMENT_INVALID',
+    'LIFECYCLE_FINAL_STATE_INVALID',
+    'LIFECYCLE_IDENTITY_CONFLICT',
+    'LIFECYCLE_IDENTITY_INVALID',
+    'LIFECYCLE_INTENT_CONFLICT',
+    'LIFECYCLE_JOURNAL_CLEANUP_FAILED',
+    'LIFECYCLE_JOURNAL_INVALID',
+    'LIFECYCLE_JOURNAL_WRITE_FAILED',
+    'LIFECYCLE_LOG_MISSING',
+    'LIFECYCLE_METADATA_FAILED',
+    'LIFECYCLE_PAYLOAD_INVALID',
+    'LIFECYCLE_SHORT_ID_FAILED',
+    'LIFECYCLE_SHORT_ID_PRECONDITION',
+    'LIFECYCLE_SOURCE_INVALID',
+    'LIFECYCLE_STAGING_IDENTITY_INVALID',
+    'LIFECYCLE_STAGING_INVALID',
+    'LIFECYCLE_TARGET_CONFLICT',
+    'LIFECYCLE_TASK_NOT_FOUND',
+    'SHORT_ID_CAPACITY_EXCEEDED'
+];
+const lifecycleProducerCatalog = lifecycleFailureCatalog.map((code) => ({
+    producerId: 'lifecycle.apply',
+    guardId: 'G-03',
+    code
+}));
+function allowsManualOverride(options, code) {
+    return options.manualOverride?.failureId === `lifecycle.apply:${code}`;
+}
 const STEPS = ['task-written', 'directory-moved', 'registry-committed'];
 const DEFAULT_IO = {
     renameSync: (source, target) => fs.renameSync(source, target),
@@ -121,10 +151,17 @@ function matchingCompletion(content, request, restoredFiles = 0) {
     return section.entries.some((entry) => entry.step === identity.action && entry.agent === request.agent && entry.note === identity.note);
 }
 function validateRestoreStaging(request, repoRoot, taskId) {
-    const workspace = path.resolve(repoRoot, '.agents', 'workspace');
-    const stagingDir = path.resolve(request.stagingDir);
+    let workspace;
+    let stagingDir;
+    try {
+        workspace = fs.realpathSync.native(path.resolve(repoRoot, '.agents', 'workspace'));
+        stagingDir = fs.realpathSync.native(path.resolve(request.stagingDir));
+    }
+    catch (error) {
+        return { code: 'LIFECYCLE_STAGING_INVALID', message: String(error) };
+    }
     const relative = path.relative(workspace, stagingDir);
-    if (!relative || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(stagingDir) === taskId) {
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative) || path.basename(stagingDir) === taskId) {
         return { code: 'LIFECYCLE_STAGING_INVALID', message: 'restore staging must be a non-final directory inside .agents/workspace' };
     }
     let entries;
@@ -168,8 +205,8 @@ function validateRestoreStaging(request, repoRoot, taskId) {
     }
     return { stagingDir, fileCount: entries.filter((entry) => !entry.name.startsWith('.')).length };
 }
-function mutationsFor(request, content, metadata, restoredFiles) {
-    const section = locateActivityLog(content);
+function mutationsFor(request, content, metadata, restoredFiles, allowMissingActivityLog = false) {
+    const section = locateActivityLog(content) ?? (allowMissingActivityLog ? { heading: 'Activity Log', body: '', entries: [] } : null);
     if (!section)
         return { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' };
     const identity = actionAndNote(request, restoredFiles);
@@ -230,6 +267,14 @@ function writeJournal(file, journal, io, create = false) {
         throw error;
     }
 }
+function rememberJournalFailure(file, journal, io, failure) {
+    try {
+        writeJournal(file, { ...journal, failure }, io);
+    }
+    catch {
+        // Preserve the original lifecycle failure when the diagnostic receipt cannot be updated.
+    }
+}
 function parseJournal(content) {
     const value = JSON.parse(content);
     if (value.version !== 1 || typeof value.taskId !== 'string' ||
@@ -303,7 +348,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: `task ${taskId} is already ${spec.target} with a different lifecycle intent` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (!spec.sources.includes(sourceState) && !existingJournal) {
+    if (!spec.sources.includes(sourceState) && !existingJournal && !allowsManualOverride(options, 'LIFECYCLE_SOURCE_INVALID')) {
         return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     if (sourcePath !== targetPath && fs.existsSync(targetPath)) {
@@ -319,7 +364,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     if (frontmatter.id !== taskId)
         return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
-    if (!locateActivityLog(content))
+    if (!locateActivityLog(content) && !allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'))
         return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     const registryRequest = executeShortIdCommand({
         operation: 'list', activeDir: path.join(repoRoot, '.agents', 'workspace', 'active'),
@@ -330,10 +375,10 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     const registry = JSON.parse(registryRequest.output || '{"version":1,"ids":{}}');
     const registeredKey = Object.entries(registry.ids).find(([, candidate]) => candidate === taskId)?.[0];
-    if (spec.registry === 'release' && sourceState === 'active' && !registeredKey) {
+    if (spec.registry === 'release' && sourceState === 'active' && !registeredKey && !allowsManualOverride(options, 'LIFECYCLE_SHORT_ID_PRECONDITION')) {
         return failed(request, { code: 'LIFECYCLE_SHORT_ID_PRECONDITION', message: 'active source has no short-id registry entry' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1) {
+    if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1 && !allowsManualOverride(options, 'SHORT_ID_CAPACITY_EXCEEDED')) {
         return failed(request, { code: 'SHORT_ID_CAPACITY_EXCEEDED', message: 'short-id registry has no free slot' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     const digest = intentIdentity(request, taskId);
@@ -347,7 +392,15 @@ function applyTaskLifecycle(requestInput, options = {}) {
         catch (error) {
             return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
         }
-        if (journal.intentDigest !== digest || journal.taskId !== taskId)
+        if (journal.taskId !== taskId || journal.intent !== request.intent)
+            return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+        if (request.dryRun) {
+            if (!journal.failure)
+                return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+            return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: STEPS.filter((step) => !journal.completedSteps.includes(step)) });
+        }
+        const overrideResumesRecordedFailure = journal.failure && allowsManualOverride(options, journal.failure.code);
+        if (journal.intentDigest !== digest && !overrideResumesRecordedFailure)
             return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
     }
     else {
@@ -360,7 +413,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         journal = { version: 1, taskId, intent: request.intent, intentDigest: digest, sourceState, targetState: spec.target, metadata, completedSteps: [] };
         if (request.dryRun) {
-            const plannedMutations = mutationsFor(request, content, metadata, restoredFiles);
+            const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
             if ('code' in plannedMutations)
                 return failed(request, plannedMutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
             const taskPlan = writeTask({ taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations: plannedMutations, dryRun: true }, {
@@ -402,7 +455,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         completed.add('task-written');
     if (!completed.has('task-written')) {
         const current = io.readFileSync(path.join(sourcePath, 'task.md'));
-        const mutations = mutationsFor(request, current, journal.metadata, restoredFiles);
+        const mutations = mutationsFor(request, current, journal.metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
         if ('code' in mutations)
             return failed(request, mutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0 });
         const writeResult = writeTask({ taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations }, {
@@ -432,7 +485,9 @@ function applyTaskLifecycle(requestInput, options = {}) {
             (options.directoryRenameSync ?? io.renameSync)(sourcePath, targetPath);
         }
         catch (error) {
-            return failed(request, { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
+            rememberJournalFailure(journalPath, journal, io, failure);
+            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         }
         completed.add('directory-moved');
         journal.completedSteps = [...completed];
@@ -480,5 +535,5 @@ function applyTaskLifecycle(requestInput, options = {}) {
         journalPath, completedSteps: [...completed], pendingSteps: []
     };
 }
-export { lifecycleIntentCatalog, applyTaskLifecycle };
+export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle };
 //# sourceMappingURL=lifecycle.js.map

package/dist/lib/task/operation-outcome.js

@@ -0,0 +1,33 @@
+function warningKey(warning) {
+    return `${warning.step}\0${warning.code}\0${warning.target}`;
+}
+function mergeOperationWarnings(...groups) {
+    const merged = new Map();
+    for (const group of groups) {
+        for (const warning of group) {
+            const canonical = {
+                code: warning.code,
+                message: warning.message,
+                retryable: warning.retryable,
+                step: warning.step,
+                target: warning.target,
+                severity: warning.severity
+            };
+            merged.set(warningKey(canonical), canonical);
+        }
+    }
+    return [...merged.values()];
+}
+const RETRY_HINTS = {
+    COMMIT_AUTOPUSH_PROTECTED_BRANCH: 'Review the protected branch policy; push the local commit manually if delivery is intended.',
+    COMMIT_PUSH_FAILED: 'Retry the commit push-only path after fixing the remote push failure.',
+    PR_METADATA_SYNC_FAILED: 'Retry create-pr metadata synchronization; do not create another pull request.',
+    PR_SUMMARY_SYNC_FAILED: 'Retry create-pr summary synchronization; do not create another pull request.',
+    FINALIZATION_WARNING_PENDING: 'Retry complete-task to process the pending finalization step.'
+};
+function retryHintForWarning(warning) {
+    return RETRY_HINTS[warning.code]
+        ?? `Retry the ${warning.step} operation after resolving ${warning.code}.`;
+}
+export { mergeOperationWarnings, retryHintForWarning, warningKey };
+//# sourceMappingURL=operation-outcome.js.map