@moretea-labs/forge 1.8.0 → 1.8.2

package/src/runtime/control-plane/facade/policy-gate.ts

@@ -14,13 +14,6 @@ export type PolicySideEffect =
   | 'destructive_remote'
   | 'raw_secret_config';
 
-export interface DirectEditBoundary {
-  scopeClear: boolean;
-  maxChangedFiles?: number;
-  maxChangedLines?: number;
-  pathsExplicit?: boolean;
-}
-
 export interface PolicyGateInput {
   capability?: CapabilityDescriptor;
   capabilityId?: string;
@@ -29,7 +22,6 @@ export interface PolicyGateInput {
   accessMode?: AccessMode;
   approvalConfirmed?: boolean;
   dryRun?: boolean;
-  directEditBoundary?: DirectEditBoundary;
 }
 
 function approvalAction(reason: string, capabilityId?: string): SuggestedNextAction {
@@ -62,11 +54,6 @@ function accessEffectFromSideEffect(sideEffect: PolicySideEffect): AccessEffect
   return 'secret_access';
 }
 
-function directEditWithinBoundary(boundary: DirectEditBoundary | undefined): boolean {
-  if (!boundary) return false;
-  return boundary.scopeClear && boundary.pathsExplicit === true && (boundary.maxChangedFiles ?? 99) <= 3 && (boundary.maxChangedLines ?? 9999) <= 200;
-}
-
 export function evaluatePolicyGate(input: PolicyGateInput): PolicyDecision {
   const capabilityId = input.capability?.capabilityId ?? input.capabilityId;
   const risk = input.risk ?? input.capability?.risk;
@@ -108,16 +95,6 @@ export function evaluatePolicyGate(input: PolicyGateInput): PolicyDecision {
     };
   }
 
-  if (sideEffect === 'local_repo_write' && directEditWithinBoundary(input.directEditBoundary)) {
-    return {
-      decision: 'allowed',
-      reason: 'Bounded direct edit is within the lightweight Direct Control policy boundary.',
-      capabilityId,
-      warnings,
-      suggestedNextActions: [],
-    };
-  }
-
   if (input.approvalConfirmed) {
     return {
       decision: 'allowed',

package/src/runtime/control-plane/facade/repository-work-admission.ts

@@ -1,5 +1,4 @@
 import type { AccessMode } from '../governance/access-policy';
-import type { RouteDecision } from '../routing/route-policy';
 import { createWorkContract, executionPlacementForWork, getWorkContract, updateWorkContract, type WorkContractStoreOptions } from '../../../../packages/kernel/work/api/index';
 import { executionPlacement, readForgeInstanceIdentity } from '../../../../packages/kernel/identity/api/index';
 import type { WorkContract } from './types';
@@ -18,12 +17,15 @@ export interface PreparedRepositoryWorkAdmissionInput {
   repoId: string;
   objective: string;
   acceptanceCriteria: string[];
-  allowedPaths: string[];
   checks: string[];
   accessMode: AccessMode;
   isolated: boolean;
   requestedBy: WorkContract['requestedBy'];
   requestId: string;
+  /** Legacy ingress-only path hints; concrete mutation scope is EditSession-owned. */
+  allowedPaths?: string[];
+  /** Legacy ingress-only path hints; concrete mutation scope is EditSession-owned. */
+  forbiddenPaths?: string[];
 }
 
 /**
@@ -39,17 +41,12 @@ export function admitPreparedRepositoryWorkContract(
     workId: input.workId,
     repoId: input.repoId,
     executionPlacement: repositoryExecutionPlacement(store, input.repoId),
-    mode: input.isolated ? 'goal_workloop' : 'direct_control',
     objective: input.objective,
     acceptanceCriteria: input.acceptanceCriteria,
-    allowedPaths: input.allowedPaths,
-    forbiddenPaths: [],
     checks: input.checks,
     constraints: {
       accessMode: input.accessMode,
       workspaceMode: input.isolated ? 'isolated' : 'current',
-      requireWorktree: input.isolated,
-      directMainProhibited: input.isolated,
       allowCommit: true,
       allowMerge: true,
       allowCleanup: true,
@@ -71,27 +68,26 @@ export interface DirectEditWorkAdmissionInput {
   controllerInstanceId?: string;
   baseRevision?: string;
   workspaceFingerprint: string;
-  routeDecision: RouteDecision;
   objective: string;
   issueId?: string;
   taskId?: string;
-  allowedPaths: string[];
   checks: string[];
   requestedBy: WorkContract['requestedBy'];
+  /** Legacy ingress-only path hints; concrete mutation scope is EditSession-owned. */
+  allowedPaths?: string[];
+  /** Legacy ingress-only path hints; concrete mutation scope is EditSession-owned. */
+  forbiddenPaths?: string[];
 }
 
 /**
  * Canonical compatibility admission for an Edit Session bound to Direct Work.
- * The caller supplies the canonical Route Policy decision as evidence; this
- * boundary rejects any decision that requires isolation or a non-direct lane.
+ * Direct-edit admission is selected explicitly by this capability boundary;
+ * no route/mode token authorizes or rejects the operation.
  */
 export function admitDirectEditWorkContract(
   store: WorkContractStoreOptions,
   input: DirectEditWorkAdmissionInput,
 ): WorkContract {
-  if (input.routeDecision.executionMode !== 'direct_control' || input.routeDecision.requiresIsolation) {
-    throw new Error('DIRECT_EDIT_WORK_ROUTE_CONFLICT: canonical Route Policy does not permit Direct Control');
-  }
   return createWorkContract(store, {
     workId: input.workId,
     repoId: input.repoId,
@@ -101,20 +97,15 @@ export function admitDirectEditWorkContract(
     controllerInstanceId: input.controllerInstanceId,
     baseRevision: input.baseRevision,
     workspaceFingerprint: input.workspaceFingerprint,
-    routeDecisionFingerprint: input.routeDecision.inputFingerprint,
-    routeDecision: input.routeDecision,
-    mode: 'direct_control',
     objective: input.objective,
     acceptanceCriteria: [],
-    constraints: { workspaceMode: 'current', requireWorktree: false, requireHandoffOnAmbiguity: true },
+    constraints: { workspaceMode: 'current' },
     risk: 'low',
-    status: 'running',
+    dispatchState: 'running',
     phase: 'implementation',
     issueId: input.issueId,
     taskId: input.taskId,
     scopeSummary: input.objective,
-    allowedPaths: input.allowedPaths,
-    forbiddenPaths: [],
     checks: input.checks,
     requestedBy: input.requestedBy,
     evidenceRefs: [],
@@ -160,6 +151,5 @@ export function materializeRepositoryWorkPlacement(
     }),
     baseRevision: workspace.baseRevision ?? contract.baseRevision,
     worktreeRef: workspace.root,
-    driver: { ...contract.driver, preferred: 'isolated_worktree', allowDirectEdit: false },
   });
 }

package/src/runtime/control-plane/facade/requirement-authority.ts

@@ -1,20 +1,14 @@
 import {
+  bindRequirementCandidateAuditRef,
   createRequirement,
+  listRequirements,
   readRequirement,
-  updateRequirement,
   type CreateRequirementInput,
   type Requirement,
   type RequirementStoreOptions,
 } from '../persistence/requirement-store';
-import { readPlanContractStore } from './plan-contract-store';
-import { withPlanAdmissionLock } from './semantic-admission';
-import {
-  getControllerRoundRelay,
-  submitControllerRoundDisposition,
-  type ControllerRoundRelayRecord,
-  type SubmitControllerRoundDispositionInput,
-} from '../../../../packages/kernel/controller/api/index';
-import { getWorkContract } from '../../../../packages/kernel/work/api/index';
+import { cognitionMemoryStore } from '../persistence/cognition-store';
+import { memoryAddressKey, type MemoryUnit } from '../../../../packages/kernel/cognition/api/index';
 
 export type RequirementAdmissionDecision = 'created' | 'reuse_existing' | 'existing_conflict';
 
@@ -47,6 +41,7 @@ export function normalizeRequirementAdmissionInput(input: CreateRequirementInput
     acceptanceCriteria: bounded(input.acceptanceCriteria, 50),
     requiredDeliveryReferences: bounded(input.requiredDeliveryReferences, 50),
     legacyAliases: bounded(input.legacyAliases, 20, 160),
+    auditRefs: bounded(input.auditRefs, 50),
   };
   if (!normalized.title || !normalized.outcomeStatement) throw new Error('REQUIREMENT_CONTENT_REQUIRED');
   return normalized;
@@ -92,210 +87,118 @@ export function admitRequirement(
   }
 }
 
+export type RequirementCandidatePromotionDecision =
+  | RequirementAdmissionDecision
+  | 'candidate_already_promoted';
 
-export interface RequirementContinueResult {
-  requirement: Requirement;
-  resumed: boolean;
-}
-
-/**
- * Canonical explicit semantic continue for a Requirement that is waiting on
- * ChatGPT/user judgement. Persistence owns transition legality; this facade
- * owns the semantic meaning so adapters and launchers never mutate Requirement
- * state directly.
- */
-export function continueRequirement(
-  options: RequirementStoreOptions,
-  requirementId: string,
-): RequirementContinueResult {
-  const normalizedId = String(requirementId ?? '').trim();
-  const current = readRequirement(options, normalizedId)?.value;
-  if (!current) throw new Error(`REQUIREMENT_NOT_FOUND: ${normalizedId}`);
-  if (current.state === 'active') return { requirement: current, resumed: false };
-  if (current.state === 'done' || current.state === 'cancelled') {
-    throw new Error(`REQUIREMENT_TERMINAL: ${current.requirementId}:${current.state}`);
-  }
-  if (current.state !== 'waiting_for_user') {
-    throw new Error(`REQUIREMENT_CONTINUE_NOT_WAITING: ${current.requirementId}:${current.state}`);
-  }
-
-  const requirement = updateRequirement(options, {
-    requirementId: current.requirementId,
-    action: 'requirement_semantic_continue',
-    mutate: (latest) => {
-      if (latest.state === 'active') return latest;
-      if (latest.state === 'done' || latest.state === 'cancelled') {
-        throw new Error(`REQUIREMENT_TERMINAL: ${latest.requirementId}:${latest.state}`);
-      }
-      if (latest.state !== 'waiting_for_user') {
-        throw new Error(`REQUIREMENT_CONTINUE_NOT_WAITING: ${latest.requirementId}:${latest.state}`);
-      }
-      return {
-        ...latest,
-        state: 'active',
-        needsAttention: false,
-        attentionSummary: undefined,
-      };
-    },
-  });
-  return { requirement, resumed: true };
-}
-
-export interface RequirementAcceptanceResult {
-  requirement: Requirement;
-  accepted: boolean;
-  finalizedPlanIds: string[];
-}
-
-export interface RequirementAcceptanceReadiness {
+export interface RequirementCandidatePromotionResult {
+  decision: RequirementCandidatePromotionDecision;
   requirement: Requirement;
-  finalizedPlanIds: string[];
+  created: boolean;
+  candidateAuditRef: string;
+  candidateMemoryId: string;
+  workspaceId: string;
 }
 
-function requirementAcceptanceContext(
-  options: RequirementStoreOptions & { repoId: string },
-  input: { requirementId: string; workId: string; reviewer: string; rationale: string },
-): RequirementAcceptanceReadiness {
-  const requirementId = String(input.requirementId ?? '').trim();
-  const workId = String(input.workId ?? '').trim();
-  const reviewer = String(input.reviewer ?? '').trim();
-  const rationale = String(input.rationale ?? '').trim();
-  if (!requirementId) throw new Error('REQUIREMENT_ACCEPTANCE_ID_REQUIRED');
-  if (!workId) throw new Error('REQUIREMENT_ACCEPTANCE_WORK_REQUIRED');
-  if (!reviewer || !rationale) throw new Error('REQUIREMENT_ACCEPTANCE_METADATA_REQUIRED');
-
-  const current = readRequirement(options, requirementId)?.value;
-  if (!current) throw new Error(`REQUIREMENT_NOT_FOUND: ${requirementId}`);
-  if (current.state === 'cancelled') throw new Error(`REQUIREMENT_TERMINAL: ${requirementId}:cancelled`);
-  if (current.state === 'planned') throw new Error(`REQUIREMENT_ACCEPTANCE_NOT_ACTIVE: ${requirementId}:planned`);
-  if (current.state === 'done') {
-    return { requirement: current, finalizedPlanIds: current.semanticAcceptance?.planIds ?? [] };
-  }
-
-  const currentPlans = readPlanContractStore({ controllerHome: options.controllerHome, repoId: options.repoId, now: options.now })
-    .contracts
-    .filter((plan) => plan.requirementId === requirementId && !plan.supersededBy?.trim() && plan.status !== 'superseded');
-  const incomplete = currentPlans.filter((plan) => plan.status !== 'finalized');
-  if (incomplete.length > 0) {
-    throw new Error(`REQUIREMENT_ACCEPTANCE_PLAN_INCOMPLETE: ${incomplete.map((plan) => `${plan.planId}:${plan.status}`).join(',')}`);
-  }
-  const work = getWorkContract({ controllerHome: options.controllerHome, repoId: options.repoId }, workId);
-  if (!work) throw new Error(`REQUIREMENT_ACCEPTANCE_WORK_NOT_FOUND: ${workId}`);
-  if (work.requirementId !== requirementId) throw new Error(`REQUIREMENT_ACCEPTANCE_WORK_MISMATCH: ${workId}:${work.requirementId ?? 'none'}:${requirementId}`);
-  if (work.status !== 'completed') throw new Error(`REQUIREMENT_ACCEPTANCE_WORK_NOT_COMPLETED: ${workId}:${work.status}`);
-  return { requirement: current, finalizedPlanIds: currentPlans.map((plan) => plan.planId).sort() };
+function activeRequirementCandidate(memory: MemoryUnit, at: string): boolean {
+  return !memory.retractedAt
+    && memory.validFrom <= at
+    && (!memory.expiresAt || memory.expiresAt > at)
+    && memory.facets.includes('candidate-finding')
+    && memory.facets.includes('requirement-candidate')
+    && memory.facets.includes('advisory')
+    && memory.concepts.includes('forge.requirement-candidate')
+    && memory.provenance.sourceKind === 'system'
+    && Boolean(memory.provenance.sourceId?.startsWith('cognitive-requirement-candidate:promoted:'))
+    && memory.provenance.evidenceRefs.length > 0;
 }
 
-function acceptRequirementOutcomeUnlocked(
-  options: RequirementStoreOptions & { repoId: string },
-  input: { requirementId: string; workId: string; reviewer: string; rationale: string },
-): RequirementAcceptanceResult {
-  const context = requirementAcceptanceContext(options, input);
-  const requirementId = context.requirement.requirementId;
-  const reviewer = String(input.reviewer ?? '').trim();
-  const rationale = String(input.rationale ?? '').trim();
-  const relay = getControllerRoundRelay({ controllerHome: options.controllerHome, repoId: options.repoId }, input.workId);
-  if (!relay) throw new Error(`REQUIREMENT_ACCEPTANCE_GOAL_COMPLETE_REQUIRED: ${input.workId}:missing_relay`);
-  if (relay.originWorkId !== input.workId
-    || relay.requirementId !== requirementId
-    || relay.disposition !== 'goal_complete'
-    || relay.status !== 'goal_complete') {
-    throw new Error(`REQUIREMENT_ACCEPTANCE_GOAL_COMPLETE_REQUIRED: ${input.workId}:${relay.status}:${relay.disposition}`);
-  }
-  if (relay.principalId !== reviewer) {
-    throw new Error(`REQUIREMENT_ACCEPTANCE_CONTROLLER_MISMATCH: ${input.workId}:${relay.principalId}:${reviewer}`);
+function validatedRequirementCandidate(
+  options: RequirementStoreOptions,
+  workspaceId: string,
+  candidateMemoryId: string,
+): MemoryUnit {
+  const workspace = String(workspaceId ?? '').trim();
+  const memoryId = String(candidateMemoryId ?? '').trim();
+  if (!workspace || !memoryId) throw new Error('REQUIREMENT_CANDIDATE_SCOPE_REQUIRED');
+  const scope = { schemaVersion: 1 as const, kind: 'workspace' as const, id: workspace };
+  const store = cognitionMemoryStore(options.controllerHome);
+  const candidate = store.read(scope, memoryId);
+  if (!candidate || !activeRequirementCandidate(candidate, options.now?.() ?? new Date().toISOString())) {
+    throw new Error(`REQUIREMENT_CANDIDATE_INVALID: ${memoryId}`);
   }
-  if (context.requirement.state === 'done') {
-    return { requirement: context.requirement, accepted: false, finalizedPlanIds: context.finalizedPlanIds };
+  const sourceId = candidate.provenance.sourceId!.slice('cognitive-requirement-candidate:'.length);
+  const source = store.read(scope, sourceId);
+  if (!source
+    || !source.id.startsWith('promoted:')
+    || source.retractedAt
+    || !source.facets.includes('cross-project')
+    || !source.facets.includes('engineering-principle')
+    || candidate.provenance.evidenceRefs.some(ref => !source.provenance.evidenceRefs.includes(ref))) {
+    throw new Error(`REQUIREMENT_CANDIDATE_SOURCE_INVALID: ${memoryId}`);
   }
-
-  const acceptedAt = options.now?.() ?? new Date().toISOString();
-  let accepted = false;
-  const requirement = updateRequirement(options, {
-    requirementId,
-    action: 'requirement_semantic_acceptance',
-    mutate: (latest) => {
-      if (latest.state === 'done') return latest;
-      if (latest.state === 'cancelled') throw new Error(`REQUIREMENT_TERMINAL: ${requirementId}:cancelled`);
-      if (latest.state === 'planned') throw new Error(`REQUIREMENT_ACCEPTANCE_NOT_ACTIVE: ${requirementId}:planned`);
-      accepted = true;
-      return {
-        ...latest,
-        state: 'done',
-        needsAttention: false,
-        attentionSummary: undefined,
-        semanticAcceptance: {
-          reviewer: reviewer.slice(0, 256),
-          rationale: rationale.slice(0, 2_000),
-          planIds: context.finalizedPlanIds,
-          acceptedAt,
-        },
-      };
-    },
-  });
-  return { requirement, accepted, finalizedPlanIds: context.finalizedPlanIds };
+  return candidate;
 }
 
-/**
- * Canonical explicit semantic acceptance for a Requirement. Direct callers are
- * serialized with Plan admission so Requirement completion cannot race a new
- * current Plan slice into existence.
- */
-export function acceptRequirementOutcome(
-  options: RequirementStoreOptions & { repoId: string },
-  input: { requirementId: string; workId: string; reviewer: string; rationale: string },
-): RequirementAcceptanceResult {
-  return withPlanAdmissionLock(options, () => acceptRequirementOutcomeUnlocked(options, input));
+export function requirementCandidateAuditRef(workspaceId: string, candidate: Pick<MemoryUnit, 'id' | 'revision'>): string {
+  const scope = { schemaVersion: 1 as const, kind: 'workspace' as const, id: String(workspaceId).trim() };
+  return `cognitive-requirement-candidate:${memoryAddressKey({ scope, id: candidate.id })}:r${candidate.revision}`;
 }
 
-export interface RequirementGoalCompletionResult {
-  relay: ControllerRoundRelayRecord;
-  requirementAcceptance: RequirementAcceptanceResult;
+function requirementByCandidateAuditRef(options: RequirementStoreOptions, candidateAuditRef: string): Requirement | undefined {
+  return listRequirements(options, 1000)
+    .map(record => record.value)
+    .find(requirement => requirement.auditRefs.includes(candidateAuditRef));
 }
 
-/**
- * One Goal application boundary for Requirement-bound goal_complete. The same
- * short semantic lock used by Plan admission covers readiness, ControllerRound
- * disposition persistence, and Requirement acceptance. A retry reuses an
- * already-recorded goal_complete relay and repairs only the missing Requirement
- * projection; no second ControllerRound or Plan authority is created.
- */
-export function completeRequirementGoal(
-  options: RequirementStoreOptions & { repoId: string },
-  input: Omit<SubmitControllerRoundDispositionInput, 'disposition' | 'requirementId' | 'reason'> & {
-    requirementId: string;
-    rationale: string;
+export function promoteRequirementCandidate(
+  options: RequirementStoreOptions,
+  input: Omit<CreateRequirementInput, 'auditRefs'> & {
+    workspaceId: string;
+    candidateMemoryId: string;
   },
-): RequirementGoalCompletionResult {
-  return withPlanAdmissionLock(options, () => {
-    const reviewer = input.identity.principalId.trim();
-    const readinessInput = {
-      requirementId: input.requirementId,
-      workId: input.workId,
-      reviewer,
-      rationale: input.rationale,
+): RequirementCandidatePromotionResult {
+  const candidate = validatedRequirementCandidate(options, input.workspaceId, input.candidateMemoryId);
+  const candidateAuditRef = requirementCandidateAuditRef(input.workspaceId, candidate);
+  const prior = requirementByCandidateAuditRef(options, candidateAuditRef);
+  if (prior && prior.requirementId !== String(input.requirementId ?? '').trim()) {
+    return {
+      decision: 'candidate_already_promoted',
+      requirement: prior,
+      created: false,
+      candidateAuditRef,
+      candidateMemoryId: candidate.id,
+      workspaceId: input.workspaceId,
     };
-    requirementAcceptanceContext(options, readinessInput);
+  }
 
-    const existing = getControllerRoundRelay(options, input.workId);
-    let relay: ControllerRoundRelayRecord;
-    if (existing?.status === 'goal_complete' && existing.disposition === 'goal_complete') {
-      relay = existing;
-    } else {
-      try {
-        relay = submitControllerRoundDisposition(options, {
-          ...input,
-          disposition: 'goal_complete',
-          requirementId: input.requirementId,
-          reason: input.rationale,
-        });
-      } catch (error) {
-        const raced = getControllerRoundRelay(options, input.workId);
-        if (!raced || raced.status !== 'goal_complete' || raced.disposition !== 'goal_complete') throw error;
-        relay = raced;
-      }
-    }
-    const requirementAcceptance = acceptRequirementOutcomeUnlocked(options, readinessInput);
-    return { relay, requirementAcceptance };
-  });
+  try {
+    const admission = admitRequirement(options, {
+      ...input,
+      auditRefs: [candidateAuditRef],
+    });
+    const requirement = admission.decision === 'reuse_existing'
+      && !admission.requirement.auditRefs.includes(candidateAuditRef)
+      ? bindRequirementCandidateAuditRef(options, admission.requirement.requirementId, candidateAuditRef)
+      : admission.requirement;
+    return {
+      ...admission,
+      requirement,
+      candidateAuditRef,
+      candidateMemoryId: candidate.id,
+      workspaceId: input.workspaceId,
+    };
+  } catch (error) {
+    if (!(error instanceof Error) || error.message !== 'REQUIREMENT_CANDIDATE_ALREADY_PROMOTED') throw error;
+    const raced = requirementByCandidateAuditRef(options, candidateAuditRef);
+    if (!raced) throw error;
+    return {
+      decision: 'candidate_already_promoted',
+      requirement: raced,
+      created: false,
+      candidateAuditRef,
+      candidateMemoryId: candidate.id,
+      workspaceId: input.workspaceId,
+    };
+  }
 }

package/src/runtime/control-plane/facade/requirement-board.ts

@@ -77,7 +77,7 @@ function loadScopedWork(options: RequirementBoardOptions): WorkContract[] {
   return listWorkContracts({
     controllerHome: options.controllerHome,
     repoId: options.repoId,
-    status: 'all',
+    state: 'all',
     limit: 100,
   });
 }
@@ -224,7 +224,7 @@ function summarizeDiagnosticWork(work: WorkContract): Record<string, unknown> {
       worktreeRef: work.worktreeRef,
       handoffRefs: work.handoffRefs.slice(-3),
     },
-    detailPointer: { tool: 'work_get', arguments: { work_id: work.workId, include_events: true } },
+    detailPointer: { tool: 'rh_work', arguments: { operation: 'get', work_id: work.workId, detail_level: 'detail' } },
   };
 }
 
@@ -292,7 +292,7 @@ export function buildExecutionDiagnostics(
     maintenanceFindingTruncatedCount: Math.max(0, requirements.filter((requirement) => requirement.needsAttention).length - maintenanceFindings.length),
     projectionWarnings,
     technicalDetailPointers: [
-      { tool: 'work_list', arguments: { limit: 50 } },
+      { tool: 'rh_context', arguments: { operation: 'list', detail_level: 'detail' } },
       { tool: 'controller_ready', arguments: {} },
       { tool: 'workflow_watchdog_report', arguments: { include_processes: true } },
       { tool: 'get_project_governance', arguments: {} },

package/src/runtime/control-plane/facade/rh-work-operation-contract.ts

@@ -8,26 +8,20 @@
  */
 export const RH_WORK_OPERATIONS = [
   'start',
-  'continue',
-  'verify',
-  'review',
   'repair',
-  'finalize',
-  'stop',
-  'delegate',
-  'controller_claim',
-  'controller_release',
-  'controller_disposition',
-  'controller_get_owner',
+  'list',
+  'get',
+  'revise',
+  'complete',
   'launcher_start',
   'requirement_create',
-  'requirement_continue',
+  'requirement_get',
+  'requirement_revise',
+  'requirement_promote_candidate',
   'plan_create',
   'plan_get',
+  'plan_revise',
   'plan_list',
-  'plan_approve',
-  'plan_accept_step',
-  'plan_supersede',
   'schedule_create',
   'schedule_list',
   'schedule_get',
@@ -37,6 +31,45 @@ export const RH_WORK_OPERATIONS = [
   'schedule_trigger',
   'workflow_execute',
   'workflow_reconcile',
+  'learning_record',
+  'learning_feedback',
+  'outcome_record',
+  'experience_record',
+] as const;
+
+/**
+ * There is intentionally no legacy lifecycle operation set.  A Runtime that
+ * has rolled over to Thin Forge rejects the former verify/review/finalize and
+ * controller-claim vocabulary instead of silently translating it.
+ */
+
+export const RH_WORK_MODEL_OPERATIONS = [
+  'start',
+  'repair',
+  'list',
+  'get',
+  'revise',
+  'complete',
+  'launcher_start',
+  'requirement_create',
+  'requirement_get',
+  'requirement_revise',
+  'requirement_promote_candidate',
+  'plan_create',
+  'plan_get',
+  'plan_revise',
+  'plan_list',
+  'schedule_create',
+  'schedule_list',
+  'schedule_get',
+  'schedule_pause',
+  'schedule_resume',
+  'schedule_delete',
+  'schedule_trigger',
+  'workflow_execute',
+  'workflow_reconcile',
+  'learning_record',
+  'learning_feedback',
   'outcome_record',
   'experience_record',
 ] as const;
@@ -46,3 +79,7 @@ export type RhWorkOperation = (typeof RH_WORK_OPERATIONS)[number];
 export function isRhWorkOperation(operation: string): operation is RhWorkOperation {
   return (RH_WORK_OPERATIONS as readonly string[]).includes(operation);
 }
+
+export function isRhWorkAcceptedOperation(operation: string): boolean {
+  return isRhWorkOperation(operation);
+}