@fitlab-ai/agent-infra 0.9.7 → 0.9.8

package/lib/server/process-state.ts

@@ -9,6 +9,9 @@ export type ProcessIdentity = Readonly<{
   startTime: ProcessStartTime;
 }>;
 
+export type ProcessIdentityState = 'alive' | 'dead' | 'unknown';
+export type ProcessIdentityProbe = (identity: ProcessIdentity) => ProcessIdentityState;
+
 export type PidRecord = ProcessIdentity & {
   version: 2;
 };
@@ -127,6 +130,50 @@ export function getProcessStartTime(
   }
 }
 
+export function getProcessIdentityState(
+  identity: ProcessIdentity,
+  platform: NodeJS.Platform = process.platform
+): ProcessIdentityState {
+  if (!Number.isInteger(identity.pid) || identity.pid <= 0 || !Number.isSafeInteger(identity.startTime)) {
+    return 'dead';
+  }
+  if (platform === 'linux') {
+    try {
+      const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${identity.pid}/stat`, 'utf8'));
+      if (stat === null) return 'unknown';
+      if (stat.state === 'Z') return 'dead';
+      return stat.startTime === identity.startTime ? 'alive' : 'dead';
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'dead' : 'unknown';
+    }
+  }
+  try {
+    process.kill(identity.pid, 0);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ESRCH') return 'dead';
+    if (code !== 'EPERM') return 'unknown';
+  }
+  const query = buildProcessStartTimeQuery(identity.pid, platform);
+  if (query === null) return 'unknown';
+  try {
+    const output = execFileSync(query.command, query.args, {
+      encoding: 'utf8',
+      env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
+    }).trim();
+    if (output.length === 0) return 'unknown';
+    const startTime = platform === 'win32'
+      ? new Date(output).getTime()
+      : platform === 'darwin'
+        ? parseDarwinStartTime(output)
+        : null;
+    if (startTime === null || Number.isNaN(startTime)) return 'unknown';
+    return startTime === identity.startTime ? 'alive' : 'dead';
+  } catch {
+    return 'unknown';
+  }
+}
+
 function parsePidRecord(
   raw: string
 ):
@@ -234,5 +281,5 @@ export function removePidRecordIfMatches(pidFile: string, expected: PidRecord):
 }
 
 export function processIdentityMatches(identity: ProcessIdentity): boolean {
-  return getProcessStartTime(identity.pid) === identity.startTime;
+  return getProcessIdentityState(identity) === 'alive';
 }

package/lib/task/activity-intent.ts

@@ -14,6 +14,7 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import type { TaskExecutionLockOptions } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
+import { allowsManualOverride } from './guard-override.ts';
 
 type PrReviewVerdict = 'approved' | 'changes-requested' | 'commented';
 type PrReviewOutcome = 'aborted' | 'superseded';
@@ -95,7 +96,7 @@ export type PrReviewInspectionResult = {
   error: { code: string; message: string } | null;
 };
 
-type ActivityIntentOptions = TaskWriteOptions & { lockOptions?: TaskExecutionLockOptions };
+type ActivityIntentOptions = TaskWriteOptions & { lockOptions?: TaskExecutionLockOptions; lockAlreadyHeld?: boolean };
 type ArtifactRecord = { identity: ArtifactIdentity; head: string; status: PrReviewArtifactStatus };
 type RoundState = ArtifactRecord & {
   startedAgent: string | null;
@@ -397,9 +398,10 @@ export function applyPrReviewActivityIntent(intent: PrReviewActivityIntent, opti
   if ('code' in validated) return failed(intent, validated.code, validated.message);
   const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(intent, resolved.code, resolved.message, resolved.taskId);
-  if (resolved.state !== 'active') {
+  if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'activity-intent', 'TASK_STATE_MISMATCH')) {
     return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   }
+  if (options.lockAlreadyHeld) return applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
   try {
     return withTaskExecutionLock(
       resolved.repoRoot,

package/lib/task/decision-intents.ts

@@ -16,6 +16,7 @@ import { resolveTaskContext } from './resolve-ref.ts';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
+import { allowsManualOverride } from './guard-override.ts';
 
 type HumanDecisionRequest = {
   taskRef?: string;
@@ -85,7 +86,8 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
   if (!request.selector || !request.decision.trim()) return failed('DECISION_PAYLOAD_INVALID', 'selector and decision are required');
   const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
-  if (resolved.state !== 'active') return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+  const stateOverride = allowsManualOverride(options.manualOverride, 'decision-intent', 'TASK_STATE_MISMATCH');
+  if (resolved.state !== 'active' && !stateOverride) return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   let content: string;
   let rows: LedgerRow[];
   try { content = fs.readFileSync(resolved.taskMdPath, 'utf8'); rows = parseLedger(content); }
@@ -170,7 +172,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
     body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
   });
-  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
+  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
     ...options,
     taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
     metadataProvider: () => metadata

package/lib/task/delegation-receipts.ts

@@ -100,6 +100,11 @@ function fail(code: string, message: string): ReceiptFailure {
   return { ok: false, code, message };
 }
 
+// 空白串折叠为 null，保持"缺失即 null"的单一表示（Start/Stop 两处共用，避免任一入口把 "   " 当成已观察到的值入账）
+function foldBlankToNull(value: string | undefined): string | null {
+  return value?.trim() ? value : null;
+}
+
 function prepareDelegation(
   input: Omit<DelegationReceipt, 'id' | 'requestedModel' | 'requestedReasoningEffort' | 'actualModel' | 'actualReasoningEffort' | 'modelFallbackReason' | 'reasoningEffortFallbackReason' | 'parentId' | 'childId' | 'spawnMode' | 'agent' | 'status' | 'hostEvidence' | 'afterFingerprint' | 'changedPaths' | 'createdAt' | 'preparedMonotonicMs' | 'spawnDispatchMonotonicMs' | 'activationDeadlineMonotonicMs' | 'spawnDispatchedAt' | 'activationDeadlineAt' | 'startEvidenceMonotonicMs' | 'activatedMonotonicMs' | 'activatedAt' | 'sealedAt' | 'consumedAt'> & Readonly<{ requestedModel: string; requestedReasoningEffort: string }>,
   options: { id?: () => string; now?: () => string; monotonicNow?: () => number } = {}
@@ -162,7 +167,7 @@ function activateDelegation(
     nativeAgent: string;
     childId: string;
     parentId: string;
-    spawnMode: string;
+    spawnMode?: string;
     actualModel?: string;
     actualReasoningEffort?: string;
     modelFallbackReason?: string;
@@ -211,32 +216,46 @@ function activateDelegation(
   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');
   }
-  if (event.spawnMode !== 'fresh') return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
-  const actualModel = event.actualModel;
-  if (!actualModel || actualModel.trim() !== actualModel) {
-    return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+  // spawnMode 的必需性按 client 判断：claude-code 宿主结构上不提供该字段，跳过；其余 client 维持硬校验
+  if (receipt.client !== 'claude-code' && 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 (!actualModel || actualModel.trim() !== actualModel) {
+      return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+    }
   }
-  if (actualModel !== receipt.requestedModel && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
-    return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+  if (actualModel !== null && actualModel !== receipt.requestedModel) {
+    if (receipt.client !== 'claude-code' && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
+      return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+    }
   }
-  const actualReasoningEffort = event.actualReasoningEffort;
-  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 !== 'claude-code') {
+    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 !== receipt.requestedReasoningEffort
-    && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')
-  ) {
-    return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+  if (actualReasoningEffort !== null && actualReasoningEffort !== receipt.requestedReasoningEffort) {
+    if (receipt.client !== 'claude-code' && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
+      return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+    }
   }
-  if (actualModel === receipt.requestedModel && event.modelFallbackReason) {
+  // "无关 fallback 理由"检查对所有 client 保持不变——防止编造理由的红线，不属于 HDR-2 放宽范围
+  // actualModel/actualReasoningEffort 为 null（未观察到）时同样没有"实际不同"这回事，理由一样是无关的
+  if ((actualModel === null || actualModel === receipt.requestedModel) && event.modelFallbackReason) {
     return fail('DELEGATION_MODEL_FALLBACK_INVALID', 'model fallback reason is only valid when actual model differs');
   }
-  if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
+  if (
+    (actualReasoningEffort === null || actualReasoningEffort === receipt.requestedReasoningEffort)
+    && event.reasoningEffortFallbackReason
+  ) {
     return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
   }
   if (
@@ -280,7 +299,7 @@ function activateDelegation(
     status: 'activated',
     parentId: event.parentId,
     childId: event.childId,
-    spawnMode: event.spawnMode,
+    spawnMode: event.spawnMode ?? null,
     actualModel,
     actualReasoningEffort,
     modelFallbackReason: event.modelFallbackReason ?? null,
@@ -328,6 +347,10 @@ function sealDelegation(
     exitCode: number;
     afterFingerprint: string;
     changedPaths: readonly string[];
+    actualModel?: string;
+    actualReasoningEffort?: string;
+    modelFallbackReason?: string;
+    reasoningEffortFallbackReason?: string;
     hostEvidence?: Readonly<{ stopRevision: number; consumer: string; consumedAt: string }>;
   }>,
   options: { now?: () => string; requireHostEvidence?: boolean } = {}
@@ -361,6 +384,10 @@ function sealDelegation(
     status: 'sealed',
     afterFingerprint: event.afterFingerprint,
     changedPaths: Object.freeze([...event.changedPaths]),
+    actualModel: receipt.actualModel ?? foldBlankToNull(event.actualModel),
+    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
@@ -385,6 +412,7 @@ export {
   completeDelegationStage,
   consumeDelegation,
   dispatchDelegation,
+  foldBlankToNull,
   managedDelegationRole,
   prepareDelegation,
   sealDelegation

package/lib/task/events.ts

@@ -32,6 +32,7 @@ import type { OrchestrationStageCompletion } from './orchestration.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from './write.ts';
+import { allowsManualOverride } from './guard-override.ts';
 
 const eventCatalog = [
   'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
@@ -53,6 +54,7 @@ type TaskEventErrorCode =
   | ArtifactErrorCode | TaskWriteErrorCode;
 type TaskEventRequest = {
   taskRef: string; event: TaskEventName | string; agent: string; dryRun?: boolean; orchestrated?: boolean;
+  overrideTicket?: string; overrideTarget?: string; overrideScope?: string;
   round?: number; question?: number; artifact?: string; fixFor?: string; implementationInput?: string;
   verdict?: Verdict; blockers?: number; major?: number; minor?: number;
   manualValidation?: number; filesModified?: number; testsPassed?: number;
@@ -61,6 +63,7 @@ type TaskEventRequest = {
 type TaskEventError = { code: TaskEventErrorCode; message: string };
 type TaskEventOptions = TaskWriteOptions & {
   commitOrchestrationCompletion?: (plan: OrchestrationStageCompletion) => void;
+  lockAlreadyHeld?: boolean;
 };
 type TaskEventResult = {
   status: 'planned' | 'applied' | 'no-op' | 'failed'; changed: boolean;
@@ -73,7 +76,7 @@ type TaskEventResult = {
   operations: readonly TaskOperationSummary[]; error: TaskEventError | null;
 };
 
-const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun']);
+const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']);
 const SCHEMAS: Record<TaskEventName, { required?: string[]; optional?: string[] }> = {
   'analyze.started': { optional: ['round'] },
   'analyze.awaiting-input': { required: ['question'] },
@@ -357,7 +360,8 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   if (invalid) return failed(request, invalid);
   const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(request, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
-  if (resolved.state !== 'active') return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+  const stateOverride = allowsManualOverride(options.manualOverride, 'task-event', 'TASK_STATE_MISMATCH');
+  if (resolved.state !== 'active' && !stateOverride) return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
   let content: string;
   try { content = fs.readFileSync(resolved.taskMdPath, 'utf8'); }
   catch (error) { return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath }); }
@@ -406,7 +410,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   const done = completedRows.find((item) => item.note === eventIdentity.note);
   if (eventIdentity.phase === 'completed' && done) return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, done.done, frontmatter, artifactContext);
   if (eventIdentity.phase === 'completed' && completedRows.length > 0 && openRows.length === 0) return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'event identity is already completed with a different payload' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-  if (eventIdentity.phase === 'completed' && !row?.started) return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires one open matching started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+  if (eventIdentity.phase === 'completed' && !row?.started && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING')) return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires one open matching started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
   if (eventIdentity.phase === 'completed') {
     const validated = validateCompletedArtifact(resolved.taskDir, FAMILY[eventIdentity.family].artifact, normalized.artifact!, normalized.round);
     if (!validated.ok) return failed(normalized, validated.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -417,7 +421,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, existing.time, frontmatter, artifactContext);
   }
   const allowed = FAMILY[eventIdentity.family][eventIdentity.phase === 'started' ? 'started' : 'completed'];
-  if (!(allowed as readonly string[]).includes(currentStep)) return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${normalized.event} is not allowed from '${currentStep}'` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+  if (!(allowed as readonly string[]).includes(currentStep) && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID')) return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${normalized.event} is not allowed from '${currentStep}'` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
   const findingCountError = validateReviewFindingCounts(
     normalized,
     content,
@@ -522,7 +526,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     });
   }
   mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
-  const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
+  const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : '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 (!normalized.dryRun && orchestrationCompletion) {
     try {
@@ -560,6 +564,7 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   const invalid = validateTaskEventRequest(request);
   if (invalid) return failed(request, invalid);
   const parts = eventParts(request.event);
+  if (options.lockAlreadyHeld) return applyTaskEventUnlocked(request, options);
   if (request.dryRun || parts.phase !== 'completed' || parts.family === 'manual-validation') {
     return applyTaskEventUnlocked(request, options);
   }

package/lib/task/guard-override.ts

@@ -0,0 +1,50 @@
+type ManualOverrideCapability = Readonly<{
+  failureId: string;
+  operator: string;
+  reason: string;
+}>;
+
+type GuardProducer = Readonly<{
+  producerId: string;
+  guardId: `G-${string}`;
+  code: string;
+}>;
+
+const guardProducerCatalog: readonly GuardProducer[] = [
+  { producerId: 'task.resolve', guardId: 'G-01', code: 'TASK_NOT_FOUND' },
+  { producerId: 'task.resolve', guardId: 'G-01', code: 'TASK_IDENTITY_CONFLICT' },
+  { producerId: 'task.write', guardId: 'G-02', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'task-event', guardId: 'G-04', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'task-event', guardId: 'G-04', code: 'EVENT_TRANSITION_INVALID' },
+  { producerId: 'task-event', guardId: 'G-04', code: 'EVENT_START_MISSING' },
+  { producerId: 'task-verify', guardId: 'G-05', code: 'VERIFY_TASK_STATE_MISMATCH' },
+  { producerId: 'task-verify', guardId: 'G-05', code: 'VERIFY_ARTIFACT_INVALID' },
+  { producerId: 'verification-engine', guardId: 'G-06', code: 'CHECK_FAILED' },
+  { producerId: 'verification-engine', guardId: 'G-06', code: 'CHECK_BLOCKED' },
+  { producerId: 'activity-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'ledger-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'decision-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'workflow-warning', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'review-finalization', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+  { producerId: 'ledger-intent', guardId: 'G-08', code: 'LEDGER_TRANSITION_INVALID' },
+  { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_STANDALONE_BUSY' },
+  { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_PROVENANCE_MISMATCH' },
+  { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_STATE_INVALID' },
+  { producerId: 'platform.issue', guardId: 'G-10', code: 'PLATFORM_BIND_FAILED' },
+  { producerId: 'platform.pull-request', guardId: 'G-10', code: 'PLATFORM_BIND_FAILED' }
+];
+
+function guardFailureId(producerId: string, code: string): string {
+  return `${producerId}:${code}`;
+}
+
+function allowsManualOverride(
+  capability: ManualOverrideCapability | undefined,
+  producerId: string,
+  code: string
+): boolean {
+  return capability?.failureId === guardFailureId(producerId, code);
+}
+
+export { allowsManualOverride, guardFailureId, guardProducerCatalog };
+export type { GuardProducer, ManualOverrideCapability };