codex-workflow-v2 2.0.0-beta.13.14 → 2.0.0-beta.13.16

package/src/observation.ts

@@ -0,0 +1,198 @@
+import { existsSync, readdirSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import type {
+  AdoptionPostureEvent,
+  ObservationReasonCode,
+  ObservedMilestoneTransaction,
+  ObservedProjectTransaction,
+  PublicWriterLease,
+  ProjectRecord,
+  WorkflowObservation,
+  WriterLease,
+} from './contracts.js';
+import { readCurrentAdoptionPosture } from './alpha6/adoption.js';
+import { listMilestoneTransactionJournals } from './alpha6/journal.js';
+import { assertNoSymlinkPathComponents } from './alpha6/store-sidecars.js';
+import { listProjectTransactions } from './beta1/project-transaction.js';
+import type { RepositoryIdentity } from './repository.js';
+import {
+  listCoreTaskOperationMutexes,
+  listWriterLeases,
+  toPublicCoreTaskOperation,
+  toPublicWriterLease,
+} from './state/lock.js';
+import { inspectCorrectiveReplanTaskTransactions } from './state/corrective-replan-transaction.js';
+import { inspectCorrectiveYieldTaskTransactions } from './state/corrective-yield-transaction.js';
+import type { FileStateStore } from './state/store.js';
+
+export interface WorkflowObservationBoundary {
+  identity: RepositoryIdentity;
+  project: ProjectRecord | null;
+  currentAdoptionPosture: AdoptionPostureEvent | null;
+  leases: WriterLease[];
+  observation: WorkflowObservation;
+}
+
+/**
+ * Reads only the persistence boundary needed to decide whether a coherent lifecycle snapshot can
+ * be loaded. It deliberately does not register a project, recover a journal, initialize adoption,
+ * or construct a WriterLockManager.
+ */
+export function inspectWorkflowObservationBoundary(options: {
+  store: FileStateStore;
+  identity: RepositoryIdentity;
+  now: Date;
+}): WorkflowObservationBoundary {
+  const { store, identity, now } = options;
+  const projectRoot = store.projectRoot(identity.projectId);
+  const projectFile = path.join(projectRoot, 'project.json');
+  const lockRoot = store.lockRoot(identity.projectId);
+  const stateRootPresent = existsSync(store.root);
+  const projectRootPresent = existsSync(projectRoot);
+  const lockRootPresent = existsSync(lockRoot);
+  const missingRegistration = !existsSync(projectFile);
+  const pendingProjectTransactions = observeProjectTransactions(projectRoot, identity.projectId);
+  const pendingMilestoneTransactions = observeMilestoneTransactions(store, identity.projectId);
+  const replanTransactions = inspectCorrectiveReplanTaskTransactions(projectRoot, store.root);
+  const yieldTransactions = inspectCorrectiveYieldTaskTransactions(projectRoot, store.root);
+  const taskTransactions = {
+    pending: [...replanTransactions.pending, ...yieldTransactions.pending]
+      .sort((left, right) => left.taskId.localeCompare(right.taskId) || left.transactionId.localeCompare(right.transactionId)),
+    corrupt: [...replanTransactions.corrupt, ...yieldTransactions.corrupt]
+      .sort((left, right) => left.taskId.localeCompare(right.taskId) || left.transactionId.localeCompare(right.transactionId)),
+  };
+  const pendingTaskTransitionIds = [...new Set(taskTransactions.pending.map((transaction) => transaction.transitionId))];
+  const mixedPendingTaskTransitions = pendingTaskTransitionIds.length > 1;
+  const leases = listWriterLeases(lockRoot);
+  const coreTaskOperations = listCoreTaskOperationMutexes(lockRoot, store.root)
+    .map((mutex) => toPublicCoreTaskOperation(mutex, now));
+  const orphanCoreTaskOperations = coreTaskOperations.filter((operation) => !taskTransactions.pending.some(
+    (transaction) => transaction.taskId === operation.entityId && transaction.transactionId === operation.operationId,
+  ));
+
+  const project = !missingRegistration && pendingProjectTransactions.length === 0
+    ? store.readProject(identity.projectId)
+    : null;
+  const repositoryRootBound = project?.repositoryRoots.includes(identity.repositoryRoot) ?? false;
+  const adoptionAssessed = pendingProjectTransactions.length === 0
+    && pendingMilestoneTransactions.length === 0
+    && taskTransactions.pending.length === 0
+    && taskTransactions.corrupt.length === 0
+    && orphanCoreTaskOperations.length === 0;
+  const currentAdoptionPosture = adoptionAssessed && stateRootPresent
+    ? readCurrentAdoptionPosture(store, identity.projectId)
+    : null;
+  const missingAdoption = adoptionAssessed && currentAdoptionPosture === null;
+  const observedLeases = leases.map((lease) => toPublicWriterLease(lease, now));
+  const activeLeases = observedLeases.filter((lease) => !lease.stale);
+  const staleLeases = observedLeases.filter((lease) => lease.stale);
+
+  const reasonCodes: ObservationReasonCode[] = [];
+  if (missingRegistration) reasonCodes.push('PROJECT_REGISTRATION_MISSING');
+  if (project && !repositoryRootBound) reasonCodes.push('PROJECT_REPOSITORY_ROOT_UNBOUND');
+  if (pendingProjectTransactions.length > 0) reasonCodes.push('PROJECT_RECOVERY_REQUIRED');
+  if (pendingMilestoneTransactions.length > 0) reasonCodes.push('MILESTONE_RECOVERY_REQUIRED');
+  if (taskTransactions.pending.length > 0) reasonCodes.push('TASK_RECOVERY_REQUIRED');
+  if (taskTransactions.corrupt.length > 0) reasonCodes.push('TASK_TRANSACTION_INTEGRITY_FAILED');
+  if (orphanCoreTaskOperations.some((operation) => !operation.stale)) reasonCodes.push('TASK_OPERATION_IN_PROGRESS');
+  if (orphanCoreTaskOperations.some((operation) => operation.stale)) reasonCodes.push('STALE_TASK_OPERATION');
+  if (activeLeases.length > 0) reasonCodes.push('ACTIVE_WRITER_LEASE');
+  if (staleLeases.length > 0) reasonCodes.push('STALE_WRITER_LEASE');
+  if (missingAdoption) reasonCodes.push('ADOPTION_MISSING');
+
+  const blocked = missingRegistration
+    || (project !== null && !repositoryRootBound)
+    || pendingProjectTransactions.length > 0
+    || taskTransactions.corrupt.length > 0
+    || mixedPendingTaskTransitions
+    || orphanCoreTaskOperations.length > 0;
+  const repairable = taskTransactions.pending.length > 0
+    || pendingMilestoneTransactions.length > 0;
+  const kind: WorkflowObservation['kind'] = blocked ? 'blocked' : repairable ? 'repair' : 'assessment';
+  const repair = kind !== 'repair'
+    ? null
+    : taskTransactions.pending.length > 0
+      ? {
+          command: pendingTaskTransitionIds[0] === 'task.coordination.corrective-yield'
+            ? 'task corrective-yield-recover' as const
+            : 'task corrective-replan-recover' as const,
+          cataloged: false as const,
+          available: true as const,
+          projectId: identity.projectId,
+          taskIds: [...new Set(taskTransactions.pending.map((transaction) => transaction.taskId))].sort(),
+          transactionIds: taskTransactions.pending.map((transaction) => transaction.transactionId).sort(),
+        }
+      : pendingMilestoneTransactions.length > 0
+      ? {
+          command: 'milestone recover' as const,
+          cataloged: false as const,
+          projectId: identity.projectId,
+          milestoneIds: [...new Set(pendingMilestoneTransactions.map((transaction) => transaction.milestoneId))].sort(),
+          transactionIds: pendingMilestoneTransactions.map((transaction) => transaction.transactionId).sort(),
+        }
+      : {
+          command: 'locks repair' as const,
+          cataloged: false as const,
+          projectId: identity.projectId,
+          entityIds: staleLeases.map((lease) => lease.entityId).sort(),
+        };
+
+  return {
+    identity,
+    project,
+    currentAdoptionPosture,
+    leases,
+    observation: {
+      kind,
+      reasonCodes,
+      stateRootPresent,
+      projectRootPresent,
+      lockRootPresent,
+      missingRegistration,
+      repositoryRootBound,
+      adoptionAssessed,
+      missingAdoption,
+      pendingProjectTransactions,
+      pendingMilestoneTransactions,
+      pendingTaskTransactions: taskTransactions.pending,
+      corruptTaskTransactions: taskTransactions.corrupt,
+      coreTaskOperations,
+      leases: observedLeases,
+      availableRepairTransitionId: null,
+      repair,
+    },
+  };
+}
+
+function observeProjectTransactions(projectRoot: string, projectId: string): ObservedProjectTransaction[] {
+  return listProjectTransactions(projectRoot, projectId)
+    .map((transaction) => ({ ...transaction }))
+    .sort((left, right) => left.preparedAt.localeCompare(right.preparedAt)
+      || left.transactionId.localeCompare(right.transactionId));
+}
+
+function observeMilestoneTransactions(
+  store: FileStateStore,
+  projectId: string,
+): ObservedMilestoneTransaction[] {
+  const milestonesRoot = path.join(store.projectRoot(projectId), 'milestones');
+  if (!existsSync(milestonesRoot)) return [];
+  assertNoSymlinkPathComponents(milestonesRoot, {
+    label: 'Milestones observation root',
+    requireLeaf: true,
+    trustedRoot: store.root,
+  });
+  return readdirSync(milestonesRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => listMilestoneTransactionJournals(realpathSync(path.join(milestonesRoot, entry.name)), {
+      expectedMilestoneId: entry.name,
+    }).map((journal) => ({
+      milestoneId: journal.milestoneId,
+      transactionId: journal.transactionId,
+      phase: journal.phase,
+      preparedAt: journal.preparedAt,
+      updatedAt: journal.updatedAt,
+    })))
+    .sort((left, right) => left.preparedAt.localeCompare(right.preparedAt)
+      || left.transactionId.localeCompare(right.transactionId));
+}