@moretea-labs/forge 1.8.0 → 1.8.1

package/packages/kernel/progression/application/projector.ts

@@ -1,211 +0,0 @@
-import { createHash } from 'crypto';
-import type {
-  AutonomousGoalProgressionAction,
-  AutonomousGoalProgressionDecision,
-  AutonomousGoalProgressionReason,
-  AutonomousGoalProgressionSnapshot,
-  ProgressionControllerRoundSnapshot,
-  ProgressionPlanStepSnapshot,
-  ProgressionWorkSnapshot,
-} from '../domain/types';
-
-const EXECUTABLE_PLAN_STATUSES = new Set(['approved', 'executing', 'verifying', 'ready_to_finalize']);
-const ACTIVE_WORK_STATUSES = new Set(['open', 'running', 'ready']);
-const IN_FLIGHT_ROUND_STATUSES = new Set(['pending_release', 'dispatching', 'dispatched', 'claimed', 'waiting']);
-
-function stableSnapshot(snapshot: AutonomousGoalProgressionSnapshot): unknown {
-  return {
-    requirement: snapshot.requirement,
-    plan: {
-      planId: snapshot.plan.planId,
-      requirementId: snapshot.plan.requirementId,
-      sourceRevision: snapshot.plan.sourceRevision,
-      status: snapshot.plan.status,
-      steps: snapshot.plan.steps.map((step) => ({
-        id: step.id,
-        dependencies: [...step.dependencies],
-        status: step.status,
-        workId: step.workId,
-      })),
-    },
-    currentSourceRevision: snapshot.currentSourceRevision,
-    works: [...snapshot.works]
-      .map((work) => ({ ...work }))
-      .sort((left, right) => left.workId.localeCompare(right.workId)),
-    controllerRounds: [...(snapshot.controllerRounds ?? [])]
-      .map((round) => ({ ...round }))
-      .sort((left, right) => left.originWorkId.localeCompare(right.originWorkId) || left.roundCount - right.roundCount),
-    schedules: [...(snapshot.schedules ?? [])]
-      .map((schedule) => ({ ...schedule }))
-      .sort((left, right) => left.scheduleId.localeCompare(right.scheduleId)),
-  };
-}
-
-function decision(
-  snapshot: AutonomousGoalProgressionSnapshot,
-  kind: AutonomousGoalProgressionAction,
-  reasonCode: AutonomousGoalProgressionReason,
-  detail: Pick<AutonomousGoalProgressionDecision, 'planStepId' | 'workId' | 'dependencyStepIds'> = {},
-): AutonomousGoalProgressionDecision {
-  const identityInput = JSON.stringify({
-    snapshot: stableSnapshot(snapshot),
-    decision: { kind, reasonCode, ...detail },
-  });
-  return {
-    schemaVersion: 1,
-    kind,
-    reasonCode,
-    requirementId: snapshot.requirement.requirementId,
-    planId: snapshot.plan.planId,
-    ...detail,
-    idempotencyKey: `goal-progression:v1:${createHash('sha256').update(identityInput).digest('hex').slice(0, 32)}`,
-  };
-}
-
-function latestRoundForWork(
-  rounds: readonly ProgressionControllerRoundSnapshot[] | undefined,
-  workId: string,
-): ProgressionControllerRoundSnapshot | undefined {
-  return (rounds ?? [])
-    .filter((round) => round.originWorkId === workId)
-    .reduce<ProgressionControllerRoundSnapshot | undefined>(
-      (latest, round) => !latest || round.roundCount > latest.roundCount ? round : latest,
-      undefined,
-    );
-}
-
-function boundWork(
-  snapshot: AutonomousGoalProgressionSnapshot,
-  step: ProgressionPlanStepSnapshot,
-): ProgressionWorkSnapshot | undefined {
-  if (!step.workId) return undefined;
-  return snapshot.works.find((work) => work.workId === step.workId);
-}
-
-function invalidDependency(
-  steps: readonly ProgressionPlanStepSnapshot[],
-): { stepId: string; dependencyIds: string[] } | undefined {
-  const ids = new Set(steps.map((step) => step.id));
-  for (const step of steps) {
-    const missing = step.dependencies.filter((dependencyId) => dependencyId === step.id || !ids.has(dependencyId));
-    if (missing.length > 0) return { stepId: step.id, dependencyIds: [...missing] };
-  }
-  return undefined;
-}
-
-/**
- * Pure Goal-level progression projection. It never writes lifecycle state and
- * never equates machine delivery with Controller semantic acceptance.
- */
-export function projectAutonomousGoalProgression(
-  snapshot: AutonomousGoalProgressionSnapshot,
-): AutonomousGoalProgressionDecision {
-  const { requirement, plan } = snapshot;
-
-  if (requirement.state === 'done') return decision(snapshot, 'goal_complete', 'REQUIREMENT_ALREADY_DONE');
-  if (requirement.state === 'waiting_for_user') return decision(snapshot, 'wait_for_user', 'REQUIREMENT_WAITING_FOR_USER');
-  if (requirement.state === 'cancelled') return decision(snapshot, 'blocked_invalid_state', 'REQUIREMENT_CANCELLED');
-  if (plan.requirementId && plan.requirementId !== requirement.requirementId) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_REQUIREMENT_MISMATCH');
-  }
-
-  // A terminal Work may legitimately advance repository source A -> B before
-  // Controller semantic acceptance advances Plan.sourceRevision to B. Only that
-  // exact Work completion target may cross the drift boundary. Any later C is
-  // unrelated drift and still requires explicit re-evaluation.
-  const validatingDelivery = plan.steps
-    .filter((step) => step.status === 'executing' || step.status === 'validating')
-    .map((step) => ({ step, work: boundWork(snapshot, step) }))
-    .find(({ work }) => work?.status === 'completed'
-      && work.baseRevision === plan.sourceRevision
-      && work.completionTargetRevision === snapshot.currentSourceRevision);
-  const expectedDeliveryAdvance = Boolean(validatingDelivery && plan.sourceRevision !== snapshot.currentSourceRevision);
-  if (plan.sourceRevision !== snapshot.currentSourceRevision && !expectedDeliveryAdvance) {
-    return decision(snapshot, 'request_replan', 'PLAN_SOURCE_DRIFT');
-  }
-  if (plan.status === 'replanning' || plan.status === 'invalidated_by_drift') return decision(snapshot, 'request_replan', 'PLAN_REPLAN_REQUIRED');
-  if (plan.status === 'finalized') {
-    if (!plan.steps.every((step) => step.status === 'completed')) {
-      return decision(snapshot, 'blocked_invalid_state', 'PLAN_COMPLETION_STATE_CONTRADICTION');
-    }
-    return decision(snapshot, 'request_requirement_acceptance', 'PLAN_FINALIZED_REQUIRES_REQUIREMENT_ACCEPTANCE');
-  }
-  if (plan.status === 'superseded' || plan.status === 'cancelled') return decision(snapshot, 'blocked_invalid_state', 'PLAN_TERMINAL_INVALID');
-  if (!EXECUTABLE_PLAN_STATUSES.has(plan.status)) return decision(snapshot, 'blocked_invalid_state', 'PLAN_NOT_EXECUTABLE');
-  if (plan.steps.length === 0) return decision(snapshot, 'blocked_invalid_state', 'PLAN_EMPTY');
-
-  const ids = new Set(plan.steps.map((step) => step.id));
-  if (ids.size !== plan.steps.length) return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_ID_DUPLICATE');
-  const badDependency = invalidDependency(plan.steps);
-  if (badDependency) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_DEPENDENCY_INVALID', {
-      planStepId: badDependency.stepId,
-      dependencyStepIds: badDependency.dependencyIds,
-    });
-  }
-
-  for (const step of plan.steps) {
-    if (step.status !== 'executing' && step.status !== 'validating') continue;
-    const work = boundWork(snapshot, step);
-    if (!work) return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_WORK_MISSING', { planStepId: step.id, workId: step.workId });
-    if (work.planId !== plan.planId || work.planStepId !== step.id || (work.requirementId && work.requirementId !== requirement.requirementId)) {
-      return decision(snapshot, 'blocked_invalid_state', 'WORK_IDENTITY_MISMATCH', { planStepId: step.id, workId: work.workId });
-    }
-    if ((work.status === 'completed' || work.status === 'failed' || work.status === 'cancelled') && step.status === 'executing') {
-      return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_TERMINAL_WORK_RECONCILIATION_REQUIRED', { planStepId: step.id, workId: work.workId });
-    }
-    if (work.status === 'failed' || work.status === 'cancelled') {
-      return decision(snapshot, 'request_replan', 'WORK_FAILED_REPLAN', { planStepId: step.id, workId: work.workId });
-    }
-    if (work.status === 'blocked') return decision(snapshot, 'wait_current_work', 'WORK_BLOCKED', { planStepId: step.id, workId: work.workId });
-    if (work.status === 'completed') {
-      return decision(snapshot, 'request_controller_acceptance', 'MACHINE_COMPLETE_REQUIRES_CONTROLLER_ACCEPTANCE', {
-        planStepId: step.id,
-        workId: work.workId,
-      });
-    }
-    if (ACTIVE_WORK_STATUSES.has(work.status)) {
-      const round = latestRoundForWork(snapshot.controllerRounds, work.workId);
-      if (round?.status === 'waiting_for_user') {
-        return decision(snapshot, 'wait_for_user', 'CONTROLLER_ROUND_WAITING_FOR_USER', { planStepId: step.id, workId: work.workId });
-      }
-      if (round?.status === 'goal_complete') {
-        return decision(snapshot, 'blocked_invalid_state', 'CONTROLLER_ROUND_TERMINAL_CONTRADICTION', { planStepId: step.id, workId: work.workId });
-      }
-      if (round && (IN_FLIGHT_ROUND_STATUSES.has(round.status) || round.status === 'blocked' || round.status === 'failed')) {
-        return decision(snapshot, 'wait_current_work', 'CONTROLLER_ROUND_IN_FLIGHT', { planStepId: step.id, workId: work.workId });
-      }
-      return decision(snapshot, 'continue_current_work', 'WORK_READY_TO_CONTINUE', { planStepId: step.id, workId: work.workId });
-    }
-  }
-
-  if (plan.steps.every((step) => step.status === 'completed')) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_COMPLETION_STATE_CONTRADICTION');
-  }
-
-  const completedIds = new Set(plan.steps.filter((step) => step.status === 'completed').map((step) => step.id));
-  const dependencyReady = plan.steps.filter((step) =>
-    step.status !== 'completed'
-    && step.dependencies.every((dependencyId) => completedIds.has(dependencyId)),
-  );
-  const explicitReady = dependencyReady.filter((step) => step.status === 'ready');
-
-  if (explicitReady.length === 1) {
-    return decision(snapshot, 'start_next_plan_step', 'NEXT_PLAN_STEP_READY', { planStepId: explicitReady[0].id });
-  }
-  if (explicitReady.length > 1) {
-    return decision(snapshot, 'blocked_invalid_state', 'MULTIPLE_READY_PLAN_STEPS', {
-      dependencyStepIds: explicitReady.map((step) => step.id),
-    });
-  }
-  const readinessNotProjected = dependencyReady.find((step) => step.status === 'pending');
-  if (readinessNotProjected) {
-    return decision(snapshot, 'blocked_invalid_state', 'PLAN_STEP_READINESS_NOT_PROJECTED', { planStepId: readinessNotProjected.id });
-  }
-
-  const blocked = plan.steps.find((step) => step.status !== 'completed');
-  return decision(snapshot, 'wait_dependency', 'PLAN_DEPENDENCY_WAIT', {
-    planStepId: blocked?.id,
-    dependencyStepIds: blocked?.dependencies.filter((dependencyId) => !completedIds.has(dependencyId)) ?? [],
-  });
-}

package/packages/kernel/progression/domain/types.ts

@@ -1,116 +0,0 @@
-import type { ControllerRoundRelayStatus } from '../../controller/api/index';
-import type { RequirementState, PlanContractStatus, PlanStepStatus } from '../../goal/api/index';
-import type { RepositorySchedule } from '../../scheduler/api/index';
-import type { WorkContractStatus } from '../../work/api/index';
-
-/**
- * Read-only lifecycle facts consumed by the Goal Progression projector.
- * These are projections of existing authorities, never a persistence schema.
- */
-export interface ProgressionRequirementSnapshot {
-  requirementId: string;
-  state: RequirementState;
-  revision: number;
-}
-
-export interface ProgressionPlanStepSnapshot {
-  id: string;
-  dependencies: readonly string[];
-  status: PlanStepStatus;
-  workId?: string;
-}
-
-export interface ProgressionPlanSnapshot {
-  planId: string;
-  requirementId?: string;
-  sourceRevision: string;
-  status: PlanContractStatus;
-  steps: readonly ProgressionPlanStepSnapshot[];
-}
-
-export interface ProgressionWorkSnapshot {
-  workId: string;
-  requirementId?: string;
-  planId?: string;
-  planStepId?: string;
-  status: WorkContractStatus;
-  /** Exact source revision from which this Work execution started. */
-  baseRevision?: string;
-  /** Exact integrated target revision from the canonical Work completion receipt, when delivery changed source. */
-  completionTargetRevision?: string;
-}
-
-export type ProgressionScheduleSnapshot = Pick<RepositorySchedule, 'scheduleId' | 'revision' | 'enabled' | 'nextEligibleAt' | 'pausedReason'>;
-
-export interface ProgressionControllerRoundSnapshot {
-  originWorkId: string;
-  status: ControllerRoundRelayStatus;
-  roundCount: number;
-}
-
-export interface AutonomousGoalProgressionSnapshot {
-  requirement: ProgressionRequirementSnapshot;
-  plan: ProgressionPlanSnapshot;
-  currentSourceRevision: string;
-  works: readonly ProgressionWorkSnapshot[];
-  controllerRounds?: readonly ProgressionControllerRoundSnapshot[];
-  schedules?: readonly ProgressionScheduleSnapshot[];
-}
-
-export const AUTONOMOUS_GOAL_PROGRESSION_ACTIONS = [
-  'continue_current_work',
-  'wait_current_work',
-  'request_controller_acceptance',
-  'request_requirement_acceptance',
-  'start_next_plan_step',
-  'wait_dependency',
-  'request_replan',
-  'wait_for_user',
-  'goal_complete',
-  'blocked_invalid_state',
-] as const;
-export type AutonomousGoalProgressionAction = (typeof AUTONOMOUS_GOAL_PROGRESSION_ACTIONS)[number];
-
-export const AUTONOMOUS_GOAL_PROGRESSION_REASONS = [
-  'REQUIREMENT_ALREADY_DONE',
-  'REQUIREMENT_WAITING_FOR_USER',
-  'REQUIREMENT_CANCELLED',
-  'PLAN_REQUIREMENT_MISMATCH',
-  'PLAN_SOURCE_DRIFT',
-  'PLAN_REPLAN_REQUIRED',
-  'PLAN_TERMINAL_INVALID',
-  'PLAN_NOT_EXECUTABLE',
-  'PLAN_EMPTY',
-  'PLAN_STEP_ID_DUPLICATE',
-  'PLAN_DEPENDENCY_INVALID',
-  'PLAN_STEP_WORK_MISSING',
-  'WORK_IDENTITY_MISMATCH',
-  'PLAN_STEP_TERMINAL_WORK_RECONCILIATION_REQUIRED',
-  'WORK_FAILED_REPLAN',
-  'WORK_BLOCKED',
-  'CONTROLLER_ROUND_IN_FLIGHT',
-  'CONTROLLER_ROUND_WAITING_FOR_USER',
-  'CONTROLLER_ROUND_TERMINAL_CONTRADICTION',
-  'WORK_READY_TO_CONTINUE',
-  'MACHINE_COMPLETE_REQUIRES_CONTROLLER_ACCEPTANCE',
-  'PLAN_FINALIZED_REQUIRES_REQUIREMENT_ACCEPTANCE',
-  'PLAN_COMPLETION_STATE_CONTRADICTION',
-  'NEXT_PLAN_STEP_READY',
-  'PLAN_DEPENDENCY_WAIT',
-  'MULTIPLE_READY_PLAN_STEPS',
-  'PLAN_STEP_READINESS_NOT_PROJECTED',
-] as const;
-export type AutonomousGoalProgressionReason = (typeof AUTONOMOUS_GOAL_PROGRESSION_REASONS)[number];
-
-export interface AutonomousGoalProgressionDecision {
-  schemaVersion: 1;
-  kind: AutonomousGoalProgressionAction;
-  reasonCode: AutonomousGoalProgressionReason;
-  requirementId: string;
-  planId: string;
-  planStepId?: string;
-  workId?: string;
-  dependencyStepIds?: string[];
-  /** Stable replay identity derived only from the immutable input snapshot + decision. */
-  idempotencyKey: string;
-}

package/packages/kernel/progression/index.ts

@@ -1 +0,0 @@
-export * from './api/index';

package/packages/kernel/scheduler/application/continuation-service.ts

@@ -1,212 +0,0 @@
-import {
-  beginInitialControllerRoundDispatch,
-  bindLegacyControllerRoundOccurrence,
-  controllerSessionPrincipalId,
-  finishControllerRoundRelayDispatch,
-  getControllerRoundRelay,
-  readControllerRoundSemanticStateFingerprint,
-  getControllerWorkBinding,
-  getRetainedControllerSession,
-  type ControllerHost,
-} from '../../controller/api/index';
-import { getWorkContract, isTerminalWorkContractStatus } from '../../work/api/index';
-import type { ScheduledControllerContinuationInput, ScheduledContinuationDispatch } from '../domain/continuation';
-import {
-  getScheduledContinuationDispatch,
-  updateScheduledContinuationDispatch,
-  type SchedulerContinuationStoreOptions,
-} from '../infrastructure/continuation-dispatch-store';
-
-export interface ScheduledControllerContinuationResult {
-  dispatch: ScheduledContinuationDispatch;
-  reused: boolean;
-}
-
-/**
- * Canonical Scheduler continuation path:
- * Schedule occurrence -> exact Work -> Work-scoped durable ControllerBinding -> current Controller delivery session -> ControllerHost.resume.
- * The occurrence record fences external replay independently of transport/provider behavior; ControllerSession ids are observation, not semantic continuation identity.
- */
-export async function resumeScheduledControllerContinuation(
-  options: SchedulerContinuationStoreOptions,
-  input: ScheduledControllerContinuationInput,
-  host: ControllerHost,
-): Promise<ScheduledControllerContinuationResult> {
-  const previous = getScheduledContinuationDispatch(options, input.occurrenceId);
-  if (previous) {
-    if (
-      previous.scheduleId !== input.scheduleId
-      || previous.workId !== input.workId
-      || previous.controllerBindingId !== input.controllerBindingId
-    ) throw new Error(`SCHEDULE_CONTINUATION_OCCURRENCE_IDENTITY_CONFLICT: ${input.occurrenceId}`);
-    if (previous.status === 'dispatched' || previous.status === 'wait_for_user' || previous.status === 'semantic_wait' || previous.status === 'rejected') return { dispatch: previous, reused: true };
-    if (previous.status === 'outcome_unknown') throw new Error(`SCHEDULE_CONTINUATION_OUTCOME_UNKNOWN: ${input.occurrenceId}`);
-    if (previous.status === 'dispatching') throw new Error(`SCHEDULE_CONTINUATION_ALREADY_DISPATCHING: ${input.occurrenceId}`);
-  }
-
-  const work = getWorkContract(options, input.workId);
-  if (!work) throw new Error(`WORK_NOT_FOUND: ${input.workId}`);
-  if (isTerminalWorkContractStatus(work.status)) throw new Error(`WORK_ALREADY_TERMINAL: ${work.workId}:${work.status}`);
-
-  const session = getRetainedControllerSession(options, work.workId);
-  if (!session) throw new Error(`CONTROLLER_SESSION_NOT_RETAINED: ${work.workId}`);
-  const bindingRecord = getControllerWorkBinding(options, work.workId);
-  if (!bindingRecord) throw new Error(`CONTROLLER_WORK_BINDING_NOT_FOUND: ${work.workId}`);
-  if (bindingRecord.binding.bindingId !== input.controllerBindingId) {
-    throw new Error(`SCHEDULE_CONTINUATION_BINDING_DRIFT: ${work.workId}:expected=${input.controllerBindingId}:actual=${bindingRecord.binding.bindingId}`);
-  }
-  if (bindingRecord.binding.hostKind !== session.controllerType) {
-    throw new Error(`SCHEDULE_CONTINUATION_HOST_KIND_MISMATCH: ${work.workId}`);
-  }
-
-  const requestedRelayScopeId = input.relayScopeId?.trim() || undefined;
-  const canonicalRelayScopeId = requestedRelayScopeId
-    ?? (work.requirementId ? `requirement:${work.requirementId}` : `goal:${work.workId}`);
-
-  // A semantic `wait` is quiescent, not a request to periodically reread the same
-  // state. Suppress unchanged schedule/manual wakes before a provider host is even
-  // selected. A new occurrence may proceed only after Kernel semantic state changes.
-  const waitingRelay = getControllerRoundRelay(options, work.workId);
-  if (waitingRelay?.status === 'waiting' && waitingRelay.relayScopeId === canonicalRelayScopeId) {
-    const currentFingerprint = readControllerRoundSemanticStateFingerprint(options, work.workId);
-    if (currentFingerprint && currentFingerprint === waitingRelay.stateFingerprint) {
-      const quiesced = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_semantic_wait', (current, at) => current ?? ({
-        schemaVersion: 1, repoId: options.repoId, scheduleId: input.scheduleId, occurrenceId: input.occurrenceId,
-        workId: work.workId, controllerSessionId: session.sessionId, controllerBindingId: bindingRecord.binding.bindingId,
-        relayScopeId: canonicalRelayScopeId, status: 'semantic_wait',
-        reason: `Controller semantic wait remains unchanged for ${canonicalRelayScopeId}; provider dispatch suppressed.`,
-        createdAt: at, updatedAt: at,
-      }));
-      return { dispatch: quiesced, reused: Boolean(previous) };
-    }
-  }
-
-  // Reserve the exact occurrence before creating a ControllerRound. If Forge dies
-  // after the round write but before the authority is copied back here, the next
-  // attempt can safely adopt only the exact still-dispatching round for this
-  // retained session/binding instead of minting or replaying another wake.
-  let prepared = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_prepare', (current, at) => current ?? ({
-    schemaVersion: 1, repoId: options.repoId, scheduleId: input.scheduleId, occurrenceId: input.occurrenceId,
-    workId: work.workId, controllerSessionId: session.sessionId, controllerBindingId: bindingRecord.binding.bindingId,
-    relayScopeId: canonicalRelayScopeId, status: 'prepared', createdAt: at, updatedAt: at,
-  }));
-  if (prepared.status === 'dispatched' || prepared.status === 'wait_for_user' || prepared.status === 'semantic_wait' || prepared.status === 'rejected') return { dispatch: prepared, reused: true };
-  if (prepared.status === 'outcome_unknown') throw new Error(`SCHEDULE_CONTINUATION_OUTCOME_UNKNOWN: ${input.occurrenceId}`);
-  if (prepared.status === 'dispatching') throw new Error(`SCHEDULE_CONTINUATION_ALREADY_DISPATCHING: ${input.occurrenceId}`);
-
-  const currentControllerPrincipalId = controllerSessionPrincipalId(session);
-  const roundMatchesReservedOccurrence = (candidate: ReturnType<typeof getControllerRoundRelay>): boolean => Boolean(
-    candidate
-    && candidate.status === 'dispatching'
-    && candidate.relayScopeId === prepared.relayScopeId
-    && candidate.occurrenceId === prepared.occurrenceId
-    && candidate.controllerId === session.controllerId
-    && candidate.controllerType === session.controllerType
-    && candidate.authorityId,
-  );
-  const bindRecoveredLegacyOccurrence = (candidate: ReturnType<typeof getControllerRoundRelay>) => {
-    if (!candidate
-      || candidate.status !== 'dispatching'
-      || candidate.occurrenceId
-      || candidate.relayScopeId !== prepared.relayScopeId
-      || candidate.controllerId !== session.controllerId
-      || candidate.controllerType !== session.controllerType
-      || (candidate.principalId?.trim() || candidate.controllerId) !== currentControllerPrincipalId
-      || !candidate.authorityId
-      || (candidate.providerRecoveryEpoch ?? 0) < 1
-      || !candidate.providerRecoveryEvidenceId) return candidate;
-    return bindLegacyControllerRoundOccurrence(options, {
-      workId: work.workId,
-      relayScopeId: prepared.relayScopeId,
-      occurrenceId: prepared.occurrenceId,
-      authorityId: candidate.authorityId,
-      expectedUpdatedAt: candidate.updatedAt,
-      identity: { controllerId: session.controllerId, controllerType: session.controllerType, principalId: currentControllerPrincipalId },
-    });
-  };
-
-  let relay = previous ? getControllerRoundRelay(options, work.workId) : undefined;
-  if (relay && !roundMatchesReservedOccurrence(relay)) {
-    relay = bindRecoveredLegacyOccurrence(relay);
-    if (!roundMatchesReservedOccurrence(relay)) {
-      throw new Error(`SCHEDULE_CONTINUATION_ROUND_ALREADY_OPEN: ${input.occurrenceId}:${relay?.relayScopeId ?? canonicalRelayScopeId}`);
-    }
-  }
-  if (!relay) {
-    try {
-      relay = beginInitialControllerRoundDispatch(options, {
-        workId: work.workId,
-        relayScopeId: requestedRelayScopeId,
-        requirementId: work.requirementId,
-        bindingId: bindingRecord.binding.bindingId,
-        occurrenceId: input.occurrenceId,
-        identity: {
-          controllerId: session.controllerId,
-          controllerType: session.controllerType,
-          principalId: controllerSessionPrincipalId(session),
-          controllerInstanceId: session.controllerInstanceId?.trim() || session.controllerId,
-          sessionId: session.sessionId,
-        },
-      });
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith('CONTROLLER_RELAY_ROUND_ALREADY_OPEN:')) {
-        let existing = getControllerRoundRelay(options, work.workId);
-        if (!roundMatchesReservedOccurrence(existing)) existing = bindRecoveredLegacyOccurrence(existing);
-        if (roundMatchesReservedOccurrence(existing)) relay = existing;
-        else throw new Error(`SCHEDULE_CONTINUATION_ROUND_ALREADY_OPEN: ${input.occurrenceId}:${canonicalRelayScopeId}`);
-      } else {
-        throw error;
-      }
-    }
-  }
-  if (!relay) throw new Error(`SCHEDULE_CONTINUATION_ROUND_MISSING: ${input.occurrenceId}`);
-  if (relay.status === 'blocked') throw new Error(`CONTROLLER_RELAY_LAUNCH_BLOCKED: ${relay.blockedReason ?? relay.relayScopeId}`);
-  if (!relay.authorityId) throw new Error(`CONTROLLER_ROUND_AUTHORITY_REQUIRED: ${relay.relayScopeId}`);
-
-  prepared = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_bind_round', (current, at) => ({
-    ...(current ?? prepared), relayScopeId: relay.relayScopeId, controllerAuthorityId: relay.authorityId, status: 'prepared', updatedAt: at,
-  }));
-
-  updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_dispatch_begin', (current, at) => ({
-    ...(current ?? prepared), status: 'dispatching', updatedAt: at,
-  }));
-  try {
-    const result = await host.resume(bindingRecord.binding, {
-      workId: work.workId,
-      relayScopeId: relay.relayScopeId,
-      roundNumber: relay.roundCount,
-      authorityId: relay.authorityId,
-      occurrenceId: input.occurrenceId,
-      exactOriginWork: true,
-      continuationHint: input.continuationHint?.trim() || undefined,
-    });
-    if (!result.accepted) {
-      const reason = result.reason ?? 'CONTROLLER_HOST_RESUME_REJECTED';
-      if (result.waitForUser) {
-        finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, waitForUser: true, handoffId: result.handoffId, error: reason });
-        const waiting = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_wait_for_user', (current, at) => ({
-          ...(current ?? prepared), status: 'wait_for_user', reason, ...(result.handoffId ? { handoffId: result.handoffId } : {}), updatedAt: at,
-        }));
-        return { dispatch: waiting, reused: false };
-      }
-      finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, error: reason });
-      const rejected = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_rejected', (current, at) => ({
-        ...(current ?? prepared), status: 'rejected', reason, updatedAt: at,
-      }));
-      return { dispatch: rejected, reused: false };
-    }
-    finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: true, bindingId: bindingRecord.binding.bindingId, providerDispatchReceiptId: result.dispatchId });
-    const dispatched = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_dispatched', (current, at) => ({
-      ...(current ?? prepared), status: 'dispatched', ...(result.dispatchId ? { hostDispatchId: result.dispatchId } : {}), updatedAt: at,
-    }));
-    return { dispatch: dispatched, reused: false };
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    const providerDispatchOutcomeUnknown = /CONTROLLER_HOST_PROVIDER_DISPATCH_OUTCOME_UNKNOWN|CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN/i.test(reason);
-    try { finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, error: reason, outcomeUnknown: providerDispatchOutcomeUnknown }); } catch {}
-    updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_outcome_unknown', (current, at) => ({
-      ...(current ?? prepared), status: 'outcome_unknown', reason, updatedAt: at,
-    }));
-    throw error;
-  }
-}

package/packages/kernel/scheduler/domain/continuation.ts

@@ -1,38 +0,0 @@
-export type ScheduledContinuationDispatchStatus =
-  | 'prepared'
-  | 'dispatching'
-  | 'dispatched'
-  | 'wait_for_user'
-  | 'semantic_wait'
-  | 'rejected'
-  | 'outcome_unknown';
-
-export interface ScheduledContinuationDispatch {
-  schemaVersion: 1;
-  repoId: string;
-  scheduleId: string;
-  occurrenceId: string;
-  workId: string;
-  /** Observed transport/session at initial dispatch; never part of semantic occurrence identity. */
-  controllerSessionId: string;
-  controllerBindingId: string;
-  relayScopeId: string;
-  controllerAuthorityId?: string;
-  status: ScheduledContinuationDispatchStatus;
-  /** Projection of ControllerRound.providerDispatchReceiptId for occurrence replay diagnostics. */
-  hostDispatchId?: string;
-  handoffId?: string;
-  reason?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface ScheduledControllerContinuationInput {
-  scheduleId: string;
-  occurrenceId: string;
-  workId: string;
-  /** Observed transport/session at initial dispatch; never part of semantic occurrence identity. */
-  controllerBindingId: string;
-  relayScopeId?: string;
-  continuationHint?: string;
-}

package/packages/kernel/scheduler/infrastructure/continuation-dispatch-store.ts

@@ -1,38 +0,0 @@
-import { withControllerLock } from '../../../../src/cli/repositories/locks';
-import { readControlPlaneRecord, writeControlPlaneRecord } from '../../../../src/runtime/control-plane/persistence/sqlite-store';
-import type { ScheduledContinuationDispatch } from '../domain/continuation';
-
-const NAMESPACE = 'scheduler_continuation_dispatch';
-
-export interface SchedulerContinuationStoreOptions {
-  controllerHome: string;
-  repoId: string;
-  now?: () => string;
-}
-
-export function getScheduledContinuationDispatch(
-  options: SchedulerContinuationStoreOptions,
-  occurrenceId: string,
-): ScheduledContinuationDispatch | undefined {
-  return readControlPlaneRecord<ScheduledContinuationDispatch>(
-    options.controllerHome, NAMESPACE, options.repoId, occurrenceId,
-  )?.value;
-}
-
-export function updateScheduledContinuationDispatch(
-  options: SchedulerContinuationStoreOptions,
-  occurrenceId: string,
-  actor: string,
-  update: (current: ScheduledContinuationDispatch | undefined, now: string) => ScheduledContinuationDispatch,
-): ScheduledContinuationDispatch {
-  return withControllerLock(options.controllerHome, { scope: 'task', repoId: options.repoId, taskId: `schedule-continuation-${occurrenceId}` }, actor, () => {
-    const current = readControlPlaneRecord<ScheduledContinuationDispatch>(options.controllerHome, NAMESPACE, options.repoId, occurrenceId);
-    const at = options.now?.() ?? new Date().toISOString();
-    const value = update(current?.value, at);
-    writeControlPlaneRecord(options.controllerHome, {
-      namespace: NAMESPACE, scope: options.repoId, key: occurrenceId, schemaVersion: 1, value,
-      action: actor, expectedRevision: current?.revision ?? null,
-    });
-    return value;
-  });
-}

package/packages/kernel/work/domain/admission-policy.ts

@@ -1,34 +0,0 @@
-export interface WorkAdmissionPolicy {
-  schemaVersion: 1;
-  mode: 'normal' | 'exclusive_work' | 'convergence';
-  allowedWorkId?: string;
-  allowReadOnlyDiagnostics: true;
-  reason?: string;
-  activatedAt?: string;
-  updatedAt: string;
-}
-
-export const WORK_ADMISSION_POLICY_NAMESPACE = 'runtime_policy';
-export const WORK_ADMISSION_POLICY_SCOPE = 'global';
-export const WORK_ADMISSION_POLICY_KEY = 'work_admission';
-
-export function normalWorkAdmissionPolicy(now = new Date().toISOString()): WorkAdmissionPolicy {
-  return { schemaVersion: 1, mode: 'normal', allowReadOnlyDiagnostics: true, updatedAt: now };
-}
-
-export function assertWorkAdmissionPolicyAllows(
-  policy: WorkAdmissionPolicy,
-  input: { operation: 'create' | 'continue' | 'maintenance'; workId?: string },
-): WorkAdmissionPolicy {
-  if (policy.mode === 'normal' || input.operation === 'maintenance') return policy;
-  if (policy.mode === 'convergence') {
-    if (input.operation !== 'create') return policy;
-    throw new Error('WORK_ADMISSION_BLOCKED:CONVERGENCE:operation=create');
-  }
-  if (input.workId?.trim() === policy.allowedWorkId) return policy;
-  throw new Error(`WORK_ADMISSION_BLOCKED:P0_EXCLUSIVE_WORK:operation=${input.operation}:allowed=${policy.allowedWorkId ?? 'none'}`);
-}
-
-export function schedulerDispatchPolicyAllowed(policy: WorkAdmissionPolicy): boolean {
-  return policy.mode !== 'exclusive_work';
-}