Add Epiphany CRRC safe-boundary automation

This commit is contained in:
Meta Vens 2026-04-28 19:03:25 +01:00
commit 86ba6de5a9
6 changed files with 248 additions and 19 deletions

View file

@ -76,6 +76,7 @@ The landed machine now has:
- explicit Phase 6 reorient-worker finding acceptance through `thread/epiphany/reorientAccept`
- read-only Phase 6 CRRC coordinator recommendation through `thread/epiphany/crrc`
- read-only Phase 6 fixed-lane MVP coordinator recommendation through `thread/epiphany/coordinator`, composing roles, pressure, reorient, CRRC, role results, and reorient result without mutation
- limited native Phase 6 CRRC automation at turn-complete safe boundaries, restricted to coordinator-approved compact and fixed reorient-worker launch actions
- read-only Phase 6 role ownership through `thread/epiphany/roles`, projecting implementation, modeling/checkpoint, verification/review, and reorientation lanes from typed state plus jobs/CRRC/result signals
- explicit Phase 6 role launch/read-back through `thread/epiphany/roleLaunch` and read-only `thread/epiphany/roleResult`, limited to fixed modeling/checkpoint and verification/review templates over the existing job-control seam
- first Phase 6 dogfood operator view through `tools/epiphany_mvp_status.py`
@ -111,6 +112,7 @@ These boundaries are more important than the individual method names:
- `thread/epiphany/reorient` is a bounded policy verdict, not an automatic runtime coordinator, scheduler, compactor, or hidden state writer.
- `thread/epiphany/crrc` is a read-only coordinator recommendation over existing signals, not a scheduler, launch button, acceptance gate, compactor, or hidden state writer.
- `thread/epiphany/coordinator` is a read-only fixed-lane MVP policy projection over existing signals, not a scheduler, launcher, acceptance gate, compactor, or hidden state writer.
- Native CRRC automation may act only at safe turn-complete boundaries and only for coordinator-approved `compactRehydrateReorient` and `launchReorientWorker` actions. It must not auto-launch modeling or verification, auto-accept semantic findings, promote evidence, edit implementation code, or silently continue after unresolved drift.
- `thread/epiphany/roles` is a read-only role ownership projection, not a specialist scheduler, marketplace, launcher, acceptance gate, or second job backend.
- `thread/epiphany/roleLaunch` is a bounded authority surface for fixed modeling/checkpoint and verification/review templates, not a broad scheduler or specialist marketplace.
- `thread/epiphany/roleResult` is a read-only result projection, not a promotion gate, state writer, scheduler, or hidden continuation trigger.
@ -209,9 +211,10 @@ workspace, report through `report_agent_job_result`, and return a completed
`checkpoint-ready` finding through `roleResult`. The coordinator runner then
proved the sequence-locked MVP policy across cold start, clean checkpoint,
modeling, verification, CRRC drift/reorient, and high-pressure compact/dry-run
paths. The next MVP question is human operator testing, not another imagined
organ: use the landed coordinator/status/artifact loop, then fix only concrete
blockers.
paths. Native CRRC automation then wired the proved policy into turn-complete
safe boundaries for compact and fixed reorient-worker launch only. The next MVP
question is human operator testing, not another imagined organ: use the landed
coordinator/status/artifact loop, then fix only concrete blockers.
## Phase 6 Direction
@ -221,7 +224,7 @@ Useful candidates:
1. Put the fixed-lane coordinator MVP in front of a human operator through status/artifact review, then fix concrete usability blockers.
2. Keep accepted worker findings review-gated; do not convert acceptance into automatic promotion of arbitrary worker output.
3. After the coordinator artifacts prove the policy, add only limited safe-boundary CRRC automation: compact/resume/reorient or launch a bounded reorient-worker when the coordinator says it is safe, without silently accepting semantic findings.
3. Dogfood the landed safe-boundary CRRC automation on real work and fix only concrete blockers in compact/reorient-worker launch behavior.
Do not spend Phase 6 polishing Phase 5 out of anxiety. The Phase 5 smoke harness
is a regression guardrail, not a ritual drum circle for summoning more tiny
@ -236,7 +239,7 @@ These remain later work:
- richer evidence and graph-shard inspection beyond the landed targeted context read
- richer role ergonomics after the fixed single-user coordinator proves useful
- mutation gates that warn or block broad writes when map freshness is stale
- broader CRRC runtime coordination beyond the narrow safe-boundary actions proved by the MVP coordinator
- broader CRRC runtime coordination beyond the landed narrow safe-boundary compact and fixed reorient-worker launch actions
- GUI workflows for graph, evidence, job, invariant, and frontier steering
Do not start these from vibes. Each one needs a source-grounded slice plan and a

View file

@ -31,6 +31,7 @@ Do not trust this file for the exact live HEAD. Always check git.
- Phase 6 has read-only `thread/epiphany/scene`, `thread/epiphany/jobs`, `thread/epiphany/roles`, `thread/epiphany/freshness`, `thread/epiphany/context`, `thread/epiphany/pressure`, `thread/epiphany/reorient`, `thread/epiphany/crrc`, `thread/epiphany/coordinator`, `thread/epiphany/reorientResult`, and `thread/epiphany/roleResult`; durable `jobBindings` now act as a thin Epiphany-owned launcher seam with launcher id, authority scope, and backend kind/job id, `thread/epiphany/jobLaunch` / `thread/epiphany/jobInterrupt` / `thread/epiphany/roleLaunch` now provide explicit bounded authority over that seam, jobs can overlay it onto live runtime `agent_jobs` progress for loaded threads, and `thread/epiphany/jobsUpdated` now translates live `agent_job_progress:{json}` background events into changed launcher-bound notifications without polling or scheduling. Freshness carries watcher-backed invalidation inputs, roles project implementation/modeling/verification/reorientation ownership from existing signals without becoming a scheduler, `roleLaunch` can launch only fixed modeling/checkpoint or verification/review specialists, `roleResult` reads those outputs back as reviewable findings without mutation, reorient turns checkpoint plus freshness/pressure/watcher signals into a read-only resume-versus-regather verdict, `thread/epiphany/reorientLaunch` is the explicit runtime consumer over that verdict, `thread/epiphany/reorientResult` reads the launched worker output back as a reviewable finding without mutation or promotion, `thread/epiphany/reorientAccept` explicitly banks completed findings into accepted observation/evidence plus optional scratch/checkpoint state, `thread/epiphany/crrc` recommends the next explicit CRRC action without launching, accepting, compacting, scheduling, or mutating, and `thread/epiphany/coordinator` composes those signals into a fixed-lane MVP action recommendation without becoming a writer.
- `tools/epiphany_mvp_status.py` is the first dogfood operator view. It starts or reads a thread through app-server and prints scene, pressure, reorient, jobs, roles, modeling/verification role result read-backs, reorient result, and CRRC recommendation as text or JSON.
- `tools/epiphany_mvp_coordinator.py` is the first auditable fixed-lane coordinator runner. It starts or reads a thread through app-server, follows the harness-native coordinator action, can auto-launch modeling, verification, or reorient-worker jobs, keeps semantic findings review-gated by default, and writes summary, steps, rendered snapshots, transcript, stderr, and final next-action artifacts under `.epiphany-dogfood/coordinator` or a caller-provided artifact directory.
- Native CRRC automation is now landed only at turn-complete safe boundaries. It may submit `Op::Compact` for coordinator-approved `compactRehydrateReorient`, and it may launch the fixed `reorient-worker` for coordinator-approved `launchReorientWorker`. It does not auto-launch modeling/verification, accept findings, promote evidence, edit implementation code, or keep going after reviewable semantic output.
- `tools/epiphany_mvp_dogfood.py` is the first auditable dogfood runner. It drives a bounded state/role/CRRC/reorientation loop and writes local artifacts under `.epiphany-dogfood/mvp-loop`, including raw app-server transcript, rendered snapshots, final status, vanilla-reference prompt/output, and comparison notes.
- `tools/epiphany_mvp_live_specialist.py` is the first auditable live-specialist runner. It launches a real role specialist through `thread/epiphany/roleLaunch`, lets the spawned worker report through `report_agent_job_result`, reads it back through `thread/epiphany/roleResult`, and writes local artifacts under `.epiphany-dogfood/live-specialist`.
- Internal `agent_job:` workers now get the reporting tool independent of the user-facing CSV spawn feature, and ephemeral worker sessions can initialize the sqlite state runtime on demand so specialist reports land in the shared backend.
@ -86,6 +87,7 @@ The current spine:
- read-only CRRC reorientation policy through `thread/epiphany/reorient`
- read-only CRRC next-action recommendation through `thread/epiphany/crrc`
- read-only fixed-lane MVP action recommendation through `thread/epiphany/coordinator`
- limited turn-complete CRRC automation for coordinator-approved compact and fixed reorient-worker launch actions
- durable investigation checkpoint packet through typed state, prompt, scene, and context
- live scene app-server smoke through `tools/epiphany_phase6_scene_smoke.py`
- live jobs app-server smoke through `tools/epiphany_phase6_jobs_smoke.py`
@ -291,13 +293,13 @@ The fixed-lane coordinator MVP is now testable. Put it in front of a human
operator through `tools/epiphany_mvp_coordinator.py`,
`tools/epiphany_mvp_status.py`, `.epiphany-dogfood/coordinator`,
`.epiphany-dogfood/mvp-loop`, and `.epiphany-dogfood/live-specialist`. Fix
concrete blockers in that operator loop. The next likely organ, after real
operator artifacts justify it, is limited safe-boundary CRRC execution that can
compact/resume/reorient or launch a bounded reorient-worker when the read-only
coordinator says it is safe. CRRC is not a specialist-agent persona; the
reorient-worker it may launch is the specialist. Do not turn the coordinator
into a broad hidden dispatcher, arbitrary marketplace, alternate job backend, or
GUI-as-source-of-truth.
concrete blockers in that operator loop. Limited safe-boundary CRRC execution is
already wired for compact and fixed reorient-worker launch actions, so the next
unknown is how it behaves under real operator pressure, not which speculative
organ to invent. CRRC is not a specialist-agent persona; the reorient-worker it
may launch is the specialist. Do not turn the coordinator into a broad hidden
dispatcher, arbitrary marketplace, alternate job backend, automatic semantic
acceptance path, or GUI-as-source-of-truth.
Live `thread/epiphany/scene`, `thread/epiphany/jobs`, `thread/epiphany/roles`,
`thread/epiphany/freshness`, `thread/epiphany/context`,
@ -312,7 +314,7 @@ are now guardrails, not the next organs.
- automatic observation promotion
- broad specialist-agent scheduling beyond the fixed single-user role lanes
- GUI-as-source-of-truth
- automatic runtime CRRC execution acting on the landed recommendation/verdict and launch/read-back path
- broad runtime CRRC execution beyond the landed safe-boundary compact and fixed reorient-worker launch actions
- Epiphany-owned long-running job execution beyond the current runtime `agent_jobs` seam
- broad event stream beyond the landed state update notification

View file

@ -60,3 +60,4 @@
{"ts": "2026-04-28T16:52:18+00:00", "type": "implementation", "status": "ok", "note": "Clarified MVP direction: marketplace and alternate job backend are not active concerns; the scheduler-shaped need is a narrow auditable fixed-lane role coordinator over modeling, implementation, verification, and CRRC handoffs, not a broad ambient dispatcher."}
{"ts": "2026-04-28T16:56:56+00:00", "type": "design", "status": "ok", "note": "Clarified CRRC architecture: CRRC is harness workflow automation that watches context pressure and continuity, persists/checkpoints, triggers compact-rehydrate-reorient behavior, and may launch a bounded reorient-worker specialist; CRRC itself is not a specialist-agent persona."}
{"ts": "2026-04-28T18:33:53+01:00", "type": "implementation", "status": "ok", "note": "Landed the fixed-lane Epiphany MVP coordinator: read-only thread/epiphany/coordinator composes roles, pressure, reorient, CRRC, role results, and reorient result into review-gated action recommendations, and tools/epiphany_mvp_coordinator.py drives the same policy through app-server APIs with auditable artifacts. Coordinator smoke covered cold prepareCheckpoint, clean continueImplementation, modeling review, verification review, source-drift reorient review, high-pressure compact/dry-run, and complete artifact bundles."}
{"ts": "2026-04-28T18:56:47+01:00", "type": "implementation", "status": "ok", "note": "Landed limited native CRRC automation at turn-complete safe boundaries. It reuses the read-only coordinator policy and only auto-runs compactRehydrateReorient via Op::Compact or launchReorientWorker via the fixed reorient-worker job binding; modeling, verification, semantic acceptance, evidence promotion, implementation edits, and hidden continuation remain review-gated or manual. Focused coordinator automation assertions, job-progress event handling, coordinator smoke, status smoke, role smoke, and reorient-launch smoke passed."}

View file

@ -12,8 +12,8 @@ objective:
explicit typed models of the codebase, active goal, evidence, and change
machinery they are working on.
current: >
Prove the Phase 6 MVP through the landed fixed-lane coordinator and
auditable operator artifacts before adding limited CRRC automation.
Dogfood the landed Phase 6 MVP coordinator and limited CRRC safe-boundary
automation on real local work before adding larger organs.
constraints:
- No frontier-scale training budget.
@ -54,8 +54,8 @@ data_flow:
active_subgoals:
- Treat Phase 5 update/distill/propose/promote/read/notification as complete enough unless a concrete regression appears.
- Preserve read-only boundaries for retrieve, distill, propose, scene, jobs, roles, roleResult, freshness, context, pressure, reorient, crrc, coordinator, and reorientResult.
- Extend Phase 6 coordination only where it makes role dependencies explicit and auditable without becoming a broad ambient dispatcher.
- Put the dogfooded MVP loop in front of a human operator before adding larger organs.
- Dogfood the landed Phase 6 coordinator and limited safe-boundary CRRC automation before adding larger organs.
- Preserve review gates for semantic findings; automatic CRRC may compact or launch the fixed reorient-worker, but not accept or promote.
- Keep persistent project state ruthlessly distilled so rehydration strengthens the next turn instead of bloating it.
accepted_design:
@ -85,6 +85,7 @@ accepted_design:
- A narrow auditable coordinator is likely central to the MVP because implementation, modeling/checkpoint, verification/review, and CRRC automation depend on each other's signals. CRRC itself is harness workflow automation, not a specialist-agent role: it watches pressure/continuity, ensures persistence, triggers compaction/rehydration/reorientation when needed, and may launch a bounded reorient-worker specialist when semantic regathering is required.
- `thread/epiphany/coordinator` is the first harness-native fixed-lane coordinator surface: it composes roles, pressure, reorient, CRRC, roleResult, and reorientResult into a read-only action recommendation with target role, source signals, review requirements, automation eligibility, reason, and current lane summaries without mutating state or launching work.
- `tools/epiphany_mvp_coordinator.py` is the first auditable coordinator runner: it drives the fixed single-user lanes through app-server APIs, may auto-launch modeling, verification, or reorient-worker jobs, keeps semantic findings review-gated by default, and writes coordinator summaries, JSONL steps, rendered snapshots, transcript, stderr, and final next-action artifacts.
- Limited native CRRC automation is now wired only at turn-complete safe boundaries: it can submit a compact operation when the read-only coordinator recommends `compactRehydrateReorient`, and it can launch the fixed `reorient-worker` when the coordinator recommends `launchReorientWorker`. It does not auto-launch modeling or verification, auto-accept findings, promote evidence, edit implementation code, or continue after reviewable semantic results.
- `tools/epiphany_mvp_status.py` is the first dogfood operator view: it starts or reads a thread through app-server and renders scene, pressure, reorient, jobs, role result read-backs, reorient result, CRRC recommendation, and MVP role lanes as text or JSON without becoming a state store.
- `thread/epiphany/roles` is the first harness-native role ownership surface: it projects implementation, modeling/checkpoint, verification/review, and reorientation lanes from authoritative typed state, bound jobs, pressure/reorient/CRRC, and worker result status without launching, scheduling, accepting, compacting, or mutating state.
- `thread/epiphany/roleLaunch` and `thread/epiphany/roleResult` are the first explicit role-scoped specialist templates: modeling/checkpoint and verification/review can be launched through fixed bindings over the existing job-control seam and read back as reviewable findings, while implementation stays owned by the main coding agent and reorientation stays on the CRRC-specific launch/result path.
@ -121,6 +122,7 @@ landed_baseline:
- Phase 6 role ownership: read-only `thread/epiphany/roles` over implementation, modeling/checkpoint, verification/review, and reorientation lanes.
- Phase 6 role specialists: explicit `thread/epiphany/roleLaunch` and read-only `thread/epiphany/roleResult` templates for modeling/checkpoint and verification/review.
- Phase 6 coordinator: read-only `thread/epiphany/coordinator` plus `tools/epiphany_mvp_coordinator.py` and smoke coverage for the fixed-lane MVP loop.
- Phase 6 safe-boundary CRRC automation: turn-complete automation limited to coordinator-approved compact and fixed reorient-worker launch actions.
guardrails:
- Use `tools/epiphany_phase5_smoke.py` before modifying update, distill, propose, promote, read-projection, or notification behavior.
- Use `tools/epiphany_phase6_scene_smoke.py` before modifying scene projection behavior.
@ -156,5 +158,5 @@ rejected_paths:
reason: persistent state that accumulates every local truth becomes memory cruft and weakens rehydration
current_status:
summary: Phase 1 durable state, Phase 2 prompt integration, Phase 3 typed read, Phase 4 retrieval/indexing, Phase 5 update/distill/propose/promote/read/notification, and Phase 6 read-only scene, jobs, roles, freshness, targeted context, pressure, reorient, CRRC, coordinator, reorient launch/result/accept, explicit modeling/checkpoint and verification/review role launch/result templates, MVP status, dogfood runner, coordinator runner, and live specialist runner are landed. The coordinator endpoint and runner now make fixed-lane modeling, verification, implementation continuation, and CRRC handoffs explicit through review-gated artifacts over the existing app-server/job seam. Implementation remains main-agent work; CRRC remains workflow automation, not a specialist persona. Persistent state remains distilled; evidence is a belief ledger, not an activity feed.
next_action: Dogfood the fixed-lane coordinator on real local work through `tools/epiphany_mvp_coordinator.py` and its artifact bundle. Fix concrete operator-loop blockers only; defer limited automatic CRRC safe-boundary execution until the coordinator artifacts prove the policy, and do not build a broad ambient dispatcher, GUI-as-source-of-truth, arbitrary specialist marketplace, or alternate job backend for the MVP.
summary: Phase 1 durable state, Phase 2 prompt integration, Phase 3 typed read, Phase 4 retrieval/indexing, Phase 5 update/distill/propose/promote/read/notification, and Phase 6 read-only scene, jobs, roles, freshness, targeted context, pressure, reorient, CRRC, coordinator, reorient launch/result/accept, explicit modeling/checkpoint and verification/review role launch/result templates, MVP status, dogfood runner, coordinator runner, live specialist runner, and limited safe-boundary CRRC automation are landed. The coordinator endpoint and runner make fixed-lane modeling, verification, implementation continuation, and CRRC handoffs explicit through review-gated artifacts; native automation only compacts or launches the fixed reorient-worker at turn-complete boundaries when the coordinator says it can auto-run. Implementation remains main-agent work; CRRC remains workflow automation, not a specialist persona. Persistent state remains distilled; evidence is a belief ledger, not an activity feed.
next_action: Dogfood the fixed-lane coordinator and native CRRC safe-boundary automation on real local work through `tools/epiphany_mvp_coordinator.py`, `tools/epiphany_mvp_status.py`, and their artifact bundles. Fix concrete operator-loop blockers only; do not build a broad ambient dispatcher, GUI-as-source-of-truth, arbitrary specialist marketplace, alternate job backend, or automatic semantic acceptance for the MVP.

View file

@ -1,8 +1,10 @@
use crate::codex_message_processor::ApiVersion;
use crate::codex_message_processor::maybe_run_epiphany_coordinator_automation_for_turn_boundary;
use crate::codex_message_processor::read_rollout_items_from_rollout;
use crate::codex_message_processor::read_summary_from_rollout;
use crate::codex_message_processor::summary_to_thread;
use crate::codex_message_processor::thread_epiphany_jobs_updated_notification_for_agent_job_progress;
use crate::epiphany_invalidation::EpiphanyInvalidationManager;
use crate::error_code::INTERNAL_ERROR_CODE;
use crate::error_code::INVALID_REQUEST_ERROR_CODE;
use crate::outgoing_message::ClientRequestResult;
@ -187,6 +189,7 @@ pub(crate) async fn apply_bespoke_event_handling(
outgoing: ThreadScopedOutgoingMessageSender,
thread_state: Arc<tokio::sync::Mutex<ThreadState>>,
thread_watch_manager: ThreadWatchManager,
epiphany_invalidation_manager: EpiphanyInvalidationManager,
api_version: ApiVersion,
fallback_model_provider: String,
codex_home: &Path,
@ -244,6 +247,15 @@ pub(crate) async fn apply_bespoke_event_handling(
&thread_state,
)
.await;
if !turn_failed {
maybe_run_epiphany_coordinator_automation_for_turn_boundary(
conversation_id,
conversation,
epiphany_invalidation_manager,
&outgoing,
)
.await;
}
}
EventMsg::SkillsUpdateAvailable => {
if let ApiVersion::V2 = api_version {
@ -3289,6 +3301,7 @@ mod tests {
outgoing: ThreadScopedOutgoingMessageSender,
thread_state: Arc<Mutex<ThreadState>>,
thread_watch_manager: ThreadWatchManager,
epiphany_invalidation_manager: EpiphanyInvalidationManager,
analytics_events_client: AnalyticsEventsClient,
codex_home: PathBuf,
}
@ -3308,6 +3321,7 @@ mod tests {
self.outgoing.clone(),
self.thread_state.clone(),
self.thread_watch_manager.clone(),
self.epiphany_invalidation_manager.clone(),
ApiVersion::V2,
"test-provider".to_string(),
&self.codex_home,
@ -3629,6 +3643,7 @@ mod tests {
outgoing: outgoing.clone(),
thread_state: thread_state.clone(),
thread_watch_manager: thread_watch_manager.clone(),
epiphany_invalidation_manager: EpiphanyInvalidationManager::new(),
analytics_events_client: AnalyticsEventsClient::new(
AuthManager::from_auth_for_testing(
CodexAuth::create_dummy_chatgpt_auth_for_testing(),
@ -4672,6 +4687,7 @@ mod tests {
let thread_state = new_thread_state();
let thread_watch_manager = ThreadWatchManager::new();
let epiphany_invalidation_manager = EpiphanyInvalidationManager::new();
let (tx, mut rx) = mpsc::channel(CHANNEL_CAPACITY);
let outgoing = Arc::new(OutgoingMessageSender::new(tx));
let outgoing = ThreadScopedOutgoingMessageSender::new(
@ -4706,6 +4722,7 @@ mod tests {
outgoing.clone(),
thread_state.clone(),
thread_watch_manager.clone(),
epiphany_invalidation_manager.clone(),
ApiVersion::V2,
"test-provider".to_string(),
codex_home.path(),
@ -4762,6 +4779,7 @@ mod tests {
outgoing,
thread_state,
thread_watch_manager,
epiphany_invalidation_manager,
ApiVersion::V2,
"test-provider".to_string(),
codex_home.path(),

View file

@ -10632,6 +10632,7 @@ impl CodexMessageProcessor {
thread_outgoing,
thread_state.clone(),
thread_watch_manager.clone(),
epiphany_invalidation_manager.clone(),
api_version,
fallback_model_provider.clone(),
codex_home.as_path(),
@ -13510,6 +13511,40 @@ struct EpiphanyCoordinatorDecision {
reason: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EpiphanyCoordinatorAutomationAction {
None,
CompactRehydrateReorient,
LaunchReorientWorker,
}
fn map_epiphany_coordinator_automation_action(
decision: &EpiphanyCoordinatorDecision,
) -> EpiphanyCoordinatorAutomationAction {
if !decision.can_auto_run {
return EpiphanyCoordinatorAutomationAction::None;
}
match decision.action {
ThreadEpiphanyCoordinatorAction::CompactRehydrateReorient => {
EpiphanyCoordinatorAutomationAction::CompactRehydrateReorient
}
ThreadEpiphanyCoordinatorAction::LaunchReorientWorker => {
EpiphanyCoordinatorAutomationAction::LaunchReorientWorker
}
ThreadEpiphanyCoordinatorAction::PrepareCheckpoint
| ThreadEpiphanyCoordinatorAction::WaitForReorientWorker
| ThreadEpiphanyCoordinatorAction::ReviewReorientResult
| ThreadEpiphanyCoordinatorAction::RegatherManually
| ThreadEpiphanyCoordinatorAction::LaunchModeling
| ThreadEpiphanyCoordinatorAction::ReviewModelingResult
| ThreadEpiphanyCoordinatorAction::LaunchVerification
| ThreadEpiphanyCoordinatorAction::ReviewVerificationResult
| ThreadEpiphanyCoordinatorAction::ContinueImplementation => {
EpiphanyCoordinatorAutomationAction::None
}
}
}
fn map_epiphany_coordinator(
state_status: ThreadEpiphanyReorientStateStatus,
checkpoint_present: bool,
@ -15191,6 +15226,154 @@ pub(crate) async fn thread_epiphany_jobs_updated_notification_for_agent_job_prog
})
}
pub(crate) async fn maybe_run_epiphany_coordinator_automation_for_turn_boundary(
thread_id: ThreadId,
thread: Arc<CodexThread>,
epiphany_invalidation_manager: EpiphanyInvalidationManager,
outgoing: &ThreadScopedOutgoingMessageSender,
) {
let thread_id_text = thread_id.to_string();
let Some(state) = thread.epiphany_state().await else {
return;
};
let retrieval_override = thread.epiphany_retrieval_state().await;
let config_snapshot = thread.config_snapshot().await;
epiphany_invalidation_manager
.ensure_thread_watch(&thread_id_text, &config_snapshot.cwd)
.await;
let watcher_snapshot = epiphany_invalidation_manager
.snapshot(&thread_id_text)
.await;
let token_usage_info = thread.token_usage_info().await;
let state_db_ctx = thread.epiphany_state_runtime().await;
let (_state_revision, retrieval, graph, watcher) = map_epiphany_freshness(
Some(&state),
Some(&retrieval_override),
Some(&watcher_snapshot),
);
let pressure = map_epiphany_pressure(token_usage_info.as_ref());
let (state_status, reorient_decision) =
map_epiphany_reorient(Some(&state), &pressure, &retrieval, &graph, &watcher);
if state_status != ThreadEpiphanyReorientStateStatus::Ready {
return;
}
let job_resolution =
load_epiphany_job_launcher_snapshots(state_db_ctx.as_ref(), Some(&state)).await;
let jobs = map_epiphany_jobs(Some(&state), Some(&retrieval_override), &job_resolution);
let reorient_job = jobs
.iter()
.find(|job| job.id == EPIPHANY_REORIENT_LAUNCH_BINDING_ID)
.cloned();
let (reorient_result_status, reorient_finding, _) = load_epiphany_reorient_result_snapshot(
Some(&state),
state_db_ctx.as_ref(),
EPIPHANY_REORIENT_LAUNCH_BINDING_ID,
)
.await;
let crrc_recommendation = map_epiphany_crrc_recommendation(
true,
state_status,
&pressure,
&reorient_decision,
reorient_result_status,
state.investigation_checkpoint.as_ref().is_some(),
reorient_finding.is_some(),
reorient_finding
.as_ref()
.is_some_and(|finding| epiphany_reorient_finding_already_accepted(&state, finding)),
);
let roles = map_epiphany_roles(
Some(&state),
&jobs,
&reorient_decision,
&pressure,
&crrc_recommendation,
reorient_result_status,
reorient_job.as_ref(),
);
let (modeling_result_status, _, _) = load_epiphany_role_result_snapshot(
&state,
state_db_ctx.as_ref(),
ThreadEpiphanyRoleId::Modeling,
EPIPHANY_MODELING_ROLE_BINDING_ID,
)
.await;
let (verification_result_status, _, _) = load_epiphany_role_result_snapshot(
&state,
state_db_ctx.as_ref(),
ThreadEpiphanyRoleId::Verification,
EPIPHANY_VERIFICATION_ROLE_BINDING_ID,
)
.await;
let source_signals = ThreadEpiphanyCoordinatorSignals {
pressure_level: pressure.level,
should_prepare_compaction: pressure.should_prepare_compaction,
reorient_action: reorient_decision.action,
crrc_action: crrc_recommendation.action,
modeling_result_status,
verification_result_status,
reorient_result_status,
};
let coordinator = map_epiphany_coordinator(
state_status,
state.investigation_checkpoint.as_ref().is_some(),
&pressure,
&crrc_recommendation,
&roles,
&source_signals,
);
match map_epiphany_coordinator_automation_action(&coordinator) {
EpiphanyCoordinatorAutomationAction::None => {}
EpiphanyCoordinatorAutomationAction::CompactRehydrateReorient => {
if let Err(err) = thread.submit(Op::Compact).await {
warn!(
"failed to run Epiphany coordinator automatic compaction for {thread_id}: {err}"
);
}
}
EpiphanyCoordinatorAutomationAction::LaunchReorientWorker => {
let Some(checkpoint) = state.investigation_checkpoint.as_ref() else {
return;
};
let launch_request = build_epiphany_reorient_launch_request(
&thread_id_text,
Some(state.revision),
None,
&state,
checkpoint,
&reorient_decision,
);
let launched = match thread.epiphany_launch_job(launch_request).await {
Ok(launched) => launched,
Err(err) => {
warn!(
"failed to launch Epiphany coordinator reorientation worker for {thread_id}: {err}"
);
return;
}
};
let epiphany_state =
client_visible_live_thread_epiphany_state(thread.as_ref(), launched.epiphany_state)
.await;
outgoing
.send_server_notification(ServerNotification::ThreadEpiphanyStateUpdated(
ThreadEpiphanyStateUpdatedNotification {
thread_id: thread_id_text,
source: ThreadEpiphanyStateUpdatedSource::JobLaunch,
revision: epiphany_state.revision,
changed_fields: vec![ThreadEpiphanyStateUpdatedField::JobBindings],
epiphany_state,
},
))
.await;
}
}
}
async fn load_epiphany_job_launcher_snapshots(
state_db_ctx: Option<&StateDbHandle>,
state: Option<&EpiphanyThreadState>,
@ -18294,6 +18477,10 @@ mod tests {
ThreadEpiphanyCoordinatorAction::CompactRehydrateReorient
);
assert!(decision.can_auto_run);
assert_eq!(
map_epiphany_coordinator_automation_action(&decision),
EpiphanyCoordinatorAutomationAction::CompactRehydrateReorient
);
}
#[test]
@ -18330,6 +18517,10 @@ mod tests {
Some(ThreadEpiphanyRoleId::Reorientation)
);
assert!(decision.can_auto_run);
assert_eq!(
map_epiphany_coordinator_automation_action(&decision),
EpiphanyCoordinatorAutomationAction::LaunchReorientWorker
);
}
#[test]
@ -18362,6 +18553,10 @@ mod tests {
ThreadEpiphanyCoordinatorAction::ReviewReorientResult
);
assert!(decision.requires_review);
assert_eq!(
map_epiphany_coordinator_automation_action(&decision),
EpiphanyCoordinatorAutomationAction::None
);
}
#[test]
@ -18392,6 +18587,10 @@ mod tests {
launch_modeling.action,
ThreadEpiphanyCoordinatorAction::LaunchModeling
);
assert_eq!(
map_epiphany_coordinator_automation_action(&launch_modeling),
EpiphanyCoordinatorAutomationAction::None
);
let modeling_done = coordinator_signals(
ThreadEpiphanyCrrcAction::Continue,
@ -18411,6 +18610,10 @@ mod tests {
launch_verification.action,
ThreadEpiphanyCoordinatorAction::LaunchVerification
);
assert_eq!(
map_epiphany_coordinator_automation_action(&launch_verification),
EpiphanyCoordinatorAutomationAction::None
);
let verification_done = coordinator_signals(
ThreadEpiphanyCrrcAction::Continue,