@fitlab-ai/agent-infra 0.11.11 → 0.11.13

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

@@ -21,77 +21,37 @@ function nullableText(value) {
 function nullableSafeInteger(value) {
     return value === null || (Number.isSafeInteger(value) && value >= 0);
 }
-const LIFECYCLE_PROVENANCE_KEYS = [
-    'protocolVersion', 'packageVersion', 'internalExecutableBuildHash', 'lifecycleContractHash',
-    'hookDefinitionHash', 'hookSource', 'hookSourcePathDigest', 'hookSourceHash',
-    'capabilitySessionId', 'capabilityTurnId', 'capabilityToolUseId',
-    'controllerInstanceDigest', 'controlGeneration'
-];
-function isDelegationLifecycleProvenance(value) {
-    if (!hasExactKeys(value, LIFECYCLE_PROVENANCE_KEYS))
-        return false;
-    return Number.isSafeInteger(value.protocolVersion)
-        && value.protocolVersion > 0
-        && exactText(value.packageVersion)
-        && exactText(value.internalExecutableBuildHash)
-        && exactText(value.lifecycleContractHash)
-        && exactText(value.hookDefinitionHash)
-        && ['project', 'managed', 'isolated-user'].includes(value.hookSource)
-        && exactText(value.hookSourcePathDigest)
-        && exactText(value.hookSourceHash)
-        && exactText(value.capabilitySessionId)
-        && exactText(value.capabilityTurnId)
-        && exactText(value.capabilityToolUseId)
-        && nullableText(value.controllerInstanceDigest)
-        && nullableText(value.controlGeneration);
-}
-const HOST_EVIDENCE_REQUIRED_KEYS = [
-    'kind', 'hookDefinitionHash', 'startRevision', 'stopRevision', 'consumer', 'consumedAt'
-];
-const HOST_EVIDENCE_OPTIONAL_KEYS = [
-    'protocolVersion', 'packageVersion', 'internalExecutableBuildHash', 'lifecycleContractHash',
-    'hookSource', 'hookSourcePathDigest', 'hookSourceHash', 'capabilitySessionId',
-    'capabilityTurnId', 'capabilityToolUseId', 'spawnToolUseId', 'spawnObservedAt',
-    'controllerInstanceDigest', 'controlGeneration'
-];
-function isDelegationHostEvidence(value) {
-    if (!hasExactKeys(value, HOST_EVIDENCE_REQUIRED_KEYS, HOST_EVIDENCE_OPTIONAL_KEYS))
-        return false;
-    if (!['codex-lifecycle-v1', 'codex-lifecycle-v2'].includes(value.kind))
-        return false;
-    if (!exactText(value.hookDefinitionHash)
-        || !Number.isSafeInteger(value.startRevision) || value.startRevision < 1
-        || !nullableSafeInteger(value.stopRevision)
-        || !nullableText(value.consumer)
-        || !nullableText(value.consumedAt))
-        return false;
-    if (value.kind === 'codex-lifecycle-v1')
-        return true;
-    return Number.isSafeInteger(value.protocolVersion)
-        && value.protocolVersion > 0
-        && exactText(value.packageVersion)
-        && exactText(value.internalExecutableBuildHash)
-        && exactText(value.lifecycleContractHash)
-        && ['project', 'managed', 'isolated-user'].includes(value.hookSource)
-        && exactText(value.hookSourcePathDigest)
-        && exactText(value.hookSourceHash)
-        && exactText(value.capabilitySessionId)
-        && exactText(value.capabilityTurnId)
-        && exactText(value.spawnToolUseId)
-        && exactText(value.spawnObservedAt)
-        && nullableText(value.controllerInstanceDigest)
-        && nullableText(value.controlGeneration);
-}
 const RECEIPT_KEYS = [
     'id', 'taskId', 'runId', 'role', 'stage', 'round', 'artifact', 'client',
     'requestedModel', 'requestedReasoningEffort', 'actualModel', 'actualReasoningEffort',
     'modelFallbackReason', 'reasoningEffortFallbackReason', 'parentId', 'childId',
-    'spawnMode', 'agent', 'status', 'workspaceSnapshotScope', 'lifecycleProvenance',
-    'hostEvidence', 'beforeFingerprint', 'afterFingerprint', 'changedPaths', 'createdAt',
+    'spawnMode', 'agent', 'status', 'workspaceSnapshotScope',
+    'beforeFingerprint', 'afterFingerprint', 'changedPaths', 'createdAt',
     'preparedMonotonicMs', 'spawnDispatchMonotonicMs', 'activationDeadlineMonotonicMs',
     'spawnDispatchedAt', 'activationDeadlineAt', 'startEvidenceMonotonicMs',
     'activatedMonotonicMs', 'activatedAt', 'sealedAt', 'consumedAt'
 ];
+const RECEIPT_OPTIONAL_KEYS = ['adapterEvidence'];
+function isJsonRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    try {
+        return JSON.parse(JSON.stringify(value)) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function withClientEvidence(receipt, evidence) {
+    if (evidence === undefined)
+        return receipt.adapterEvidence ?? Object.freeze({});
+    if (!isJsonRecord(evidence))
+        return null;
+    return Object.freeze({
+        ...(receipt.adapterEvidence ?? {}),
+        [receipt.client]: JSON.parse(JSON.stringify(evidence))
+    });
+}
 function hasStatusBoundEvidence(receipt) {
     const dispatchFields = [
         receipt.spawnDispatchMonotonicMs,
@@ -114,7 +74,6 @@ function hasStatusBoundEvidence(receipt) {
             && receipt.modelFallbackReason === null
             && receipt.reasoningEffortFallbackReason === null
             && receipt.agent === null
-            && receipt.hostEvidence === null
             && receipt.startEvidenceMonotonicMs === null
             && receipt.activatedMonotonicMs === null
             && receipt.activatedAt === null
@@ -139,18 +98,12 @@ function hasStatusBoundEvidence(receipt) {
             && receipt.consumedAt === null;
     }
     if (receipt.status === 'aborted') {
-        const host = receipt.hostEvidence;
         return receipt.agent === null
             && receipt.afterFingerprint === null
             && receipt.changedPaths.length === 0
             && receipt.sealedAt === null
             && receipt.consumedAt === null
-            && host !== null
-            && host !== undefined
-            && Number.isSafeInteger(host.stopRevision)
-            && host.stopRevision > host.startRevision
-            && host.consumer === receipt.id
-            && exactText(host.consumedAt);
+            && receipt.childId !== null;
     }
     if (!exactText(receipt.agent)
         || normalizeAgentToken(receipt.agent) !== normalizeAgentToken(receipt.client))
@@ -168,7 +121,7 @@ function hasStatusBoundEvidence(receipt) {
         : receipt.status === 'consumed' && exactText(receipt.consumedAt);
 }
 function isDelegationReceipt(value) {
-    if (!hasExactKeys(value, RECEIPT_KEYS))
+    if (!hasExactKeys(value, RECEIPT_KEYS, RECEIPT_OPTIONAL_KEYS))
         return false;
     const structurallyValid = exactText(value.id)
         && exactText(value.taskId)
@@ -191,8 +144,7 @@ function isDelegationReceipt(value) {
         && nullableText(value.agent)
         && ['prepared', 'activated', 'stage-completed', 'sealed', 'consumed', 'aborted', 'expired'].includes(value.status)
         && value.workspaceSnapshotScope === 'task'
-        && (value.lifecycleProvenance === null || isDelegationLifecycleProvenance(value.lifecycleProvenance))
-        && (value.hostEvidence === null || isDelegationHostEvidence(value.hostEvidence))
+        && (value.adapterEvidence === undefined || isJsonRecord(value.adapterEvidence))
         && exactText(value.beforeFingerprint)
         && nullableText(value.afterFingerprint)
         && Array.isArray(value.changedPaths)
@@ -214,14 +166,6 @@ function isDelegationReceipt(value) {
     const receipt = value;
     if (!hasStatusBoundEvidence(receipt))
         return false;
-    const host = receipt.hostEvidence;
-    if (receipt.client === 'codex' && receipt.activatedAt !== null) {
-        if (host?.kind !== 'codex-lifecycle-v2' || host.capabilitySessionId !== receipt.parentId)
-            return false;
-        if (['sealed', 'consumed'].includes(receipt.status)) {
-            return Number.isSafeInteger(host.stopRevision) && host.stopRevision > host.startRevision;
-        }
-    }
     return true;
 }
 const MANAGED_AGENTS = {
@@ -238,10 +182,35 @@ function fail(code, message) {
 function foldBlankToNull(value) {
     return value?.trim() ? value : null;
 }
+function validateSealRequest(receipt, event) {
+    if (receipt.status !== 'stage-completed') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+    }
+    if (event.childId !== receipt.childId || event.exitCode !== 0) {
+        return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
+    }
+    const reviewerPathFailure = validateReviewerSealPaths(receipt, event.changedPaths);
+    return reviewerPathFailure;
+}
+function validateReviewerSealPaths(receipt, changedPaths) {
+    if (receipt.role !== 'reviewer')
+        return null;
+    const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
+    const allowed = new Set([
+        `${taskRoot}${receipt.artifact}`,
+        `${taskRoot}task.md`,
+        `${taskRoot}.runtime/orchestration.json`
+    ]);
+    const disallowed = changedPaths.find((entry) => !allowed.has(entry));
+    return disallowed
+        ? fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`)
+        : null;
+}
 function prepareDelegation(input, options = {}) {
     const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
     return Object.freeze({
         ...input,
+        adapterEvidence: Object.freeze({ ...(input.adapterEvidence ?? {}) }),
         id: (options.id ?? randomUUID)(),
         actualModel: null,
         actualReasoningEffort: null,
@@ -252,7 +221,6 @@ function prepareDelegation(input, options = {}) {
         spawnMode: null,
         agent: null,
         status: 'prepared',
-        hostEvidence: null,
         afterFingerprint: null,
         changedPaths: Object.freeze([]),
         createdAt: (options.now ?? (() => new Date().toISOString()))(),
@@ -310,33 +278,29 @@ function activateDelegation(receipt, event, options = {}) {
     if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
         return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
     }
-    // spawnMode 的必需性按 client 判断：claude-code 宿主结构上不提供该字段，跳过；其余 client 维持硬校验
-    if (receipt.client !== 'claude-code' && event.spawnMode !== 'fresh') {
+    const evidencePolicy = options.evidencePolicy ?? {};
+    if (evidencePolicy.spawnModeRequired !== false && event.spawnMode !== 'fresh') {
         return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
     }
-    // model/effort 维度：claude-code 如实记录、不做门禁；其余 client 维持现状硬校验（HDR-2）
     const actualModel = foldBlankToNull(event.actualModel);
     const actualReasoningEffort = foldBlankToNull(event.actualReasoningEffort);
-    if (receipt.client !== 'claude-code') {
+    if (evidencePolicy.actualModelRequired !== false) {
         if (!actualModel || actualModel.trim() !== actualModel) {
             return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
         }
     }
     if (actualModel !== null && actualModel !== receipt.requestedModel) {
-        if (receipt.client !== 'claude-code' && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
+        if (evidencePolicy.fallbackReasonRequired !== false && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
             return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
         }
     }
-    if (receipt.client !== 'claude-code') {
+    if (evidencePolicy.actualReasoningEffortRequired !== false) {
         if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
             return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
         }
     }
-    if (receipt.client === 'codex'
-        && event.hostEvidence?.kind !== 'codex-lifecycle-v2')
-        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex activation requires trusted lifecycle-v2 host evidence');
     if (actualReasoningEffort !== null && actualReasoningEffort !== receipt.requestedReasoningEffort) {
-        if (receipt.client !== 'claude-code' && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
+        if (evidencePolicy.fallbackReasonRequired !== false && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
             return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
         }
     }
@@ -349,16 +313,9 @@ function activateDelegation(receipt, event, options = {}) {
         && event.reasoningEffortFallbackReason) {
         return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
     }
-    if (event.hostEvidence
-        && (receipt.client !== 'codex'
-            || !event.hostEvidence.hookDefinitionHash.trim()
-            || !Number.isSafeInteger(event.hostEvidence.startRevision)
-            || event.hostEvidence.startRevision < 1))
-        return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
-    if (event.hostEvidence?.kind === 'codex-lifecycle-v2'
-        && event.hostEvidence.capabilitySessionId !== event.parentId) {
-        return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence does not match the observed parent');
-    }
+    const adapterEvidence = withClientEvidence(receipt, event.clientEvidence);
+    if (!adapterEvidence)
+        return fail('DELEGATION_ADAPTER_EVIDENCE_INVALID', 'adapter evidence must be a JSON object');
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'activated',
@@ -369,12 +326,7 @@ function activateDelegation(receipt, event, options = {}) {
             actualReasoningEffort,
             modelFallbackReason: event.modelFallbackReason ?? null,
             reasoningEffortFallbackReason: event.reasoningEffortFallbackReason ?? null,
-            hostEvidence: event.hostEvidence ? Object.freeze({
-                ...event.hostEvidence,
-                stopRevision: null,
-                consumer: null,
-                consumedAt: null
-            }) : receipt.hostEvidence ?? null,
+            adapterEvidence,
             startEvidenceMonotonicMs: monotonic,
             activatedMonotonicMs: (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))(),
             activatedAt: new Date(wallNow).toISOString()
@@ -393,22 +345,11 @@ function abortActivatedDelegation(receipt, event) {
     if (receipt.status !== 'activated') {
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
     }
-    if (receipt.client !== 'codex'
-        || !receipt.lifecycleProvenance
-        || receipt.hostEvidence?.kind !== 'codex-lifecycle-v2'
-        || typeof receipt.lifecycleProvenance.controllerInstanceDigest !== 'string'
-        || typeof receipt.lifecycleProvenance.controlGeneration !== 'string'
-        || typeof receipt.hostEvidence.controllerInstanceDigest !== 'string'
-        || typeof receipt.hostEvidence.controlGeneration !== 'string') {
-        return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'activated delegation lacks the current Codex controller binding');
-    }
-    if (event.childId !== receipt.childId
-        || !Number.isSafeInteger(event.stopRevision)
-        || event.stopRevision <= receipt.hostEvidence.startRevision
-        || event.consumer !== receipt.id
-        || !exactText(event.consumedAt)) {
-        return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'recovery stop evidence does not match the activated delegation');
-    }
+    if (event.childId !== receipt.childId)
+        return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'recovery child does not match the activated delegation');
+    const adapterEvidence = withClientEvidence(receipt, event.clientEvidence);
+    if (!adapterEvidence)
+        return fail('DELEGATION_ADAPTER_EVIDENCE_INVALID', 'adapter evidence must be a JSON object');
     return {
         ok: true,
         receipt: Object.freeze({
@@ -419,12 +360,7 @@ function abortActivatedDelegation(receipt, event) {
             changedPaths: Object.freeze([]),
             sealedAt: null,
             consumedAt: null,
-            hostEvidence: Object.freeze({
-                ...receipt.hostEvidence,
-                stopRevision: event.stopRevision,
-                consumer: event.consumer,
-                consumedAt: event.consumedAt
-            })
+            adapterEvidence
         })
     };
 }
@@ -440,32 +376,12 @@ function completeDelegationStage(receipt, event) {
     return { ok: true, receipt: Object.freeze({ ...receipt, status: 'stage-completed', agent: event.agent }) };
 }
 function sealDelegation(receipt, event, options = {}) {
-    if (receipt.status !== 'stage-completed')
-        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
-    if (receipt.client === 'codex' && options.requireHostEvidence !== false && !event.hostEvidence) {
-        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex sealing requires consumed lifecycle-v2 host evidence');
-    }
-    if (event.childId !== receipt.childId || event.exitCode !== 0)
-        return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
-    if (receipt.role === 'reviewer') {
-        const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
-        const allowed = new Set([
-            `${taskRoot}${receipt.artifact}`,
-            `${taskRoot}task.md`,
-            `${taskRoot}orchestration.json`
-        ]);
-        const disallowed = event.changedPaths.find((entry) => !allowed.has(entry));
-        if (disallowed)
-            return fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`);
-    }
-    if (event.hostEvidence) {
-        if (!receipt.hostEvidence
-            || !Number.isSafeInteger(event.hostEvidence.stopRevision)
-            || event.hostEvidence.stopRevision <= receipt.hostEvidence.startRevision
-            || event.hostEvidence.consumer !== receipt.id
-            || !event.hostEvidence.consumedAt.trim())
-            return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex stop evidence reference is invalid');
-    }
+    const validationFailure = validateSealRequest(receipt, event);
+    if (validationFailure)
+        return validationFailure;
+    const adapterEvidence = withClientEvidence(receipt, event.clientEvidence);
+    if (!adapterEvidence)
+        return fail('DELEGATION_ADAPTER_EVIDENCE_INVALID', 'adapter evidence must be a JSON object');
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'sealed',
@@ -475,10 +391,7 @@ function sealDelegation(receipt, event, options = {}) {
             actualReasoningEffort: receipt.actualReasoningEffort ?? foldBlankToNull(event.actualReasoningEffort),
             modelFallbackReason: receipt.modelFallbackReason ?? event.modelFallbackReason ?? null,
             reasoningEffortFallbackReason: receipt.reasoningEffortFallbackReason ?? event.reasoningEffortFallbackReason ?? null,
-            hostEvidence: event.hostEvidence && receipt.hostEvidence ? Object.freeze({
-                ...receipt.hostEvidence,
-                ...event.hostEvidence
-            }) : receipt.hostEvidence ?? null,
+            adapterEvidence,
             sealedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }

package/dist/lib/task/events.js

@@ -25,7 +25,6 @@ import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { inspectReviewIdentity } from './review-identity.js';
 import { parseCompletionFacts } from './completion-facts.js';
-import { consumeLifecycleRecoveryAttestation, lifecycleRecoveryAttestationDigest, validateLifecycleRecoveryAttestation } from './control-authority.js';
 import { readManualValidationCompletion } from './manual-validation-completion.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 const eventCatalog = [
@@ -349,6 +348,65 @@ function openStartedIdentity(rows, family) {
     });
     return matches.length === 1 ? matches[0] : matches.length > 1 ? { conflict: true } : null;
 }
+function repairMissingCodeFixQualifier(request, family, open, repoRoot) {
+    if (family !== 'code' || open.fixFor !== undefined || !request.fixFor || request.implementationInput !== undefined) {
+        return {
+            error: {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `open code start cannot be repaired (family=${family}, openFixFor=${open.fixFor ?? 'none'}, requestedFixFor=${request.fixFor ?? 'none'}, implementationInput=${request.implementationInput ?? 'none'})`
+            },
+            context: null
+        };
+    }
+    const repair = normalizeStarted(request, repoRoot);
+    if ('error' in repair)
+        return { error: repair.error, context: repair.context };
+    if (repair.request.round !== open.round || repair.request.fixFor !== request.fixFor || repair.request.implementationInput !== undefined) {
+        return { error: { code: 'EVENT_ARTIFACT_CONFLICT', message: 'current code artifact context does not match the open round and requested fix input' }, context: repair.context };
+    }
+    return repair;
+}
+function resolveOpenStartedEvent(request, family, open, repoRoot) {
+    if (open.row.agent !== request.agent)
+        return { status: 'error', error: { code: 'EVENT_LOG_CONFLICT', message: 'open started event has a different agent' } };
+    if (family === 'manual-validation' && request.transactionId !== undefined) {
+        const existingTransactionId = /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(open.row.note)?.[1];
+        if (existingTransactionId !== undefined && existingTransactionId !== request.transactionId) {
+            return { status: 'error', error: { code: 'EVENT_LOG_CONFLICT', message: 'open manual-validation started event has a different transactionId' } };
+        }
+    }
+    if (request.round !== undefined && request.round !== open.round) {
+        return { status: 'error', error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `round ${request.round} conflicts with open round ${open.round}` } };
+    }
+    if (request.fixFor !== undefined && request.fixFor !== open.fixFor) {
+        const repair = repairMissingCodeFixQualifier(request, family, open, repoRoot);
+        if (!repair)
+            return { status: 'error', error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `fixFor '${request.fixFor}' conflicts with open event` } };
+        if ('error' in repair)
+            return { status: 'error', error: repair.error, context: repair.context };
+        return { status: 'repair', repair: repair.request, context: repair.context, superseded: { action: open.row.step } };
+    }
+    if (request.implementationInput !== open.implementationInput) {
+        return { status: 'error', error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `implementationInput '${request.implementationInput ?? ''}' conflicts with open event` } };
+    }
+    return {
+        status: 'replay',
+        replay: {
+            ...request,
+            round: open.round,
+            artifact: artifactName(FAMILY[family].artifact, open.round),
+            fixFor: open.fixFor,
+            implementationInput: open.implementationInput
+        },
+        startedAt: open.row.started
+    };
+}
+function hasOtherOpenStarted(rows, allowedAction) {
+    return rows.some((row) => row.started && !row.done && row.step !== allowedAction);
+}
+function hasConflictingOpenStarted(rows, recovery) {
+    return recovery ? hasOtherOpenStarted(rows, recovery.action) : rows.some((row) => row.started && !row.done);
+}
 function reviewInputFamily(family) {
     return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
 }
@@ -538,38 +596,34 @@ function applyTaskEventUnlocked(request, options = {}) {
     const rows = startedBackedRows(pairEntries(section.entries));
     let normalized = request;
     let artifactContext = null;
+    let supersededOpenStart = null;
     if (initialParts.phase === 'started') {
         const openIdentity = openStartedIdentity(rows, initialParts.family);
         if (openIdentity && 'conflict' in openIdentity)
             return failed(request, { code: 'EVENT_LOG_CONFLICT', message: 'artifact family has more than one open started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
         if (openIdentity) {
-            if (openIdentity.row.agent !== request.agent)
-                return failed(request, { code: 'EVENT_LOG_CONFLICT', message: 'open started event has a different agent' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            if (initialParts.family === 'manual-validation' && request.transactionId !== undefined) {
-                const existingTransactionId = /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(openIdentity.row.note)?.[1];
-                if (existingTransactionId !== undefined && existingTransactionId !== request.transactionId)
-                    return failed(request, { code: 'EVENT_LOG_CONFLICT', message: 'open manual-validation started event has a different transactionId' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            }
-            if (request.round !== undefined && request.round !== openIdentity.round)
-                return failed(request, { code: 'EVENT_ARTIFACT_CONFLICT', message: `round ${request.round} conflicts with open round ${openIdentity.round}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            if (request.fixFor !== undefined && request.fixFor !== openIdentity.fixFor)
-                return failed(request, { code: 'EVENT_ARTIFACT_CONFLICT', message: `fixFor '${request.fixFor}' conflicts with open event` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            if (request.implementationInput !== openIdentity.implementationInput)
-                return failed(request, { code: 'EVENT_ARTIFACT_CONFLICT', message: `implementationInput '${request.implementationInput ?? ''}' conflicts with open event` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            normalized = { ...request, round: openIdentity.round, artifact: artifactName(FAMILY[initialParts.family].artifact, openIdentity.round), fixFor: openIdentity.fixFor, implementationInput: openIdentity.implementationInput };
-            return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '', identity(normalized), openIdentity.row.started, frontmatter, null);
-        }
-        if (rows.some((item) => item.started && !item.done)) {
+            const resolvedStart = resolveOpenStartedEvent(request, initialParts.family, openIdentity, resolved.repoRoot);
+            if (resolvedStart.status === 'error')
+                return failed(request, resolvedStart.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+            if (resolvedStart.status === 'replay')
+                return successNoOp(resolvedStart.replay, resolved.taskId, resolved.taskMdPath, typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '', identity(resolvedStart.replay), resolvedStart.startedAt, frontmatter, null);
+            normalized = resolvedStart.repair;
+            artifactContext = resolvedStart.context;
+            supersededOpenStart = resolvedStart.superseded;
+        }
+        if (hasConflictingOpenStarted(rows, supersededOpenStart)) {
             return failed(request, {
                 code: 'EVENT_TRANSITION_INVALID',
                 message: 'EXECUTION_BUSY: another lifecycle execution is open'
             }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
         }
-        const result = normalizeStarted(request, resolved.repoRoot);
-        artifactContext = result.context;
-        if ('error' in result)
-            return failed(request, result.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, artifactContext });
-        normalized = result.request;
+        if (!supersededOpenStart) {
+            const result = normalizeStarted(request, resolved.repoRoot);
+            artifactContext = result.context;
+            if ('error' in result)
+                return failed(request, result.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, artifactContext });
+            normalized = result.request;
+        }
     }
     else if (initialParts.phase === 'completed') {
         const identity = request.artifact ? parseArtifactName(request.artifact) : null;
@@ -577,25 +631,6 @@ function applyTaskEventUnlocked(request, options = {}) {
             normalized = { ...request, round: identity.round };
     }
     const eventIdentity = identity(normalized);
-    const lifecycleAuthority = options.lifecycleRecoveryAttestation ?? null;
-    if (lifecycleAuthority) {
-        try {
-            validateLifecycleRecoveryAttestation(lifecycleAuthority);
-        }
-        catch (error) {
-            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: error instanceof Error ? error.message : String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-        }
-        const expectedFamily = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
-        if (eventIdentity.phase !== 'completed'
-            || lifecycleAuthority.phase !== 'task-event.completed'
-            || lifecycleAuthority.taskId !== resolved.taskId
-            || lifecycleAuthority.family !== expectedFamily
-            || lifecycleAuthority.artifact !== normalized.artifact
-            || lifecycleAuthority.round !== normalized.round
-            || (normalized.requestId !== undefined && lifecycleAuthority.lifecycleRequestId !== normalized.requestId)) {
-            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'lifecycle completion authority does not match the event tuple' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-        }
-    }
     const currentStep = typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '';
     const matchingRows = rows.filter((item) => item.step === eventIdentity.action);
     const manual = eventIdentity.family === 'manual-validation';
@@ -689,7 +724,8 @@ function applyTaskEventUnlocked(request, options = {}) {
         const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
         const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
             || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
-        if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)) {
+        if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)
+            && !(supersededOpenStart && capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN')) {
             return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
     }
@@ -759,7 +795,15 @@ function applyTaskEventUnlocked(request, options = {}) {
     }
     const step = eventIdentity.phase === 'started' || eventIdentity.target === null ? currentStep : eventIdentity.target;
     const logStep = eventIdentity.phase === 'started' ? `${eventIdentity.action} [started]` : eventIdentity.action;
-    const body = appendActivityEntry(section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
+    const supersededBody = supersededOpenStart
+        ? appendActivityEntry(section, {
+            time: metadata.timestamp,
+            step: `${supersededOpenStart.action} [aborted]`,
+            agent: normalized.agent,
+            note: `superseded by ${eventIdentity.action}`
+        })
+        : section.body;
+    const body = appendActivityEntry(supersededOpenStart ? { ...section, body: supersededBody } : section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
     const frontmatterSet = { current_step: step, assigned_to: normalized.agent };
     if (currentFact)
         frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(parseCompletionFacts(frontmatter.completion_facts), currentFact));

package/dist/lib/task/finalization.js

@@ -9,7 +9,7 @@ import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { recoverPlatformOperations } from './platform-operation-recovery.js';
-import { applyTaskLifecycle, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
+import { applyTaskLifecycle, applyTaskLifecycleWithinTaskLock, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
 import { enumerateAllTaskDirs, resolveTaskRef } from './resolve-ref.js';
 import { inspectShortIdRegistry } from './short-id.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
@@ -684,7 +684,7 @@ function preparedResult(taskId, receipt, steps, changed) {
 }
 async function prepareUnderLock(request, taskId, options) {
     const repoRoot = path.resolve(options.repoRoot);
-    const lifecycle = options.lifecycle ?? applyTaskLifecycle;
+    const lifecycle = options.lifecycle ?? ((lifecycleRequest, lifecycleOptions) => (applyTaskLifecycleWithinTaskLock(lifecycleRequest, lifecycleOptions ?? { repoRoot }, taskId)));
     const backfill = options.backfill ?? backfillCompletionComments;
     const commentSync = options.commentSync ?? syncPlatformComment;
     const issueSync = options.issueSync ?? syncPlatformIssue;
@@ -746,7 +746,9 @@ async function prepareUnderLock(request, taskId, options) {
             const issueOperations = synced.operations;
             const badOperation = issueOperations?.find((operation) => ['requirements', 'issue-type', 'fields'].includes(operation.name)
                 && operation.status !== 'applied' && operation.status !== 'no-op'
-                && !(operation.name === 'requirements' && operation.status === 'skipped' && operation.reasonCode === 'NO_REQUIREMENTS_ANCHOR'));
+                && !(operation.name === 'requirements' && operation.status === 'skipped' && operation.reasonCode === 'NO_REQUIREMENTS_ANCHOR')
+                && !(!synced.capabilities.push && ['issue-type', 'fields'].includes(operation.name)
+                    && operation.status === 'skipped' && operation.reasonCode === 'PUSH_REQUIRED'));
             if ((synced.status !== 'applied' && synced.status !== 'no-op') || synced.error || badOperation) {
                 const error = synced.error ?? {
                     code: badOperation?.reasonCode || 'FINALIZATION_ISSUE_METADATA_UNCONFIRMED',
@@ -755,6 +757,15 @@ async function prepareUnderLock(request, taskId, options) {
                 };
                 return failed(taskId, errorOf(error, 'FINALIZATION_ISSUE_METADATA_FAILED', true));
             }
+            if (!synced.capabilities.push) {
+                const missingCapabilitySkip = ['issue-type', 'fields'].find((name) => !issueOperations?.some((operation) => operation.name === name && operation.status === 'skipped' && operation.reasonCode === 'PUSH_REQUIRED'));
+                if (missingCapabilitySkip)
+                    return failed(taskId, {
+                        code: 'FINALIZATION_ISSUE_METADATA_UNCONFIRMED',
+                        message: `Issue metadata operation '${missingCapabilitySkip}' did not report the required PUSH_REQUIRED capability skip`,
+                        retryable: true
+                    });
+            }
             let inspected;
             try {
                 inspected = await issueInspect(taskId, { cwd: repoRoot });
@@ -770,7 +781,8 @@ async function prepareUnderLock(request, taskId, options) {
                     retryable: true
                 });
             }
-            for (const name of ['requirements', 'issue-type', 'fields']) {
+            const rereadNames = synced.capabilities.push ? ['requirements', 'issue-type', 'fields'] : ['requirements'];
+            for (const name of rereadNames) {
                 const operation = issueOperations?.find((candidate) => candidate.name === name);
                 if (!operation)
                     return failed(taskId, {
@@ -1024,8 +1036,11 @@ async function commitPreparedTaskFinalization(request, options) {
                     retryable: false
                 });
             receipt = updateReceipt(repoRoot, receipt, { verification: 'pending' });
-            const lifecycle = options.lifecycle ?? applyTaskLifecycle;
-            const result = lifecycle({ taskRef: resolved.taskId, intent: 'complete', agent: request.agent }, { repoRoot, ...(options.metadataProvider ? { metadataProvider: options.metadataProvider } : {}) });
+            const lifecycleRequest = { taskRef: resolved.taskId, intent: 'complete', agent: request.agent };
+            const lifecycleOptions = { repoRoot, ...(options.metadataProvider ? { metadataProvider: options.metadataProvider } : {}) };
+            const result = options.lifecycle
+                ? options.lifecycle(lifecycleRequest, lifecycleOptions)
+                : applyTaskLifecycleWithinTaskLock(lifecycleRequest, lifecycleOptions, resolved.taskId);
             const step = lifecycleStep(result);
             if (result.status !== 'applied' && result.status !== 'no-op') {
                 const updated = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: step.error });
@@ -1118,6 +1133,20 @@ async function applyTaskFinalization(request, options) {
     const prepared = await prepareTaskFinalization(request, options);
     if (prepared.status !== 'prepared')
         return prepared;
+    if (options.beforeLifecycle) {
+        try {
+            await options.beforeLifecycle(prepared.taskId);
+        }
+        catch (error) {
+            const detail = errorOf(error, 'TASK_FINALIZATION_PRE_LIFECYCLE_FAILED', true);
+            return failed(prepared.taskId, detail, {
+                changed: prepared.changed,
+                completedSteps: prepared.completedSteps,
+                pendingSteps: prepared.pendingSteps,
+                warnings: prepared.warnings
+            });
+        }
+    }
     return commitPreparedTaskFinalization(request, options);
 }
 export { applyFinalizationReceiptMutation, commitPreparedTaskFinalization, applyTaskFinalization, prepareTaskFinalization, issueCapability as createFinalizationCapability, readTaskFinalizationReceipt, terminalResult };