Make worker model sessions finite
This commit is contained in:
parent
f565ad6a73
commit
04169bb1c0
5 changed files with 240 additions and 29 deletions
|
|
@ -37,6 +37,7 @@ use epiphany_openai_runtime::run_model_turn;
|
|||
use epiphany_openai_runtime::run_openai_model_turn;
|
||||
use epiphany_openai_runtime::run_tool_followup_model_turn;
|
||||
use epiphany_openai_runtime::run_worker_launch;
|
||||
use epiphany_openai_runtime::worker_model_session_id;
|
||||
use epiphany_tool_adapter::EpiphanyToolInvocationIntent;
|
||||
use epiphany_tool_adapter::tool_invocation_intent_key;
|
||||
use serde_json::json;
|
||||
|
|
@ -663,7 +664,7 @@ async fn run_worker_launch_with_tool_continuation(
|
|||
let openai_options = EpiphanyOpenAiRuntimeOptions {
|
||||
store_path: options.store_path.clone(),
|
||||
codex_home: options.codex_home.clone(),
|
||||
session_id: format!("openai-worker-session-{}", launch_request.binding_id),
|
||||
session_id: worker_model_session_id(&launch_request.job_id),
|
||||
job_id: format!("openai-worker-{}", launch_request.job_id),
|
||||
objective: format!(
|
||||
"Run Epiphany worker {} for {}",
|
||||
|
|
@ -750,6 +751,17 @@ async fn run_worker_launch_with_tool_continuation(
|
|||
&openai_summary,
|
||||
&assistant_text,
|
||||
)?;
|
||||
epiphany_core::close_runtime_session(
|
||||
&options.store_path,
|
||||
epiphany_core::RuntimeSpineSessionClosureOptions {
|
||||
session_id: openai_options.session_id.clone(),
|
||||
completed_at: chrono::Utc::now().to_rfc3339(),
|
||||
summary: format!(
|
||||
"Worker model execution {} reached terminal result {}.",
|
||||
launch_request.job_id, worker_result.result_id
|
||||
),
|
||||
},
|
||||
)?;
|
||||
|
||||
Ok(json!({
|
||||
"store": options.store_path,
|
||||
|
|
@ -814,6 +826,11 @@ fn fail_worker_for_tool_round_limit(
|
|||
"worker {} still requested tools after {} automatic tool rounds",
|
||||
launch_request.job_id, max_tool_rounds
|
||||
);
|
||||
terminalize_unexecuted_tool_intents(
|
||||
store_path,
|
||||
&openai_summary.tool_intent_ids,
|
||||
"worker tool round limit closed this intent before execution",
|
||||
)?;
|
||||
let result = fail_worker_job(
|
||||
store_path,
|
||||
&launch_request.job_id,
|
||||
|
|
@ -821,6 +838,7 @@ fn fail_worker_for_tool_round_limit(
|
|||
"Inspect the worker request, tool receipts, and model/tool loop before relaunching."
|
||||
.to_string(),
|
||||
)?;
|
||||
close_worker_model_session(store_path, &launch_request.job_id, &summary)?;
|
||||
Ok(json!({
|
||||
"status": "tool-round-limit",
|
||||
"store": store_path.display().to_string(),
|
||||
|
|
@ -853,6 +871,11 @@ fn fail_worker_for_repeated_tool_loop(
|
|||
"worker {} repeated the same pending tool request set for {} consecutive follow-up rounds",
|
||||
launch_request.job_id, consecutive_rounds
|
||||
);
|
||||
terminalize_unexecuted_tool_intents(
|
||||
store_path,
|
||||
&openai_summary.tool_intent_ids,
|
||||
"worker repeated an identical tool round; intent closed before execution",
|
||||
)?;
|
||||
let result = fail_worker_job(
|
||||
store_path,
|
||||
&launch_request.job_id,
|
||||
|
|
@ -860,6 +883,7 @@ fn fail_worker_for_repeated_tool_loop(
|
|||
"Inspect the repeated tool fingerprints and decide whether the worker needs a narrower evidence bundle, a repaired tool, or a higher explicit limit."
|
||||
.to_string(),
|
||||
)?;
|
||||
close_worker_model_session(store_path, &launch_request.job_id, &summary)?;
|
||||
Ok(json!({
|
||||
"status": "tool-loop-stalled",
|
||||
"store": store_path,
|
||||
|
|
@ -880,6 +904,45 @@ fn fail_worker_for_repeated_tool_loop(
|
|||
}))
|
||||
}
|
||||
|
||||
fn terminalize_unexecuted_tool_intents(
|
||||
store_path: &Path,
|
||||
intent_ids: &[String],
|
||||
reason: &str,
|
||||
) -> Result<()> {
|
||||
let mut cache = epiphany_core::runtime_spine_cache(store_path)?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
for intent_id in intent_ids {
|
||||
let intent = cache
|
||||
.get::<EpiphanyToolInvocationIntent>(&tool_invocation_intent_key(intent_id))?
|
||||
.ok_or_else(|| anyhow!("pending tool intent {intent_id:?} disappeared"))?;
|
||||
let mut receipt = epiphany_tool_adapter::EpiphanyToolInvocationReceipt::new(
|
||||
format!("receipt-{intent_id}-worker-closure"),
|
||||
intent_id.clone(),
|
||||
intent.adapter,
|
||||
intent.server,
|
||||
intent.tool_name,
|
||||
"failed",
|
||||
chrono::Utc::now().to_rfc3339(),
|
||||
);
|
||||
receipt.error = Some(reason.to_string());
|
||||
epiphany_core::put_runtime_tool_execution_receipt(store_path, &receipt)?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn close_worker_model_session(store_path: &Path, worker_job_id: &str, summary: &str) -> Result<()> {
|
||||
epiphany_core::close_runtime_session(
|
||||
store_path,
|
||||
epiphany_core::RuntimeSpineSessionClosureOptions {
|
||||
session_id: worker_model_session_id(worker_job_id),
|
||||
completed_at: chrono::Utc::now().to_rfc3339(),
|
||||
summary: summary.to_string(),
|
||||
},
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn tool_intent_fingerprints(store_path: &Path, intent_ids: &[String]) -> Result<Vec<String>> {
|
||||
let mut cache = epiphany_core::runtime_spine_cache(store_path)?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
|
|
@ -929,6 +992,84 @@ mod tests {
|
|||
use epiphany_tool_adapter::EpiphanyToolInvocationIntent;
|
||||
use tempfile::tempdir;
|
||||
|
||||
fn seed_pending_tool_summary(
|
||||
store: &Path,
|
||||
worker_job_id: &str,
|
||||
request_id: &str,
|
||||
tool_name: &str,
|
||||
arguments: &str,
|
||||
) -> Result<epiphany_openai_runtime::EpiphanyOpenAiRuntimeRunSummary> {
|
||||
let session_id = worker_model_session_id(worker_job_id);
|
||||
let job_id = format!("openai-worker-{worker_job_id}");
|
||||
let model_request = EpiphanyModelRequest::new(
|
||||
request_id,
|
||||
format!("worker-{worker_job_id}"),
|
||||
DEFAULT_PROVIDER,
|
||||
"gpt-test",
|
||||
"Call one source tool.",
|
||||
);
|
||||
let provider_request = EpiphanyOpenAiModelRequest::new(
|
||||
request_id,
|
||||
format!("worker-{worker_job_id}"),
|
||||
"gpt-test",
|
||||
"Call one source tool.",
|
||||
);
|
||||
epiphany_core::open_runtime_model_execution(
|
||||
store,
|
||||
epiphany_core::RuntimeSpineSessionOptions {
|
||||
session_id: session_id.clone(),
|
||||
objective: format!("Run model execution for {worker_job_id}."),
|
||||
created_at: chrono::Utc::now().to_rfc3339(),
|
||||
coordinator_note: "test".to_string(),
|
||||
},
|
||||
epiphany_core::RuntimeSpineJobOptions {
|
||||
job_id: job_id.clone(),
|
||||
session_id: session_id.clone(),
|
||||
role: OPENAI_RUNTIME_ROLE.to_string(),
|
||||
created_at: chrono::Utc::now().to_rfc3339(),
|
||||
summary: "Pending tool fixture.".to_string(),
|
||||
artifact_refs: Vec::new(),
|
||||
},
|
||||
&model_request,
|
||||
&provider_request,
|
||||
&chrono::Utc::now().to_rfc3339(),
|
||||
)?;
|
||||
let mut receipt = EpiphanyOpenAiModelReceipt::new(request_id, "gpt-test");
|
||||
receipt.response_id = Some(format!("response-{request_id}"));
|
||||
receipt.transport = Some("test".to_string());
|
||||
record_openai_events(
|
||||
store,
|
||||
&EpiphanyOpenAiRuntimeOptions {
|
||||
store_path: store.to_path_buf(),
|
||||
codex_home: PathBuf::from(".codex"),
|
||||
session_id,
|
||||
job_id,
|
||||
objective: format!("Run model execution for {worker_job_id}."),
|
||||
coordinator_note: "test".to_string(),
|
||||
default_model: Some("gpt-test".to_string()),
|
||||
},
|
||||
&provider_request,
|
||||
&[
|
||||
EpiphanyOpenAiStreamEvent {
|
||||
schema_id: epiphany_openai_adapter::OPENAI_ADAPTER_EVENT_SCHEMA_ID.to_string(),
|
||||
request_id: request_id.to_string(),
|
||||
sequence: 0,
|
||||
payload: EpiphanyOpenAiStreamPayload::ToolCall {
|
||||
call_id: format!("call-{request_id}"),
|
||||
name: tool_name.to_string(),
|
||||
arguments: arguments.to_string(),
|
||||
},
|
||||
},
|
||||
EpiphanyOpenAiStreamEvent {
|
||||
schema_id: epiphany_openai_adapter::OPENAI_ADAPTER_EVENT_SCHEMA_ID.to_string(),
|
||||
request_id: request_id.to_string(),
|
||||
sequence: 1,
|
||||
payload: EpiphanyOpenAiStreamPayload::Completed { receipt },
|
||||
},
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn same_nonempty_tool_request_round_requires_real_repetition() {
|
||||
let first = vec!["source::read_file::{\"path\":\"README.md\"}".to_string()];
|
||||
|
|
@ -1035,18 +1176,13 @@ mod tests {
|
|||
)?;
|
||||
let launch_request =
|
||||
runtime_worker_launch_request(&store, "worker-job-loop")?.expect("launch request");
|
||||
let openai_summary = epiphany_openai_runtime::EpiphanyOpenAiRuntimeRunSummary {
|
||||
store: store.display().to_string(),
|
||||
session_id: "openai-worker-session-verification-review-worker".to_string(),
|
||||
job_id: "openai-worker-worker-job-loop".to_string(),
|
||||
request_id: "request-3".to_string(),
|
||||
event_count: 1,
|
||||
verdict: "pass".to_string(),
|
||||
summary: "Model requested the same tool again.".to_string(),
|
||||
result_id: "result-openai-worker-job-loop".to_string(),
|
||||
receipt_id: Some("request-3".to_string()),
|
||||
tool_intent_ids: vec!["intent-readme".to_string()],
|
||||
};
|
||||
let openai_summary = seed_pending_tool_summary(
|
||||
&store,
|
||||
"worker-job-loop",
|
||||
"request-3",
|
||||
"mcp__epiphany_source__read_file",
|
||||
r#"{"path":"README.md"}"#,
|
||||
)?;
|
||||
|
||||
let status = fail_worker_for_repeated_tool_loop(
|
||||
&store,
|
||||
|
|
@ -1062,6 +1198,24 @@ mod tests {
|
|||
let snapshot = runtime_job_snapshot(&store, "worker-job-loop")?.expect("worker snapshot");
|
||||
assert_eq!(snapshot.job.status, EpiphanyRuntimeJobStatus::Failed);
|
||||
assert_eq!(snapshot.result.expect("worker result").verdict, "failed");
|
||||
let mut cache = epiphany_core::runtime_spine_cache(&store)?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
assert_eq!(
|
||||
cache
|
||||
.get::<epiphany_core::EpiphanyRuntimeSession>(
|
||||
"openai-worker-session-worker-job-loop"
|
||||
)?
|
||||
.expect("worker model session")
|
||||
.status,
|
||||
epiphany_core::EpiphanyRuntimeSessionStatus::Completed
|
||||
);
|
||||
assert!(cache
|
||||
.get::<epiphany_tool_adapter::EpiphanyToolInvocationReceipt>(
|
||||
&epiphany_tool_adapter::tool_invocation_receipt_key(
|
||||
&openai_summary.tool_intent_ids[0]
|
||||
)
|
||||
)?
|
||||
.is_some());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -1213,18 +1367,14 @@ mod tests {
|
|||
)?;
|
||||
let launch_request = runtime_worker_launch_request(&store, "worker-job-round-limit")?
|
||||
.expect("launch request");
|
||||
let openai_summary = epiphany_openai_runtime::EpiphanyOpenAiRuntimeRunSummary {
|
||||
store: store.display().to_string(),
|
||||
session_id: "openai-worker-session-verification-review-worker".to_string(),
|
||||
job_id: "openai-worker-worker-job-round-limit".to_string(),
|
||||
request_id: "request-limit".to_string(),
|
||||
event_count: 1,
|
||||
verdict: "pass".to_string(),
|
||||
summary: "Model still requested another nonrepeating tool.".to_string(),
|
||||
result_id: "result-openai-worker-job-round-limit".to_string(),
|
||||
receipt_id: Some("request-limit".to_string()),
|
||||
tool_intent_ids: vec!["intent-git-show".to_string()],
|
||||
};
|
||||
let openai_summary = seed_pending_tool_summary(
|
||||
&store,
|
||||
"worker-job-round-limit",
|
||||
"request-limit",
|
||||
"mcp__epiphany_source__git_show",
|
||||
r#"{"commit":"HEAD"}"#,
|
||||
)?;
|
||||
let pending_intent_id = openai_summary.tool_intent_ids[0].clone();
|
||||
let tool_rounds = vec![
|
||||
json!({"round": 0, "toolFingerprints": ["epiphany_source::read_file::{\"path\":\"README.md\"}"]}),
|
||||
json!({"round": 1, "toolFingerprints": ["epiphany_source::git_show::{\"commit\":\"HEAD\"}"]}),
|
||||
|
|
@ -1240,12 +1390,23 @@ mod tests {
|
|||
)?;
|
||||
|
||||
assert_eq!(status["status"], "tool-round-limit");
|
||||
assert_eq!(status["pendingToolIntentIds"][0], "intent-git-show");
|
||||
assert_eq!(status["pendingToolIntentIds"][0], pending_intent_id);
|
||||
assert_ne!(status["status"], "tool-loop-stalled");
|
||||
let snapshot =
|
||||
runtime_job_snapshot(&store, "worker-job-round-limit")?.expect("worker snapshot");
|
||||
assert_eq!(snapshot.job.status, EpiphanyRuntimeJobStatus::Failed);
|
||||
assert_eq!(snapshot.result.expect("worker result").verdict, "failed");
|
||||
let mut cache = epiphany_core::runtime_spine_cache(&store)?;
|
||||
cache.pull_all_backing_stores()?;
|
||||
assert_eq!(
|
||||
cache
|
||||
.get::<epiphany_core::EpiphanyRuntimeSession>(
|
||||
"openai-worker-session-worker-job-round-limit"
|
||||
)?
|
||||
.expect("worker model session")
|
||||
.status,
|
||||
epiphany_core::EpiphanyRuntimeSessionStatus::Completed
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ use anyhow::Result;
|
|||
use chrono::SecondsFormat;
|
||||
use epiphany_core::append_runtime_event;
|
||||
use epiphany_core::complete_runtime_job;
|
||||
use epiphany_core::close_runtime_session;
|
||||
use epiphany_core::initialize_runtime_spine;
|
||||
use epiphany_core::put_runtime_reorient_worker_result;
|
||||
use epiphany_core::put_runtime_role_worker_result;
|
||||
|
|
@ -23,6 +24,7 @@ use epiphany_core::RuntimeSpineInitOptions;
|
|||
use epiphany_core::RuntimeSpineJobOptions;
|
||||
use epiphany_core::RuntimeSpineJobResultOptions;
|
||||
use epiphany_core::RuntimeSpineSessionOptions;
|
||||
use epiphany_core::RuntimeSpineSessionClosureOptions;
|
||||
use epiphany_model_adapter::EpiphanyModelInputItem;
|
||||
use epiphany_model_adapter::EpiphanyModelReceipt;
|
||||
use epiphany_model_adapter::EpiphanyModelRequest;
|
||||
|
|
@ -53,6 +55,10 @@ pub const OPENAI_RUNTIME_ROLE: &str = "openai-model-adapter";
|
|||
pub const OPENAI_RUNTIME_SOURCE: &str = "epiphany-openai-runtime";
|
||||
pub const DEFAULT_MODEL_PROVIDER: &str = "openai-codex";
|
||||
|
||||
pub fn worker_model_session_id(worker_job_id: &str) -> String {
|
||||
format!("openai-worker-session-{worker_job_id}")
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EpiphanyOpenAiRuntimeOptions {
|
||||
pub store_path: PathBuf,
|
||||
|
|
@ -314,7 +320,7 @@ pub async fn run_worker_launch(
|
|||
let openai_options = EpiphanyOpenAiRuntimeOptions {
|
||||
store_path: options.store_path.clone(),
|
||||
codex_home: options.codex_home,
|
||||
session_id: format!("openai-worker-session-{}", launch_request.binding_id),
|
||||
session_id: worker_model_session_id(&launch_request.job_id),
|
||||
job_id: format!("openai-worker-{}", launch_request.job_id),
|
||||
objective: format!(
|
||||
"Run Epiphany worker {} for {}",
|
||||
|
|
@ -339,6 +345,17 @@ pub async fn run_worker_launch(
|
|||
&openai_summary,
|
||||
&assistant_text,
|
||||
)?;
|
||||
close_runtime_session(
|
||||
&openai_options.store_path,
|
||||
RuntimeSpineSessionClosureOptions {
|
||||
session_id: openai_options.session_id.clone(),
|
||||
completed_at: now(),
|
||||
summary: format!(
|
||||
"Worker model execution {} reached terminal result {}.",
|
||||
launch_request.job_id, worker_result.result_id
|
||||
),
|
||||
},
|
||||
)?;
|
||||
Ok(EpiphanyWorkerRuntimeRunSummary {
|
||||
store: openai_options.store_path.display().to_string(),
|
||||
job_id: launch_request.job_id,
|
||||
|
|
|
|||
|
|
@ -2416,6 +2416,28 @@ receipt IDs at read time. Those readers either preserve exact execution
|
|||
members or must first own a self-contained immutable evidence projection. No
|
||||
generic string scan or age rule may substitute for typed references.
|
||||
|
||||
That classification exposed and repaired the archive-unit fault. Worker model
|
||||
sessions were formerly role-long (`openai-worker-session-{binding}`), so future
|
||||
workers kept the session live forever and a session tombstone could never
|
||||
bound the dominant prompt/stream family. Worker execution now derives one
|
||||
session from the exact outer worker `job_id`; all model/tool-followup jobs for
|
||||
that worker share it, while later workers receive different sessions.
|
||||
Successful completion closes the inner model session after the outer typed
|
||||
worker result is admitted. Tool-loop stall and round-limit closure first write
|
||||
failed receipts for the exact unexecuted pending intents, then fail the outer
|
||||
worker and close the same inner session. Tests prove terminal outer job,
|
||||
terminal tool receipt, and completed unique inner session. Conversation-wide
|
||||
model sessions remain intentionally long-lived and cannot be archived until
|
||||
their own owner closes them.
|
||||
|
||||
The initial tombstone can therefore be narrow and honest: archive only a
|
||||
completed session whose jobs are model-adapter jobs, each job has an explicit
|
||||
model execution binding and terminal result, every model stream is terminal,
|
||||
and every tool binding is receipted. Outer worker launch/results and all
|
||||
semantic/Mind/consequence families remain untouched. The tombstone must retain
|
||||
the exact session, job/result, model-request, and tool-intent identities as an
|
||||
ID-reuse barrier plus counts and a digest of bulky retired envelopes.
|
||||
|
||||
The coordinator receipt accumulator is implemented in source. Runtime owns the
|
||||
typed head, cumulative status counts, chained digest, and full-snapshot-fenced
|
||||
replacement/deletion. Resident Self supplies the cross-store preservation set
|
||||
|
|
|
|||
|
|
@ -1501,3 +1501,14 @@ runtime tests pass warning-free. The next pass is source-grounded retained
|
|||
reference classification across semantic, frontier, Hands/Soul, Persona,
|
||||
memory, resident, and coordinator readers before any archived-session deletion
|
||||
is implemented.
|
||||
|
||||
Retained-reference inspection found the archive unit itself was false: worker
|
||||
model sessions were role-long and remained open for later workers. They now
|
||||
derive from the exact outer worker job ID, so one session owns that worker's
|
||||
initial and tool-followup model jobs only. Success closes it after typed outer
|
||||
result admission. Loop-stall and round-limit paths terminalize the exact
|
||||
unexecuted tool intents, fail the outer job, and close the same inner session.
|
||||
Six OpenAI CLI and 15 library tests pass, including terminal receipt/session
|
||||
assertions. The next cut is the narrow archived model-session tombstone; it
|
||||
must retain exact IDs and delete only inner execution envelopes, never outer
|
||||
worker or semantic authority.
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ invariants:
|
|||
|
||||
current_status:
|
||||
summary: Epiphany is a supervised engineering alpha on Starfire, not deployment-ready. Exact b8138a6b active-child SIGTERM and restart, exact 9f369528 deterministic warm packaging, exact c930f505 cross-container ownership, exact ed15f83a resident lifecycle retention, and exact 16c4b19f coordinator receipt and Heartbeat artifact retention are proven. Gamecult-ops 059821f makes journald the sole Yggdrasil supervisor/projector stream-retention owner. Exact 16c4b19f genuine idle and exact a987d2f7 active cognition both completed 900-pulse bounded plateaus with clean direct-PID exits. The active run proves restart-persistent cooldown, exact-grant terminality under deliberate missing-ack and marker-regression corruption, multiple later terminal grants without resurrection, bounded artifact retention, and flat terminal resource state. Runtime-owned typed fulfillment is now accepted live: c1b461b2 falsified mutable Body/admission coupling, c9738fdb repaired the owner split, and exact 6dd9b132 packaging completed one autonomous Eyes continuation through coordinator exit, awaiting-fulfillment, one authenticated result, one planned acknowledgement, grant terminality, and clean shutdown. All 50 runtime-spine and 24 resident focused tests pass. Broad session/model/event/tool retention and stable Starfire firewall ownership remain open. Yggdrasil is the small public crossing body, never the release forge.
|
||||
latest_phase: Exact 6dd9b132 runtime-owned asynchronous fulfillment remains accepted. The broad retention audit proves runtime sessions are not yet complete deletion generations and semantic documents in the same store are not session exhaust. Runtime spine now owns atomic model and tool execution membership. open_runtime_model_execution publishes session/job/opened-event/binding/native/provider requests before transport. EpiphanyRuntimeToolExecutionBinding publishes each intent with exact session/job and optional model ownership; the tool runtime refuses unbound execution and publishes immutable terminal receipts through the same owner. Core hostile tests, CultNet Hello/catalog, all 15 OpenAI runtime tests, and all 10 tool-runtime tests pass. No archive deletion exists yet.
|
||||
latest_phase: Exact 6dd9b132 fulfillment remains accepted. Runtime spine owns atomic model/tool execution membership and immutable tool receipts. Retained-reference inspection then falsified the proposed archive unit: worker model sessions were role-long and could never close while future workers remained possible. Worker sessions now derive from exact outer job_id, contain that worker's initial/followup model jobs, and close on success. Loop-stall/round-limit paths terminalize unexecuted intents, fail the outer worker, and close the unique inner session. Six OpenAI CLI and 15 library tests pass. Semantic/outer-worker families remain outside the archive unit; no deletion exists yet.
|
||||
operational_state:
|
||||
local_worktree: coordinator_receipt_retention_packaged_proven
|
||||
operator_wireguard: restored
|
||||
|
|
@ -69,7 +69,7 @@ current_status:
|
|||
yggdrasil_epiphany_service_contract: repaired_in_gamecult_ops_812b427_not_installed
|
||||
resident_physiology: authenticated_9b8df0b4_c005_bound_to_eyes_tools_nervous_system_with_217dd_and_bd96305e_helpers_running
|
||||
unresolved_authority: Coordinator receipt, Heartbeat pulse-artifact, deployed supervisor/projector log retention, genuine-idle and active resource plateaus, exact-grant terminality, restart-persistent cooldown refusal, schedule/action issuance cardinality, and runtime-owned typed fulfillment are accepted. Broader semantic/runtime session, job, event, model, and tool histories remain unbounded pending a typed archived-session owner. Repository Body observation still performs two authenticated full-tree Git index/manifest passes. Execute-mode workers require a persistent process body. Keyed storage has not earned live migration. One Discord consequence remains blocked by the absent Yggdrasil credential.
|
||||
next_action: Classify retained semantic references before archival. Enumerate every production reader that resolves session/job/worker-result/model-request/tool-intent/tool-receipt IDs from RepoModel, frontier, Hands/Soul, Persona, memory projection, resident, or coordinator state. Preserve exact referenced execution members or first replace the dependency with a self-contained immutable evidence projection. Then implement one typed archived-session tombstone with full-snapshot-fenced exact deletion and negative resurrection proof. Legacy unbound model/tool rows remain unarchivable. Preserve active c005. Yggdrasil never builds.
|
||||
next_action: Implement the narrow archived model-session tombstone. Admit only a Completed session containing model-adapter jobs where every job has one explicit model binding and terminal result, every native/provider stream is terminal, and every tool binding has an immutable receipt. Retain exact session/job/result/request/intent IDs plus counts and chained digest as an ID-reuse barrier; delete only exact inner session/job/event/model/tool envelopes under a full-snapshot fence. Refuse legacy unbound rows, nonterminal families, stale snapshots, semantic/outer-worker deletion, and session recreation. Preserve active c005. Yggdrasil never builds.
|
||||
|
||||
active_subgoals:
|
||||
- Prove Persona, Self, Eyes, Modeling, Imagination, Hands, Soul, Mind, Continuity, and nervous-system behavior individually.
|
||||
|
|
|
|||
Reference in a new issue