@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/task/lifecycle-execution.ts

@@ -1,95 +1,43 @@
-import {
-  inspectOrchestrationStage,
-  pauseOrchestration,
-  planOrchestrationStageCompletion
-} from './orchestration.ts';
-import type {
-  OrchestrationStageCompletion,
-  OrchestrationStageIdentity
-} from './orchestration.ts';
-import { resolveTaskRef } from './resolve-ref.ts';
+import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 
-type LifecycleExecutionMode = 'standalone' | 'orchestrated';
-type LifecycleExecutionRequest = Readonly<{
-  mode: LifecycleExecutionMode;
-  identity: OrchestrationStageIdentity;
-  agent?: string;
-  dryRun?: boolean;
-}>;
-type LifecycleExecutionResult = Readonly<{
-  ok: boolean;
-  mode: LifecycleExecutionMode;
-  completionPlan: OrchestrationStageCompletion | null;
-  error: Readonly<{ code: string; message: string }> | null;
-}>;
+const labels = {
+  'Analyze Task': 'analyze', 'Review Analysis': 'review-analysis', 'Plan Task': 'plan',
+  'Review Plan': 'review-plan', 'Code Task': 'code', 'Review Code': 'review-code',
+  'Run Manual Validation': 'validation-run'
+} as const;
+export type ExecutionFamily = typeof labels[keyof typeof labels] | 'manual-validation' | 'other';
+export type LifecycleExecution = {
+  family: ExecutionFamily; agent: string; startedAt: string; round?: number;
+  fixFor?: string; implementationInput?: string; transactionId?: string;
+};
 
-function failure(mode: LifecycleExecutionMode, code: string, message: string): LifecycleExecutionResult {
-  return { ok: false, mode, completionPlan: null, error: { code, message } };
-}
-
-function inspectLifecycleExecution(
-  taskRef: string,
-  request: LifecycleExecutionRequest,
-  options: Readonly<{
-    repoRoot?: string;
-    now?: () => string;
-  }> = {}
-): LifecycleExecutionResult {
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-  if (!resolved.ok) return failure(request.mode, resolved.code, resolved.message);
-  if (request.mode === 'standalone') {
-    return { ok: true, mode: request.mode, completionPlan: null, error: null };
-  }
-
-  if (request.agent) {
-    const planned = planOrchestrationStageCompletion(taskRef, {
-      ...request.identity,
-      agent: request.agent
-    }, options);
-    if (planned.plan) {
-      return { ok: true, mode: request.mode, completionPlan: planned.plan, error: null };
-    }
-    return failure(
-      request.mode,
-      planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-      planned.result.error?.message ?? 'orchestration provenance validation failed'
-    );
+export function lifecycleExecutions(content: string): LifecycleExecution[] {
+  const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+  if (value !== undefined) {
+    if (typeof value !== 'string') throw new Error('invalid lifecycle execution state');
+    const state: unknown = JSON.parse(value);
+    if (!state || typeof state !== 'object' || !('version' in state) || state.version !== 1 || !('open' in state) || !Array.isArray(state.open)) throw new Error('invalid lifecycle execution state');
+    return state.open.map((item: unknown) => {
+      if (!item || typeof item !== 'object' || !('family' in item) || typeof item.family !== 'string' || ![...Object.values(labels), 'manual-validation', 'other'].includes(item.family as ExecutionFamily) || !('agent' in item) || typeof item.agent !== 'string' || !('startedAt' in item) || typeof item.startedAt !== 'string') throw new Error('invalid lifecycle execution identity');
+      return item as LifecycleExecution;
+    });
   }
-
-  const inspected = inspectOrchestrationStage(taskRef, request.identity, options);
-  if (inspected.status !== 'failed') {
-    return { ok: true, mode: request.mode, completionPlan: null, error: null };
-  }
-  return failure(
-    request.mode,
-    inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-    inspected.error?.message ?? 'orchestration provenance validation failed'
-  );
+  return [];
 }
 
-function validateLifecycleExecution(
-  taskRef: string,
-  request: LifecycleExecutionRequest,
-  options: Readonly<{
-    repoRoot?: string;
-    now?: () => string;
-  }> = {}
-): LifecycleExecutionResult {
-  const inspected = inspectLifecycleExecution(taskRef, request, options);
-  if (inspected.ok || request.mode === 'standalone' || request.dryRun) return inspected;
-  const paused = pauseOrchestration(
-    taskRef,
-    inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-    inspected.error?.message ?? 'orchestration provenance validation failed',
-    true,
-    options
-  );
-  return failure(
-    request.mode,
-    paused.run?.pause?.code ?? inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-    paused.run?.pause?.message ?? inspected.error?.message ?? 'orchestration provenance validation failed'
-  );
+export type PrReviewExecution = { open: { artifact: string; head: string; agent: string; startedAt: string } | null; terminals: Array<{ artifact: string; head: string; agent: string; note: string }> };
+export function prReviewExecution(content: string): PrReviewExecution {
+  const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+  if (value === undefined) return { open: null, terminals: [] };
+  if (typeof value !== 'string') throw new Error('invalid lifecycle execution state');
+  const state = JSON.parse(value);
+  if (state.version !== 1 || !Array.isArray(state.open)) throw new Error('invalid lifecycle execution state');
+  const pr = state.prReview ?? { open: null, terminals: [] };
+  const valid = (item: any) => item && typeof item.artifact === 'string' && typeof item.head === 'string' && typeof item.agent === 'string';
+  if (!Array.isArray(pr.terminals) || (pr.open !== null && (!valid(pr.open) || typeof pr.open.startedAt !== 'string')) || !pr.terminals.every((item: any) => valid(item) && typeof item.note === 'string')) throw new Error('invalid PR review execution state');
+  return pr;
+}
+export function serializeLifecycleExecution(open: readonly LifecycleExecution[], content?: string, prReview?: PrReviewExecution): string {
+  const pr = prReview ?? (content ? prReviewExecution(content) : { open: null, terminals: [] });
+  return JSON.stringify({ version: 1, open, prReview: pr });
 }
-
-export { inspectLifecycleExecution, validateLifecycleExecution };
-export type { LifecycleExecutionMode, LifecycleExecutionRequest, LifecycleExecutionResult };

package/lib/task/lifecycle.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { artifactFamilyCatalog, inspectArtifactDirectory } from './artifact-lifecycle.ts';
 import { parseArtifactName } from './artifact-name.ts';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.ts';
@@ -21,7 +21,7 @@ import { resourceIdentityEquals } from '../platform/resource-identity.ts';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 const lifecycleIntentCatalog = [
-  'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
+  'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ] as const;
 const lifecycleFailureCatalog = [
   'LIFECYCLE_DIRECTORY_TRANSFER_FAILED',
@@ -60,8 +60,7 @@ type TaskLifecycleRequest =
   | { taskRef: string; intent: 'complete'; agent: string; dryRun?: boolean }
   | { taskRef: string; intent: 'close-codescan'; agent: string; alertNumber: number; reason: string; dryRun?: boolean }
   | { taskRef: string; intent: 'close-dependabot'; agent: string; alertNumber: number; reason: string; dryRun?: boolean }
-  | { taskRef: string; intent: 'restore'; agent: string; stagingDir: string; issueNumber: number; dryRun?: boolean }
-  | { taskRef: string; intent: 'recover-started'; agent: string; auto: true; dryRun?: boolean };
+  | { taskRef: string; intent: 'restore'; agent: string; stagingDir: string; issueNumber: number; dryRun?: boolean };
 
 type HotState = 'active' | 'blocked' | 'completed';
 type SourceState = HotState | 'staging';
@@ -97,6 +96,7 @@ type TaskLifecycleResult = {
   completedSteps: readonly LifecycleStep[];
   pendingSteps: readonly LifecycleStep[];
   error: LifecycleError | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 type LifecycleFileSystem = {
   renameSync: (source: string, target: string) => void;
@@ -160,14 +160,6 @@ function failed(request: Pick<TaskLifecycleRequest, 'taskRef' | 'intent'>, error
   };
 }
 
-export function taskLifecycleFailure(
-  request: Pick<TaskLifecycleRequest, 'taskRef' | 'intent'>,
-  error: LifecycleError,
-  taskId: string | null = null
-): TaskLifecycleResult {
-  return failed(request, error, { taskId });
-}
-
 function normalizedRequest(request: TaskLifecycleRequest): TaskLifecycleRequest | LifecycleError {
   if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent as TaskLifecycleIntent)) {
     return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -368,32 +360,17 @@ function taskBoundControlMoveSafety(
   return null;
 }
 
-function orchestrationMoveSafety(sourcePath: string): LifecycleError | null {
-  const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
-  if (!pathExists(orchestrationPath)) return null;
-  try {
-    const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8')) as { status?: unknown; pendingDelegation?: unknown };
-    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: TaskLifecycleRequest,
   movingTaskDirectory: boolean,
   options: TaskLifecycleOptions,
   taskId: string,
   repoRoot: string,
-  sourcePath: string,
   validateControlManifestIdentity: boolean
 ): LifecycleError | null {
   if (!movingTaskDirectory) return null;
   const controlSafety = taskBoundControlMoveSafety(request, options.controlRoot, options, taskId, repoRoot, validateControlManifestIdentity);
-  return controlSafety ?? orchestrationMoveSafety(sourcePath);
+  return controlSafety;
 }
 
 function targetContainsTask(targetPath: string, taskId: string, request: TaskLifecycleRequest): boolean {
@@ -422,15 +399,26 @@ function actionAndNote(request: TaskLifecycleRequest, restoredFiles = 0): { acti
   if (request.intent === 'complete') return { action: 'Complete Task', note: 'Task moved to completed/' };
   if (request.intent === 'close-codescan') 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}` };
 }
 
+type LifecycleCompletionKey = { action: string; agent: string; note: string };
+
+function completionKeys(content: string): LifecycleCompletionKey[] {
+  const value = parseTypedTaskFrontmatter(content).lifecycle_transition;
+  if (value === undefined) return [];
+  if (typeof value !== 'string') throw new Error('invalid lifecycle transition');
+  const state: unknown = 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: unknown) => {
+    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 as LifecycleCompletionKey;
+  });
+}
+
 function matchingCompletion(content: string, request: TaskLifecycleRequest, restoredFiles = 0): boolean {
-  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: Extract<TaskLifecycleRequest, { intent: 'restore' }>, repoRoot: string, taskId: string): LifecycleError | { stagingDir: string; fileCount: number } {
@@ -483,12 +471,17 @@ function validateRestoreStaging(request: Extract<TaskLifecycleRequest, { intent:
   return { stagingDir, fileCount: entries.filter((entry) => !entry.name.startsWith('.')).length };
 }
 
-function mutationsFor(request: TaskLifecycleRequest, content: string, metadata: TaskWriteMetadata, restoredFiles: number, allowMissingActivityLog = false): TaskMutation[] | LifecycleError {
-  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);
+function lifecycleActivityMutation(content: string, request: TaskLifecycleRequest, metadata: TaskWriteMetadata, identity: { action: string; note: string }, allowMissing: boolean): TaskMutation[] {
+  const section = locateActivityLog(content) ?? (allowMissing ? { heading: 'Activity Log', body: '', entries: [] } : null);
+  if (!section) 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: TaskLifecycleRequest, content: string, metadata: TaskWriteMetadata, restoredFiles: number, allowMissingActivityLog = false): TaskMutation[] | LifecycleError {
+  const identity = actionAndNote(request, restoredFiles);
+  const activityMutation = lifecycleActivityMutation(content, request, metadata, identity, allowMissingActivityLog);
   const set: Record<string, string> = {};
   const remove: string[] = [];
   if (request.intent === 'block') {
@@ -506,9 +499,12 @@ function mutationsFor(request: TaskLifecycleRequest, content: string, metadata:
     const frontmatter = parseTypedTaskFrontmatter(content);
     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: TaskMutation[] = [
     { 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, {
@@ -630,9 +626,6 @@ export function inspectTaskLifecycleProgress(
 }
 
 function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLifecycleOptions = {}): TaskLifecycleResult {
-  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);
   const request = normalized;
@@ -696,14 +689,13 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     && !(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);
   let frontmatter;
   try { frontmatter = parseTypedTaskFrontmatter(content); }
   catch (error) { return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: error instanceof Error ? error.message : String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath }); }
   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) return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: contract.message }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
@@ -823,7 +815,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   }
   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 });
     if (request.intent === 'complete') {
@@ -925,9 +917,21 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   };
 }
 
+function applyTaskLifecycleWithWarnings(request: TaskLifecycleRequest, options: TaskLifecycleOptions = {}): TaskLifecycleResult {
+  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: ReturnType<typeof activityWarnings> = [];
+  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,
-  applyTaskLifecycle, previewTaskCompletion
+  applyTaskLifecycleWithWarnings as applyTaskLifecycle, previewTaskCompletion
 };
 export type {
   TaskLifecycleIntent, TaskLifecycleRequest, TaskLifecycleResult, TaskLifecycleOptions,

package/lib/task/local-artifact-finalization.ts

@@ -183,12 +183,6 @@ function prepareLocalArtifact(
 
 }
 
-function commitLocalArtifactProvenance(
-  prepared: LocalArtifactPreparation
-): LocalArtifactFinalizationResult {
-  return prepared.result;
-}
-
 function finalizeLocalArtifact(
   request: LocalArtifactFinalizationRequest
 ): LocalArtifactFinalizationResult {
@@ -208,7 +202,6 @@ export {
   finalizeLocalArtifact,
   preflightLocalArtifact,
   prepareLocalArtifact,
-  commitLocalArtifactProvenance,
   canonicalSemanticDigest as semanticDigest,
   sha256Content,
   validateLocalArtifact

package/lib/task/manual-validation-evidence.ts

@@ -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,
@@ -47,11 +45,6 @@ type ManualValidationEvidenceInput = {
   signal: string | null;
   cleanup: ManualValidationCleanup;
 };
-type ManualValidationEvidenceIdentity = {
-  taskId: string | null;
-  branch: string;
-  commit?: string;
-};
 type ManualValidationEvidenceErrorCode =
   | 'MANUAL_VALIDATION_EVIDENCE_MISSING'
   | 'MANUAL_VALIDATION_EVIDENCE_INVALID'
@@ -151,56 +144,17 @@ function manualValidationEvidenceSummary(evidence: ManualValidationEvidence): Ma
   };
 }
 
-function validateManualValidationEvidence(value: unknown, expected?: ManualValidationEvidenceIdentity): ManualValidationEvidenceResult {
-  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: string, expected?: ManualValidationEvidenceIdentity): ManualValidationEvidenceResult {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).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: ManualValidationEvidence): string {
-  return createHash('sha256').update(JSON.stringify(evidence), 'utf8').digest('hex');
-}
-
 export {
   MANUAL_VALIDATION_EVIDENCE_SCHEMA,
   MANUAL_VALIDATION_EVIDENCE_VERSION,
   createManualValidationEvidence,
-  manualValidationEvidenceSummary,
-  manualValidationEvidenceDigest,
-  readManualValidationEvidence,
-  validateManualValidationEvidence
+  manualValidationEvidenceSummary
 };
 export type {
   ManualValidationCleanup,
   ManualValidationEvidence,
   ManualValidationEvidenceError,
   ManualValidationEvidenceErrorCode,
-  ManualValidationEvidenceIdentity,
   ManualValidationEvidenceInput,
   ManualValidationEvidenceResult,
   ManualValidationEvidenceSummary,