@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/task/lifecycle.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { artifactFamilyCatalog, inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
@@ -15,7 +15,7 @@ import { taskIssueIdentity } from '../platform/task-identities.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const lifecycleIntentCatalog = [
-    'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
+    'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ];
 const lifecycleFailureCatalog = [
     'LIFECYCLE_DIRECTORY_TRANSFER_FAILED',
@@ -82,9 +82,6 @@ function failed(request, error, extra = {}) {
         error, ...extra
     };
 }
-export function taskLifecycleFailure(request, error, taskId = null) {
-    return failed(request, error, { taskId });
-}
 function normalizedRequest(request) {
     if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent)) {
         return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -300,26 +297,11 @@ function taskBoundControlMoveSafety(request, controlRoot, options, taskId, repoR
     }
     return null;
 }
-function orchestrationMoveSafety(sourcePath) {
-    const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
-    if (!pathExists(orchestrationPath))
-        return null;
-    try {
-        const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8'));
-        if (run.status === 'running' || run.pendingDelegation !== null && run.pendingDelegation !== undefined) {
-            return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration has an active or pending delegation; settle it before moving the task directory' };
-        }
-    }
-    catch {
-        return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration state is unreadable; refusing to move the task directory' };
-    }
-    return null;
-}
-function runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, validateControlManifestIdentity) {
+function runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, validateControlManifestIdentity) {
     if (!movingTaskDirectory)
         return null;
     const controlSafety = taskBoundControlMoveSafety(request, options.controlRoot, options, taskId, repoRoot, validateControlManifestIdentity);
-    return controlSafety ?? orchestrationMoveSafety(sourcePath);
+    return controlSafety;
 }
 function targetContainsTask(targetPath, taskId, request) {
     try {
@@ -356,16 +338,26 @@ function actionAndNote(request, restoredFiles = 0) {
         return { action: 'Close Codescan', note: `Code Scanning alert #${request.alertNumber} dismissed: ${request.reason}` };
     if (request.intent === 'close-dependabot')
         return { action: 'Close Dependabot', note: `Dependabot alert #${request.alertNumber} dismissed: ${request.reason}` };
-    if (request.intent === 'recover-started')
-        return { action: 'Recover Started', note: 'automatic recovery' };
     return { action: 'Restore Task', note: `Restored ${restoredFiles} files from Issue #${request.issueNumber}` };
 }
+function completionKeys(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_transition;
+    if (value === undefined)
+        return [];
+    if (typeof value !== 'string')
+        throw new Error('invalid lifecycle transition');
+    const state = JSON.parse(value);
+    if (!state || typeof state !== 'object' || !('completedKeys' in state) || !Array.isArray(state.completedKeys))
+        throw new Error('invalid lifecycle transition');
+    return state.completedKeys.map((key) => {
+        if (!key || typeof key !== 'object' || !('action' in key) || typeof key.action !== 'string' || !('agent' in key) || typeof key.agent !== 'string' || !('note' in key) || typeof key.note !== 'string')
+            throw new Error('invalid lifecycle completion identity');
+        return key;
+    });
+}
 function matchingCompletion(content, request, restoredFiles = 0) {
-    const section = locateActivityLog(content);
-    if (!section)
-        return false;
     const identity = actionAndNote(request, restoredFiles);
-    return section.entries.some((entry) => entry.step === identity.action && entry.agent === request.agent && entry.note === identity.note);
+    return completionKeys(content).some((entry) => entry.action === identity.action && entry.agent === request.agent && entry.note === identity.note);
 }
 function validateRestoreStaging(request, repoRoot, taskId) {
     let workspace;
@@ -424,13 +416,17 @@ function validateRestoreStaging(request, repoRoot, taskId) {
     }
     return { stagingDir, fileCount: entries.filter((entry) => !entry.name.startsWith('.')).length };
 }
-function mutationsFor(request, content, metadata, restoredFiles, allowMissingActivityLog = false) {
-    const section = locateActivityLog(content) ?? (allowMissingActivityLog ? { heading: 'Activity Log', body: '', entries: [] } : null);
+function lifecycleActivityMutation(content, request, metadata, identity, allowMissing) {
+    const section = locateActivityLog(content) ?? (allowMissing ? { 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);
+        return [];
     let body = appendActivityEntry(section, { time: metadata.timestamp, step: `${identity.action} [started]`, agent: request.agent, note: 'started' });
     body = appendActivityEntry({ ...section, body }, { time: metadata.timestamp, step: identity.action, agent: request.agent, note: identity.note });
+    return [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }];
+}
+function mutationsFor(request, content, metadata, restoredFiles, allowMissingActivityLog = false) {
+    const identity = actionAndNote(request, restoredFiles);
+    const activityMutation = lifecycleActivityMutation(content, request, metadata, identity, allowMissingActivityLog);
     const set = {};
     const remove = [];
     if (request.intent === 'block') {
@@ -458,9 +454,13 @@ function mutationsFor(request, content, metadata, restoredFiles, allowMissingAct
         if (frontmatter.target_date === '')
             set.target_date = metadata.timestamp.slice(0, 10);
     }
+    const completedKeys = completionKeys(content);
+    if (!matchingCompletion(content, request, restoredFiles))
+        completedKeys.push({ ...identity, agent: request.agent });
+    set.lifecycle_transition = JSON.stringify({ completedKeys });
     const mutations = [
         { kind: 'frontmatter', set, remove: [...new Set(remove)] },
-        { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }
+        ...activityMutation
     ];
     if (request.intent === 'block') {
         mutations.splice(1, 0, {
@@ -595,9 +595,6 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
     }
 }
 function applyTaskLifecycle(requestInput, options = {}) {
-    if (requestInput.intent === 'recover-started') {
-        return failed(requestInput, { code: 'LIFECYCLE_RECOVERY_REQUIRES_AUTHORITY', message: 'recover-started must be dispatched through task control authority' });
-    }
     const normalized = normalizedRequest(requestInput);
     if ('code' in normalized)
         return failed(requestInput, normalized);
@@ -674,7 +671,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         && !(request.intent === 'complete' && targetContainsTask(targetPath, taskId, request))) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, true);
+    const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, true);
     if (moveSafety)
         return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     const content = io.readFileSync(currentTaskFile);
@@ -687,8 +684,6 @@ 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))
-        return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     if (spec.target === 'active') {
         const contract = validateCurrentTaskContract(content);
         if (!contract.ok)
@@ -832,7 +827,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (fs.existsSync(targetPath) && !fs.existsSync(path.join(sourcePath, 'task.md')))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {
-        const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, false);
+        const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, false);
         if (moveSafety)
             return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0, timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -967,5 +962,18 @@ function applyTaskLifecycle(requestInput, options = {}) {
         journalPath, completedSteps: [...completed], pendingSteps: []
     };
 }
-export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle, previewTaskCompletion };
+function applyTaskLifecycleWithWarnings(request, options = {}) {
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    const taskFile = resolved.ok ? resolved.taskMdPath : request.intent === 'restore' ? path.join(request.stagingDir, 'task.md') : null;
+    let warnings = [];
+    if (taskFile) {
+        try {
+            warnings = activityWarnings(fs.readFileSync(taskFile, 'utf8'));
+        }
+        catch { /* The lifecycle operation reports its own read failure. */ }
+    }
+    const result = applyTaskLifecycle(request, options);
+    return result.status === 'failed' || !warnings.length ? result : { ...result, warnings };
+}
+export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycleWithWarnings as applyTaskLifecycle, previewTaskCompletion };
 //# sourceMappingURL=lifecycle.js.map

package/dist/lib/task/local-artifact-finalization.js

@@ -113,9 +113,6 @@ function prepareLocalArtifact(request, candidate) {
         repoRoot: resolved.repoRoot
     };
 }
-function commitLocalArtifactProvenance(prepared) {
-    return prepared.result;
-}
 function finalizeLocalArtifact(request) {
     return prepareLocalArtifact(request).result;
 }
@@ -124,5 +121,5 @@ function preflightLocalArtifact(request) {
     const prepared = prepareLocalArtifact(request);
     return prepared.result;
 }
-export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, finalizeLocalArtifact, preflightLocalArtifact, prepareLocalArtifact, commitLocalArtifactProvenance, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
+export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, finalizeLocalArtifact, preflightLocalArtifact, prepareLocalArtifact, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
 //# sourceMappingURL=local-artifact-finalization.js.map

package/dist/lib/task/manual-validation-evidence.js

@@ -1,5 +1,3 @@
-import fs from 'node:fs';
-import { createHash } from 'node:crypto';
 import { MANUAL_VALIDATION_SHA40 as SHA40, MANUAL_VALIDATION_TASK_ID as TASK_ID, exactKeys, isRecord, validTimestamp } from './manual-validation-shared.js';
 const MANUAL_VALIDATION_EVIDENCE_SCHEMA = 'agent-infra/branch-only-validation-evidence';
 const MANUAL_VALIDATION_EVIDENCE_VERSION = 1;
@@ -92,39 +90,5 @@ function manualValidationEvidenceSummary(evidence) {
         cleanup: evidence.result.cleanup
     };
 }
-function validateManualValidationEvidence(value, expected) {
-    const shape = validateShape(value);
-    if (!shape.ok)
-        return shape;
-    const evidence = shape.value;
-    if (evidence.result.exitCode !== 0 || evidence.result.signal !== null || evidence.result.cleanup !== 'completed') {
-        return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_UNSUCCESSFUL', message: 'validation must exit 0 without a signal and complete cleanup' } };
-    }
-    if (expected) {
-        if (evidence.taskId !== expected.taskId || evidence.branch !== expected.branch) {
-            return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_IDENTITY_MISMATCH', message: 'evidence task or branch does not match the expected identity' } };
-        }
-        if (expected.commit !== undefined && evidence.commit !== expected.commit) {
-            return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_STALE', message: 'evidence commit does not match the current head' } };
-        }
-    }
-    return shape;
-}
-function readManualValidationEvidence(file, expected) {
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch (error) {
-        const code = error.code === 'ENOENT'
-            ? 'MANUAL_VALIDATION_EVIDENCE_MISSING'
-            : 'MANUAL_VALIDATION_EVIDENCE_INVALID';
-        return { ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } };
-    }
-    return validateManualValidationEvidence(parsed, expected);
-}
-function manualValidationEvidenceDigest(evidence) {
-    return createHash('sha256').update(JSON.stringify(evidence), 'utf8').digest('hex');
-}
-export { MANUAL_VALIDATION_EVIDENCE_SCHEMA, MANUAL_VALIDATION_EVIDENCE_VERSION, createManualValidationEvidence, manualValidationEvidenceSummary, manualValidationEvidenceDigest, readManualValidationEvidence, validateManualValidationEvidence };
+export { MANUAL_VALIDATION_EVIDENCE_SCHEMA, MANUAL_VALIDATION_EVIDENCE_VERSION, createManualValidationEvidence, manualValidationEvidenceSummary };
 //# sourceMappingURL=manual-validation-evidence.js.map