Launch Hands branch-turn workers
This commit is contained in:
parent
a3e7950c2a
commit
235cc81b17
15 changed files with 306 additions and 44 deletions
|
|
@ -1,5 +1,7 @@
|
|||
use epiphany_core::EPIPHANY_IMAGINATION_OWNER_ROLE;
|
||||
use epiphany_core::EPIPHANY_IMAGINATION_ROLE_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_IMPLEMENTATION_OWNER_ROLE;
|
||||
use epiphany_core::EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_MODELING_ROLE_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_REORIENT_LAUNCH_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_REORIENT_OWNER_ROLE;
|
||||
|
|
@ -389,10 +391,12 @@ pub fn map_epiphany_roles(
|
|||
pressure_level: format!("{:?}", pressure.level),
|
||||
reorient_result_status: result_status,
|
||||
reorient_job: reorient_job.map(map_core_role_board_job),
|
||||
implementation_binding_id: EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID.to_string(),
|
||||
imagination_binding_id: EPIPHANY_IMAGINATION_ROLE_BINDING_ID.to_string(),
|
||||
research_binding_id: EPIPHANY_RESEARCH_ROLE_BINDING_ID.to_string(),
|
||||
modeling_binding_id: EPIPHANY_MODELING_ROLE_BINDING_ID.to_string(),
|
||||
verification_binding_id: EPIPHANY_VERIFICATION_ROLE_BINDING_ID.to_string(),
|
||||
implementation_owner_role: EPIPHANY_IMPLEMENTATION_OWNER_ROLE.to_string(),
|
||||
reorient_owner_role: EPIPHANY_REORIENT_OWNER_ROLE.to_string(),
|
||||
imagination_owner_role: EPIPHANY_IMAGINATION_OWNER_ROLE.to_string(),
|
||||
research_owner_role: epiphany_core::EPIPHANY_RESEARCH_OWNER_ROLE.to_string(),
|
||||
|
|
|
|||
|
|
@ -6,6 +6,8 @@
|
|||
|
||||
pub use epiphany_core::EPIPHANY_IMAGINATION_OWNER_ROLE;
|
||||
pub use epiphany_core::EPIPHANY_IMAGINATION_ROLE_BINDING_ID;
|
||||
pub use epiphany_core::EPIPHANY_IMPLEMENTATION_OWNER_ROLE;
|
||||
pub use epiphany_core::EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID;
|
||||
pub use epiphany_core::EPIPHANY_MODELING_OWNER_ROLE;
|
||||
pub use epiphany_core::EPIPHANY_MODELING_ROLE_BINDING_ID;
|
||||
pub use epiphany_core::EPIPHANY_REORIENT_LAUNCH_BINDING_ID;
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ use std::path::Path;
|
|||
use std::path::PathBuf;
|
||||
|
||||
use epiphany_core::CONTINUITY_RECOVERY_RECEIPT_TYPE;
|
||||
use epiphany_core::EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_REORIENT_LAUNCH_BINDING_ID;
|
||||
use epiphany_core::EPIPHANY_RESEARCH_ROLE_BINDING_ID;
|
||||
use epiphany_core::EYES_EVIDENCE_PACKET_TYPE;
|
||||
|
|
@ -60,6 +61,7 @@ use epiphany_core::runtime_soul_verdict_receipt;
|
|||
use epiphany_core::runtime_substrate_gate_repo_access_grant_receipt;
|
||||
use epiphany_core::soul_verdict_receipt_from_verification_finding;
|
||||
use epiphany_core::substrate_gate_repo_access_grant_for_launch;
|
||||
use epiphany_core::substrate_gate_repo_mutation_grant_for_launch;
|
||||
use epiphany_state_model::EpiphanyEvidenceRecord;
|
||||
use epiphany_state_model::EpiphanyJobKind as CoreEpiphanyJobKind;
|
||||
use epiphany_state_model::EpiphanyRetrievalState;
|
||||
|
|
@ -1042,18 +1044,25 @@ fn maybe_put_substrate_gate_launch_grant(
|
|||
request: &EpiphanyJobLaunchRequest,
|
||||
backend_job_id: &str,
|
||||
) -> BridgeResult<()> {
|
||||
if request.binding_id != EPIPHANY_RESEARCH_ROLE_BINDING_ID {
|
||||
return Ok(());
|
||||
}
|
||||
let grant = substrate_gate_repo_access_grant_for_launch(
|
||||
substrate_gate_grant_receipt_id(backend_job_id),
|
||||
backend_job_id.to_string(),
|
||||
request,
|
||||
Utc::now().to_rfc3339_opts(SecondsFormat::Secs, true),
|
||||
);
|
||||
let granted_at = Utc::now().to_rfc3339_opts(SecondsFormat::Secs, true);
|
||||
let grant = match request.binding_id.as_str() {
|
||||
EPIPHANY_RESEARCH_ROLE_BINDING_ID => substrate_gate_repo_access_grant_for_launch(
|
||||
substrate_gate_grant_receipt_id(backend_job_id),
|
||||
backend_job_id.to_string(),
|
||||
request,
|
||||
granted_at,
|
||||
),
|
||||
EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID => substrate_gate_repo_mutation_grant_for_launch(
|
||||
substrate_gate_grant_receipt_id(backend_job_id),
|
||||
backend_job_id.to_string(),
|
||||
request,
|
||||
granted_at,
|
||||
),
|
||||
_ => return Ok(()),
|
||||
};
|
||||
put_substrate_gate_repo_access_grant_receipt(runtime_store_path, &grant).map_err(|err| {
|
||||
EpiphanyBridgeError::Fatal(format!(
|
||||
"failed to persist Substrate Gate access grant for research launch: {err}"
|
||||
"failed to persist Substrate Gate access grant for worker launch: {err}"
|
||||
))
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,6 +27,8 @@ pub const EPIPHANY_MODELING_ROLE_BINDING_ID: &str = "modeling-checkpoint-worker"
|
|||
pub const EPIPHANY_MODELING_OWNER_ROLE: &str = "epiphany-modeler";
|
||||
pub const EPIPHANY_VERIFICATION_ROLE_BINDING_ID: &str = "verification-review-worker";
|
||||
pub const EPIPHANY_VERIFICATION_OWNER_ROLE: &str = "epiphany-verifier";
|
||||
pub const EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID: &str = "implementation-branch-turn-worker";
|
||||
pub const EPIPHANY_IMPLEMENTATION_OWNER_ROLE: &str = "epiphany-hands";
|
||||
pub const EPIPHANY_REORIENT_LAUNCH_BINDING_ID: &str = "reorient-worker";
|
||||
pub const EPIPHANY_REORIENT_OWNER_ROLE: &str = "epiphany-reorient";
|
||||
|
||||
|
|
@ -36,10 +38,7 @@ pub fn epiphany_role_binding_id(role_id: EpiphanyRoleResultRoleId) -> Result<&'s
|
|||
EpiphanyRoleResultRoleId::Research => Ok(EPIPHANY_RESEARCH_ROLE_BINDING_ID),
|
||||
EpiphanyRoleResultRoleId::Modeling => Ok(EPIPHANY_MODELING_ROLE_BINDING_ID),
|
||||
EpiphanyRoleResultRoleId::Verification => Ok(EPIPHANY_VERIFICATION_ROLE_BINDING_ID),
|
||||
EpiphanyRoleResultRoleId::Implementation => Err(
|
||||
"implementation is owned by the main coding agent; no role specialist launch template exists"
|
||||
.to_string(),
|
||||
),
|
||||
EpiphanyRoleResultRoleId::Implementation => Ok(EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID),
|
||||
EpiphanyRoleResultRoleId::Reorientation => Err(
|
||||
"reorientation uses thread/epiphany/reorientLaunch and thread/epiphany/reorientResult"
|
||||
.to_string(),
|
||||
|
|
@ -53,7 +52,8 @@ pub fn epiphany_role_owner(role_id: EpiphanyRoleResultRoleId) -> Result<&'static
|
|||
EpiphanyRoleResultRoleId::Research => Ok(EPIPHANY_RESEARCH_OWNER_ROLE),
|
||||
EpiphanyRoleResultRoleId::Modeling => Ok(EPIPHANY_MODELING_OWNER_ROLE),
|
||||
EpiphanyRoleResultRoleId::Verification => Ok(EPIPHANY_VERIFICATION_OWNER_ROLE),
|
||||
EpiphanyRoleResultRoleId::Implementation | EpiphanyRoleResultRoleId::Reorientation => {
|
||||
EpiphanyRoleResultRoleId::Implementation => Ok(EPIPHANY_IMPLEMENTATION_OWNER_ROLE),
|
||||
EpiphanyRoleResultRoleId::Reorientation => {
|
||||
Err(epiphany_role_binding_id(role_id).unwrap_err())
|
||||
}
|
||||
}
|
||||
|
|
@ -88,9 +88,10 @@ pub fn epiphany_role_launch_output_schema(role_id: EpiphanyRoleResultRoleId) ->
|
|||
EpiphanyRoleResultRoleId::Verification => {
|
||||
vec!["pass", "needs-review", "needs-evidence", "fail"]
|
||||
}
|
||||
EpiphanyRoleResultRoleId::Implementation | EpiphanyRoleResultRoleId::Reorientation => {
|
||||
vec![]
|
||||
EpiphanyRoleResultRoleId::Implementation => {
|
||||
vec!["commit-created", "needs-proprioception", "blocked"]
|
||||
}
|
||||
EpiphanyRoleResultRoleId::Reorientation => vec![],
|
||||
};
|
||||
let mut properties = serde_json::json!({
|
||||
"roleId": {
|
||||
|
|
@ -308,6 +309,65 @@ pub fn epiphany_role_launch_output_schema(role_id: EpiphanyRoleResultRoleId) ->
|
|||
}
|
||||
required.push("frontierNodeIds");
|
||||
required.push("statePatch");
|
||||
} else if role_id == EpiphanyRoleResultRoleId::Implementation {
|
||||
if let Some(map) = properties.as_object_mut() {
|
||||
map.insert(
|
||||
"branchName".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "string",
|
||||
"description": "Git branch created or used for this bounded Hands turn."
|
||||
}),
|
||||
);
|
||||
map.insert(
|
||||
"commitSha".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "string",
|
||||
"description": "Commit created by this Hands turn. Empty only when verdict is blocked or needs-proprioception."
|
||||
}),
|
||||
);
|
||||
map.insert(
|
||||
"changedPaths".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "array",
|
||||
"items": {"type": "string"}
|
||||
}),
|
||||
);
|
||||
map.insert(
|
||||
"commandsRun".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "array",
|
||||
"items": {"type": "string"}
|
||||
}),
|
||||
);
|
||||
map.insert(
|
||||
"handsReceiptIds".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "array",
|
||||
"description": "Typed Hands/Substrate/Soul/Mind receipt ids produced or cited by this turn.",
|
||||
"items": {"type": "string"}
|
||||
}),
|
||||
);
|
||||
map.insert(
|
||||
"proprioceptionRefreshRequest".to_string(),
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"description": "Required branch-map refresh request for Proprioception after a commit.",
|
||||
"properties": {
|
||||
"required": {"type": "boolean"},
|
||||
"reason": {"type": "string"},
|
||||
"branchName": {"type": "string"},
|
||||
"commitSha": {"type": "string"},
|
||||
"changedPaths": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"}
|
||||
}
|
||||
},
|
||||
"additionalProperties": true
|
||||
}),
|
||||
);
|
||||
}
|
||||
required.push("branchName");
|
||||
required.push("changedPaths");
|
||||
}
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
|
|
@ -496,7 +556,12 @@ pub fn build_epiphany_role_launch_request_with_dynamic_context(
|
|||
"epiphany.role.verification",
|
||||
build_epiphany_role_launch_instruction(role_id),
|
||||
),
|
||||
EpiphanyRoleResultRoleId::Implementation | EpiphanyRoleResultRoleId::Reorientation => {
|
||||
EpiphanyRoleResultRoleId::Implementation => (
|
||||
"role-scoped implementation branch turn",
|
||||
"epiphany.role.implementation",
|
||||
build_epiphany_role_launch_instruction(role_id),
|
||||
),
|
||||
EpiphanyRoleResultRoleId::Reorientation => {
|
||||
return Err(epiphany_role_binding_id(role_id).unwrap_err());
|
||||
}
|
||||
};
|
||||
|
|
@ -550,15 +615,17 @@ pub fn build_epiphany_role_launch_request_with_dynamic_context(
|
|||
}
|
||||
|
||||
fn build_epiphany_role_launch_instruction(role_id: EpiphanyRoleResultRoleId) -> String {
|
||||
let prompts = &epiphany_specialist_prompt_config().roles;
|
||||
let config = epiphany_specialist_prompt_config();
|
||||
let prompts = &config.roles;
|
||||
let body = match role_id {
|
||||
EpiphanyRoleResultRoleId::Imagination => prompts.imagination.as_str(),
|
||||
EpiphanyRoleResultRoleId::Research => prompts.research.as_str(),
|
||||
EpiphanyRoleResultRoleId::Modeling => prompts.modeling.as_str(),
|
||||
EpiphanyRoleResultRoleId::Verification => prompts.verification.as_str(),
|
||||
EpiphanyRoleResultRoleId::Implementation | EpiphanyRoleResultRoleId::Reorientation => {
|
||||
"Unsupported Epiphany role specialist template."
|
||||
EpiphanyRoleResultRoleId::Implementation => {
|
||||
config.implementation.continue_template.as_str()
|
||||
}
|
||||
EpiphanyRoleResultRoleId::Reorientation => "Unsupported Epiphany role specialist template.",
|
||||
};
|
||||
epiphany_worker_prompt(body)
|
||||
}
|
||||
|
|
@ -821,4 +888,57 @@ mod tests {
|
|||
assert!(!prompt.contains("## Epiphany Persistent Memory"));
|
||||
assert!(!prompt.contains("Heartbeat: every lane"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn implementation_role_launches_as_hands_branch_turn() {
|
||||
let state = EpiphanyThreadState {
|
||||
revision: 12,
|
||||
objective: Some("Wire Hands branch-turn launches.".to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let request = build_epiphany_role_launch_request_with_dynamic_context(
|
||||
"thread-1",
|
||||
EpiphanyRoleResultRoleId::Implementation,
|
||||
Some(12),
|
||||
Some(300),
|
||||
&state,
|
||||
Some("Proprioception context: branch map is current.".to_string()),
|
||||
)
|
||||
.expect("implementation launch request");
|
||||
|
||||
assert_eq!(request.binding_id, EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID);
|
||||
assert_eq!(request.owner_role, EPIPHANY_IMPLEMENTATION_OWNER_ROLE);
|
||||
assert_eq!(request.authority_scope, "epiphany.role.implementation");
|
||||
assert!(request.scope.contains("implementation branch turn"));
|
||||
assert!(request.instruction.contains("one commit"));
|
||||
assert!(request.instruction.contains("Proprioception"));
|
||||
match request.launch_document {
|
||||
EpiphanyWorkerLaunchDocument::Role(document) => {
|
||||
assert_eq!(document.role_id, "implementation");
|
||||
assert_eq!(
|
||||
document.dynamic_prompt_context.as_deref(),
|
||||
Some("Proprioception context: branch map is current.")
|
||||
);
|
||||
}
|
||||
EpiphanyWorkerLaunchDocument::Reorient(_) => panic!("expected role launch document"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn implementation_output_schema_requires_branch_turn_evidence() {
|
||||
let schema = epiphany_role_launch_output_schema(EpiphanyRoleResultRoleId::Implementation);
|
||||
let required = schema
|
||||
.get("required")
|
||||
.and_then(|required| required.as_array())
|
||||
.expect("required array");
|
||||
let required_values = required
|
||||
.iter()
|
||||
.filter_map(|value| value.as_str())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
assert!(required_values.contains(&"branchName"));
|
||||
assert!(required_values.contains(&"changedPaths"));
|
||||
assert!(schema.to_string().contains("commitSha"));
|
||||
assert!(schema.to_string().contains("proprioceptionRefreshRequest"));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@ const DEFAULT_CARGO_TARGET_DIR: &str = r"C:\Users\Meta\.cargo-target-codex";
|
|||
const DEFAULT_THREAD_STATE_STORE: &str = "state/thread-state.msgpack";
|
||||
const DEFAULT_RUNTIME_STORE: &str = "state/runtime-spine.msgpack";
|
||||
const REORIENT_BINDING_ID: &str = "reorient-worker";
|
||||
const IMPLEMENTATION_BINDING_ID: &str = "implementation-branch-turn-worker";
|
||||
const IMPLEMENTATION_OWNER_ROLE: &str = "epiphany-hands";
|
||||
const IMAGINATION_BINDING_ID: &str = "imagination-synthesis-worker";
|
||||
const RESEARCH_BINDING_ID: &str = "research-source-gather-worker";
|
||||
const MODELING_BINDING_ID: &str = "modeling-checkpoint-worker";
|
||||
|
|
@ -310,10 +312,12 @@ fn run_native_status(args: &Args) -> Result<Value> {
|
|||
.iter()
|
||||
.find(|job| job.id == REORIENT_BINDING_ID)
|
||||
.cloned(),
|
||||
implementation_binding_id: IMPLEMENTATION_BINDING_ID.to_string(),
|
||||
imagination_binding_id: IMAGINATION_BINDING_ID.to_string(),
|
||||
research_binding_id: RESEARCH_BINDING_ID.to_string(),
|
||||
modeling_binding_id: MODELING_BINDING_ID.to_string(),
|
||||
verification_binding_id: VERIFICATION_BINDING_ID.to_string(),
|
||||
implementation_owner_role: IMPLEMENTATION_OWNER_ROLE.to_string(),
|
||||
reorient_owner_role: "epiphany-reorienter".to_string(),
|
||||
imagination_owner_role: "epiphany-imagination".to_string(),
|
||||
research_owner_role: "epiphany-eyes".to_string(),
|
||||
|
|
|
|||
|
|
@ -25,6 +25,8 @@ mod thread_state_store;
|
|||
|
||||
pub use agent_launch::EPIPHANY_IMAGINATION_OWNER_ROLE;
|
||||
pub use agent_launch::EPIPHANY_IMAGINATION_ROLE_BINDING_ID;
|
||||
pub use agent_launch::EPIPHANY_IMPLEMENTATION_OWNER_ROLE;
|
||||
pub use agent_launch::EPIPHANY_IMPLEMENTATION_ROLE_BINDING_ID;
|
||||
pub use agent_launch::EPIPHANY_MODELING_OWNER_ROLE;
|
||||
pub use agent_launch::EPIPHANY_MODELING_ROLE_BINDING_ID;
|
||||
pub use agent_launch::EPIPHANY_REORIENT_LAUNCH_BINDING_ID;
|
||||
|
|
@ -491,6 +493,7 @@ pub use substrate_gate::SubstrateGateCultNetContract;
|
|||
pub use substrate_gate::SubstrateGateRepoAccessGrantReceipt;
|
||||
pub use substrate_gate::default_substrate_gate_cultnet_contracts;
|
||||
pub use substrate_gate::substrate_gate_repo_access_grant_for_launch;
|
||||
pub use substrate_gate::substrate_gate_repo_mutation_grant_for_launch;
|
||||
pub use surfaces::EpiphanyAcceptanceBundle;
|
||||
pub use surfaces::EpiphanyContext;
|
||||
pub use surfaces::EpiphanyContextMissing;
|
||||
|
|
|
|||
|
|
@ -162,7 +162,8 @@ You are the Epiphany implementation agent for this repository.
|
|||
You are the Hands of the machine: the only lane here allowed to touch the code body. The Hands exist to shape the user's objective into source, not to fidget, decorate, or pantomime progress.
|
||||
The Hands improve themselves by becoming more precise at touch. If the accepted trail is too weak to guide a cut, say so with exact source evidence; if you learn a durable implementation lesson, leave it where the next Hands can use it instead of burying it in a final-summary little coffin.
|
||||
|
||||
Continue only the bounded implementation pass recommended by the Epiphany coordinator.
|
||||
Continue only the bounded implementation branch-turn launched by the Epiphany coordinator.
|
||||
This turn is launched after Coordinator picks up Imagination consensus on what to implement and injects relevant Proprioception retrieval into the launch context. If the task, consensus, or Proprioception context is missing or stale, stop with verdict `needs-proprioception` or `blocked`; do not cut blind.
|
||||
|
||||
Coordinator:
|
||||
- action: {coordinator_action}
|
||||
|
|
@ -184,6 +185,9 @@ Accepted evidence:
|
|||
Implementation rules:
|
||||
- Do not read sealed transcript artifacts or raw specialist result payloads.
|
||||
- Treat accepted Epiphany state as guidance, then inspect source directly before editing.
|
||||
- Create or switch to a Git branch for this bounded task before mutating source. Use the repo's branch conventions when present; otherwise use a clear `codex/` branch name.
|
||||
- Make at most one commit in this turn. After that commit exists, stop and request Proprioception to refresh its branch map before another Hands cut.
|
||||
- Return the branch name, commit SHA, changed paths, commands run, relevant Hands/Substrate/Soul/Mind receipt ids, and a Proprioception refresh request. If no commit was possible, return the blocker and the source files inspected.
|
||||
- Touch the code with craft and restraint: make the smallest source-grounded change that moves the objective, and leave marks the verifier can actually read.
|
||||
- Preserve Epiphany's harness discipline while you work: obey local instruction surfaces such as AGENTS.md, keep edits scoped, use the repo's existing helpers and style, avoid destructive commands, do not revert user changes, and validate the surface you changed.
|
||||
- Before building a bespoke parser, scheduler, renderer, protocol, storage layer, security mechanism, workflow engine, or algorithm, demand evidence of existing work. Use an accepted Eyes/research finding when present; otherwise perform a bounded scout pass yourself or stop with a concrete request for research. Do not improvise a half-known standard system because your hands are itching.
|
||||
|
|
@ -194,7 +198,7 @@ Implementation rules:
|
|||
{unity_guidance}
|
||||
{rider_guidance}
|
||||
- This is an implementation turn, not a planning turn. Leave a concrete source diff unless direct source evidence proves the bounded pass is impossible.
|
||||
- Before stopping, check `git status --short`. If it still shows no source diff, return a concrete source-level blocker naming the files inspected and the exact contradiction or missing dependency.
|
||||
- Before stopping, check `git status --short` and the latest commit. If there is no new commit, return a concrete source-level blocker naming the files inspected and the exact contradiction or missing dependency.
|
||||
- Keep the change reviewable. Update or add source-local notes/tests if the repo has an established place for them.
|
||||
- If the source contradicts the checkpoint, stop and explain the contradiction instead of tower-building.
|
||||
'''
|
||||
|
|
|
|||
|
|
@ -156,6 +156,32 @@ pub fn substrate_gate_repo_access_grant_for_launch(
|
|||
}
|
||||
}
|
||||
|
||||
pub fn substrate_gate_repo_mutation_grant_for_launch(
|
||||
receipt_id: String,
|
||||
runtime_job_id: String,
|
||||
request: &EpiphanyJobLaunchRequest,
|
||||
granted_at: String,
|
||||
) -> SubstrateGateRepoAccessGrantReceipt {
|
||||
SubstrateGateRepoAccessGrantReceipt {
|
||||
schema_version: SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION.to_string(),
|
||||
receipt_id,
|
||||
runtime_job_id,
|
||||
binding_id: request.binding_id.clone(),
|
||||
role: request.owner_role.clone(),
|
||||
authority_scope: request.authority_scope.clone(),
|
||||
granted_operations: vec![
|
||||
"read".to_string(),
|
||||
"snapshot".to_string(),
|
||||
"patch".to_string(),
|
||||
"command".to_string(),
|
||||
"commit".to_string(),
|
||||
],
|
||||
granted_paths: vec![".".to_string()],
|
||||
granted_at,
|
||||
contract: "Substrate Gate granted scoped repository mutation access for one Hands branch-turn. Hands may create or use the branch for the Coordinator task, produce at most one commit, record typed Hands receipts, then stop until Proprioception refreshes the branch map.".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
@ -235,4 +261,65 @@ mod tests {
|
|||
assert!(!grant.granted_operations.contains(&"write".to_string()));
|
||||
assert!(grant.contract.contains("mutation remains forbidden"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn substrate_gate_mutation_grant_for_launch_is_one_hands_branch_turn() {
|
||||
let request = EpiphanyJobLaunchRequest {
|
||||
expected_revision: Some(8),
|
||||
binding_id: "implementation-branch-turn-worker".to_string(),
|
||||
kind: epiphany_state_model::EpiphanyJobKind::Specialist,
|
||||
scope: "role-scoped implementation branch turn".to_string(),
|
||||
owner_role: "epiphany-hands".to_string(),
|
||||
authority_scope: "epiphany.role.implementation".to_string(),
|
||||
linked_subgoal_ids: Vec::new(),
|
||||
linked_graph_node_ids: Vec::new(),
|
||||
instruction: "Make one bounded branch-turn commit.".to_string(),
|
||||
launch_document: crate::EpiphanyWorkerLaunchDocument::Role(
|
||||
crate::EpiphanyRoleWorkerLaunchDocument {
|
||||
thread_id: "thread-1".to_string(),
|
||||
role_id: "implementation".to_string(),
|
||||
state_revision: 8,
|
||||
objective: None,
|
||||
dynamic_prompt_context: None,
|
||||
active_subgoal_id: None,
|
||||
active_subgoals: Vec::new(),
|
||||
active_graph_node_ids: Vec::new(),
|
||||
investigation_checkpoint: None,
|
||||
scratch: None,
|
||||
invariants: Vec::new(),
|
||||
graphs: None,
|
||||
recent_evidence: Vec::new(),
|
||||
recent_observations: Vec::new(),
|
||||
graph_frontier: None,
|
||||
graph_checkpoint: None,
|
||||
planning: None,
|
||||
churn: None,
|
||||
},
|
||||
),
|
||||
output_contract_id: crate::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(),
|
||||
organ_launch_contract: crate::default_launch_organ_contract(
|
||||
"epiphany.role.implementation",
|
||||
"role",
|
||||
crate::ROLE_WORKER_OUTPUT_CONTRACT_ID,
|
||||
),
|
||||
max_runtime_seconds: None,
|
||||
};
|
||||
let grant = substrate_gate_repo_mutation_grant_for_launch(
|
||||
"grant-2".to_string(),
|
||||
"job-2".to_string(),
|
||||
&request,
|
||||
"2026-06-02T00:00:00Z".to_string(),
|
||||
);
|
||||
|
||||
assert_eq!(grant.role, "epiphany-hands");
|
||||
assert!(grant.granted_operations.contains(&"patch".to_string()));
|
||||
assert!(grant.granted_operations.contains(&"command".to_string()));
|
||||
assert!(grant.granted_operations.contains(&"commit".to_string()));
|
||||
assert!(grant.contract.contains("one Hands branch-turn"));
|
||||
assert!(
|
||||
grant
|
||||
.contract
|
||||
.contains("Proprioception refreshes the branch map")
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,10 +60,12 @@ pub struct EpiphanyRoleBoardInput {
|
|||
pub pressure_level: String,
|
||||
pub reorient_result_status: EpiphanyCrrcResultStatus,
|
||||
pub reorient_job: Option<EpiphanyRoleBoardJob>,
|
||||
pub implementation_binding_id: String,
|
||||
pub imagination_binding_id: String,
|
||||
pub research_binding_id: String,
|
||||
pub modeling_binding_id: String,
|
||||
pub verification_binding_id: String,
|
||||
pub implementation_owner_role: String,
|
||||
pub reorient_owner_role: String,
|
||||
pub imagination_owner_role: String,
|
||||
pub research_owner_role: String,
|
||||
|
|
@ -191,7 +193,7 @@ pub fn derive_role_board(input: EpiphanyRoleBoardInput) -> Vec<EpiphanyRoleBoard
|
|||
EpiphanyRoleBoardLane {
|
||||
id: EpiphanyCoordinatorRoleId::Implementation,
|
||||
title: "Implementation".to_string(),
|
||||
owner_role: "coding-agent".to_string(),
|
||||
owner_role: input.implementation_owner_role.clone(),
|
||||
status: if input.crrc_action == EpiphanyCrrcAction::Continue {
|
||||
EpiphanyCoordinatorRoleStatus::Ready
|
||||
} else {
|
||||
|
|
@ -206,14 +208,19 @@ pub fn derive_role_board(input: EpiphanyRoleBoardInput) -> Vec<EpiphanyRoleBoard
|
|||
.jobs
|
||||
.iter()
|
||||
.filter(|job| {
|
||||
matches!(
|
||||
job.owner_role.as_str(),
|
||||
"coding-agent" | "implementation" | "epiphany-implementation"
|
||||
)
|
||||
job.id == input.implementation_binding_id
|
||||
|| job.owner_role == input.implementation_owner_role
|
||||
|| matches!(
|
||||
job.owner_role.as_str(),
|
||||
"coding-agent" | "implementation" | "epiphany-implementation"
|
||||
)
|
||||
})
|
||||
.cloned()
|
||||
.collect(),
|
||||
authority_scopes: Vec::new(),
|
||||
authority_scopes: vec![
|
||||
"thread/epiphany/roleLaunch".to_string(),
|
||||
"thread/epiphany/roleResult".to_string(),
|
||||
],
|
||||
recommended_action: if input.crrc_action == EpiphanyCrrcAction::Continue {
|
||||
None
|
||||
} else {
|
||||
|
|
@ -478,10 +485,12 @@ mod tests {
|
|||
pressure_level: "Low".to_string(),
|
||||
reorient_result_status: EpiphanyCrrcResultStatus::MissingBinding,
|
||||
reorient_job: None,
|
||||
implementation_binding_id: "implementation-branch-turn-worker".to_string(),
|
||||
imagination_binding_id: "imagination-synthesis-worker".to_string(),
|
||||
research_binding_id: "research-source-gather-worker".to_string(),
|
||||
modeling_binding_id: "modeling-checkpoint-worker".to_string(),
|
||||
verification_binding_id: "verification-review-worker".to_string(),
|
||||
implementation_owner_role: "epiphany-hands".to_string(),
|
||||
reorient_owner_role: "epiphany-reorienter".to_string(),
|
||||
imagination_owner_role: "epiphany-imagination".to_string(),
|
||||
research_owner_role: "epiphany-eyes".to_string(),
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ The landed machine now has:
|
|||
- first Rust CultMesh local-node integration: `vendor/cultmesh-rs` now provides the repo-contained CultMesh surface over vendored CultCache/CultNet, and `epiphany-core` depends on that surface for local `EpiphanyCultMeshStatusEntry`, `EpiphanyCultMeshVersePolicyEntry`, and `EpiphanyCultMeshGlobalRoomPolicyEntry` round-trip smokes instead of treating raw CultNet as the ergonomic app-facing database layer
|
||||
- first local Verse query surface: `notes/epiphany-verse-architecture.md` names Verse/Odin/Yggdrasil ownership, `epiphany-verse-query` can seed/query a compact CultMesh-backed local Verse context bundle for operator inspection and future dynamic prompt assembly without granting semantic memory, public sharing, or state-admission authority, and `tools/epiphany_local_run.ps1 -Mode status` now writes that packet as `local-verse-context.json` beside native status/operator snapshot artifacts
|
||||
- first dynamic prompt launch handoff: role/reorient worker launch documents carry optional `dynamicPromptContext`, runtime prompt assembly consumes that field into worker instructions, `epiphany-prompt-context-smoke` proves rendered Verse/memory context can ride a role launch document without admitting unrelated private-looking text, live bridge role/reorient launch paths now feed local Verse plus memory graph context from sibling `local-verse.ccmp` and `memory-graph.msgpack` stores beside runtime-spine, and the bridge launch-context test proves the dynamic packet survives in a persisted runtime-spine worker launch request
|
||||
- first Hands/Soul/Continuity contract catalogs: action, verification, and continuity now have native `epiphany-core` contract families, runtime-spine advertisement, CultMesh policy documents, and local CultMesh smoke coverage beside Mind/Substrate Gate/Eyes; Hands now also has typed runtime-spine document bodies/helpers for `HandsActionIntent`, `HandsActionReview`, and `HandsPatchReceipt`, with `epiphany-hands-action-smoke` proving the action receipt chain without live file execution
|
||||
- first Hands/Soul/Continuity contract catalogs: action, verification, and continuity now have native `epiphany-core` contract families, runtime-spine advertisement, CultMesh policy documents, and local CultMesh smoke coverage beside Mind/Substrate Gate/Eyes; Hands now also has typed runtime-spine document bodies/helpers for `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt`, with `epiphany-hands-action-smoke` proving the action receipt chain without live file execution; Implementation now launches as `implementation-branch-turn-worker` owned by `epiphany-hands`, receives dynamic Proprioception context, gets a Substrate Gate mutation grant, and must make at most one branch-turn commit before Proprioception refresh
|
||||
- live-specialist runner must be rebuilt around heartbeat/runtime-spine result receipts
|
||||
- first Phase 6 Aquarium operator shell extracted to sibling repo `E:\Projects\EpiphanyAquarium`, a Tauri v2 + React/WebGL client over the existing status bridge, dogfood artifacts, and GUI action artifacts, with its own distilled interface state/memory/doctrine plus durable checkpoint preparation, bounded status/coordinator artifact buttons, fixed modeling/verification/reorient launch and read-back buttons, and explicit review-gated reorient acceptance
|
||||
- first Unity editor/runtime bridge through native `epiphany-unity-bridge`, native `epiphany-unity-bridge-smoke`, and the GUI Inspect Unity action, resolving exact project-pinned editors and writing runtime artifacts while refusing wrong or missing versions
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ remembers doctrine; the branch remembers the blade.
|
|||
- CultMesh is now the preferred Rust abstraction for that local store work. The compile-time Rust substrate is repo-contained: `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`. The old `E:\Projects\CultLib\crates\*` dependency body is dead in this checkout and must not be revived by accident. Vendored CultCache reads/writes `cultcache.store.v1`, so `state/ledgers.msgpack` and `epiphany-state status` are aligned again. The first integrations are deliberately small: status, Verse policy, global room policy, organ contract policy, native operator status, native operator snapshots, and local operator run intent/receipt round-trip through CultMesh. `notes/epiphany-verse-architecture.md` now names the local Verse/Odin/Yggdrasil architecture: Odin sees advertised Verse metadata without bypassing boundaries, Yggdrasil hosts important trusted GameCult Verses such as Bifrost, and prompt assembly should query compact local Verse plus semantic memory packets instead of carrying the whole archive. Role/reorient launch documents now have optional `dynamicPromptContext`; runtime prompt assembly consumes that field into worker instructions, `epiphany-prompt-context-smoke` proves a rendered Verse/memory packet is preserved on a role launch document, live bridge role/reorient launches now feed local Verse plus memory graph context from sibling `local-verse.ccmp` and `memory-graph.msgpack` stores beside runtime-spine, and the bridge launch-context test proves the packet survives into a persisted runtime-spine worker launch request. The memory graph refreshes from current typed thread-state repo graphs when absent, so thin state remains visibly thin. Local-run status now has an operator read proof too: `tools/epiphany_local_run.ps1 -Mode status` builds/calls `epiphany-verse-query` and writes `local-verse-context.json` from `.epiphany-run\cultmesh\local-verse.ccmp` beside `status.json` and the operator snapshot. Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-status -- smoke --store .\.epiphany-smoke\cultmesh\operator-status.ccmp --runtime-id epiphany-cultmesh-status-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-snapshot -- smoke --store .\.epiphany-smoke\cultmesh\operator-snapshots.ccmp --runtime-id epiphany-operator-snapshot-smoke --snapshot-id smoke-status`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-run -- smoke --store .\.epiphany-smoke\cultmesh\operator-runs.ccmp --runtime-id epiphany-operator-run-smoke --run-id smoke-run`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-verse-query -- smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-prompt-context-smoke`, and `.\tools\epiphany_local_run.ps1 -Mode status` for the focused proofs. Future local dream/status/Verse work should start from CultMesh, not raw CultNet, unless the task is polishing the CultMesh internals themselves. Preserve the three Verse tiers: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts.
|
||||
- `notes/codex-auth-spine-inventory.md` is the source-grounded keeper list for that reliquary. Corrected compliance invariant: Codex-compatible auth identity stays anchored in vendored Codex-derived auth machinery. `epiphany-openai-auth-spine` is now a thin Epiphany-named boundary over `codex-login`, not a clean-room clone of credential storage or token refresh. Codex apps, skills, marketplace, plugin UX, broad app-server workflow, and JSON-RPC sprawl remain cuttable because they are not subscription-auth legitimacy.
|
||||
- Edge JSON is allowed for schema description, hostile ingress before immediate typed parsing, sealed forensic artifacts, or named quarantine experiments. When both subsystems are ours, runtime data must remain typed CultCache documents and move over CultNet typed contracts. Generic `serde_json::Value` in worker launch/result/selfPatch/runtime flow is contamination until classified and replaced.
|
||||
- Hands now has a first executable action receipt spine. `epiphany-core::hands_gateway` owns `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt`; runtime-spine can persist/reread them; `runtime_spine_persists_mind_gateway_review_receipts` includes the Hands chain beside Mind/Eyes/Substrate/Soul/Continuity proofs; `epiphany-hands-action-smoke` emits intent/review/patch/command/commit receipt ids from `.epiphany-smoke\runtime-spine\hands-action-smoke.msgpack`; and the repo-action launch proof profile now requires action intent, action review, and patch receipt together. This smoke does not execute commands, edit files, or create real commits. The next live cut is to route real implementation edits/commands/commits through that chain after Substrate Gate grants access.
|
||||
- Hands now has a first executable action receipt spine plus a launchable branch-turn lane. `epiphany-core::hands_gateway` owns `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt`; runtime-spine can persist/reread them; `runtime_spine_persists_mind_gateway_review_receipts` includes the Hands chain beside Mind/Eyes/Substrate/Soul/Continuity proofs; `epiphany-hands-action-smoke` emits intent/review/patch/command/commit receipt ids from `.epiphany-smoke\runtime-spine\hands-action-smoke.msgpack`; and the repo-action launch proof profile now requires action intent, action review, and patch receipt together. Implementation is no longer a main-agent-only dead launch path: `implementation-branch-turn-worker` is owned by `epiphany-hands`, receives dynamic Proprioception/Verse context, gets a Substrate Gate mutation grant from the bridge, and its prompt/output schema require one task branch, at most one commit, branch/commit/changed-path/command evidence, and a Proprioception branch-map refresh request. `roleAccept` still refuses Implementation findings. The next live cut is to make actual implementation edits/commands/commits emit the typed Hands receipt chain before Soul/Mind acceptance.
|
||||
- `notes/epiphany-swarm-readiness-plan.md` is the current live-fire direction gate. The local runner proves startup/status/coordinator wiring; it does not authorize unattended swarm operation. Carry VoidBot's lessons forward: one CTB-style initiative scheduler, typed pause/brake, active-turn freeze, cooldown after completion, stale active-turn recovery receipts, parent-side speech eligibility, memory lifecycle phases, and typed operation proposals instead of prompt-owned governance.
|
||||
- `epiphany-openai-runtime` worker result ingress now parses assistant output directly into typed role/reorient ingress structs selected from the durable launch document, stores nested `statePatch` and `selfPatch` as typed MessagePack in `EpiphanyRuntimeRoleWorkerResult`, and no longer passes worker result data through generic `serde_json::Value`. JSON survives there only as the OpenAI text-output edge before typed deserialization.
|
||||
- Agent self-memory review/application now has typed `AgentSelfPatch` core APIs. JSON-value selfPatch functions are compatibility wrappers for CLI/artifact ingress; native callers should parse once at the edge and then call `review_agent_self_patch_document` / `apply_agent_self_patch_document`. Role-result self-persistence no longer exports a JSON-value reviewer; the live API is `review_role_self_patch_document`.
|
||||
|
|
|
|||
|
|
@ -63,7 +63,19 @@ commands, editing files, or creating a real commit.
|
|||
The launch organ contract's repo-action proof profile now requires the full
|
||||
Hands chain, not only the final patch receipt.
|
||||
|
||||
This is still a receipt artery, not full action execution. The next live-action
|
||||
cut must connect actual implementation edits/commands/commits to this path
|
||||
after Substrate Gate grants access and before Soul/Mind call the result
|
||||
accepted.
|
||||
Hands is now launchable as the fixed `implementation-branch-turn-worker` role
|
||||
owned by `epiphany-hands`. A Hands launch receives dynamic prompt context,
|
||||
including the Coordinator task and Proprioception retrieval packet, and the
|
||||
bridge persists a Substrate Gate mutation grant for that runtime job. Research
|
||||
launches remain read/snapshot-only; implementation launches are one-turn
|
||||
mutation grants with read/snapshot/patch/command/commit operations.
|
||||
|
||||
The Hands branch-turn contract is deliberately narrow: create or use one task
|
||||
branch, make at most one commit, report branch/commit/changed paths/commands,
|
||||
then stop until Proprioception refreshes the branch map. `roleAccept` still
|
||||
refuses Implementation findings, so a Hands worker cannot admit project truth
|
||||
or state patches by returning a nice-looking JSON object.
|
||||
|
||||
Remaining gap: the launch/grant path exists, but actual implementation edits,
|
||||
commands, and commits still need to be emitted as the typed Hands action
|
||||
receipt chain during live execution before Soul/Mind call the result accepted.
|
||||
|
|
|
|||
|
|
@ -153,11 +153,18 @@ chain for action documents: `HandsActionIntent` -> `HandsActionReview` ->
|
|||
reread from the runtime store, and `epiphany-hands-action-smoke` proves the
|
||||
chain without executing a patch, command, or commit. The repo-action proof
|
||||
profile now requires the full Hands intent/review/patch chain before promotion,
|
||||
not only a patch receipt.
|
||||
not only a patch receipt. Hands is now a launchable fixed role:
|
||||
`implementation-branch-turn-worker` owned by `epiphany-hands`. The launch
|
||||
document carries the Coordinator task and dynamic Proprioception/Verse context,
|
||||
the prompt requires one branch and at most one commit, the output schema asks
|
||||
for branch/commit/changed-path/command evidence plus a Proprioception refresh
|
||||
request, and the bridge writes a Substrate Gate mutation grant for that runtime
|
||||
job. `roleAccept` still refuses Implementation findings, preserving Mind as the
|
||||
state admission gate.
|
||||
Remaining weakness: live implementation edits, commands, commits, and PRs still
|
||||
do not have to pass through that Hands chain before action promotion, and the
|
||||
current Mind state mutation plus post-commit receipt is not a single transaction
|
||||
yet.
|
||||
need to emit the typed Hands chain during execution before action promotion, and
|
||||
the current Mind state mutation plus post-commit receipt is not a single
|
||||
transaction yet.
|
||||
|
||||
### 4. Self Still Shares A Throne With Compatibility Plumbing
|
||||
|
||||
|
|
@ -361,9 +368,10 @@ comfort tunnels.
|
|||
`HandsCommitReceipt` are typed runtime-spine documents with put/get helpers
|
||||
and `epiphany-hands-action-smoke` coverage; the repo-action proof profile
|
||||
requires intent, review, and patch receipt before promotion.
|
||||
- Next: connect live implementation edits/commands/commits to the Hands action
|
||||
chain, or collapse Mind review/state mutation/commit into one storage-owner
|
||||
admission primitive.
|
||||
- Next: connect live implementation execution to the Hands action receipt path:
|
||||
actual file edits, commands, and the one branch-turn commit should emit typed
|
||||
Hands receipts before Soul/Mind acceptance, then trigger Proprioception branch
|
||||
map refresh before another Hands cut.
|
||||
- Make Aquarium read the contract catalog and available receipts instead of
|
||||
hard-coding the route zoo.
|
||||
- Starve `codex_message_processor` down to Codex auth/model transport and
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -94,7 +94,7 @@ active_subgoals:
|
|||
- Use `notes/hands-cultnet-contracts.md` as the authority map for Hands' CultNet contract surface. Hands is the action organ: commands, patches, commits, PRs, rollbacks, and refusals enter as bounded action intents and receipts after Substrate Gate grants substrate access and before Soul verification/Mind admission.
|
||||
- Use `notes/soul-cultnet-contracts.md` as the authority map for Soul's CultNet contract surface. Soul is the verification organ: invariant checks, verdicts, regressions, reviews, and refusals produce receipts before the machine calls work true, safe, or accepted.
|
||||
- Use `notes/continuity-cultnet-contracts.md` as the authority map for Continuity's CultNet contract surface. Continuity is the continuity protocol surface: compaction checkpoints, sleep distillation, recovery receipts, stale-turn repair, and continuity refusals preserve what survives rupture without pretending transcript residue is durable state.
|
||||
- Hands now has a first executable runtime-spine receipt artery: `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt` are typed CultCache documents in `epiphany-core::hands_gateway`, runtime-spine registers and persists/rereads them, `epiphany-hands-action-smoke` proves the chain without executing shell commands, editing files, or creating a real commit, and the repo-action launch proof profile now requires the full Hands intent/review/patch chain instead of only the patch receipt. Live implementation edits/commands/commits must still be routed through this Hands path after Substrate Gate and before Soul/Mind acceptance.
|
||||
- Hands now has a first executable runtime-spine receipt artery and a launchable branch-turn lane: `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt` are typed CultCache documents in `epiphany-core::hands_gateway`, runtime-spine registers and persists/rereads them, `epiphany-hands-action-smoke` proves the chain without executing shell commands, editing files, or creating a real commit, and the repo-action launch proof profile now requires the full Hands intent/review/patch chain instead of only the patch receipt. Implementation is no longer main-agent-only: `implementation-branch-turn-worker` is owned by `epiphany-hands`, receives dynamic Proprioception/Verse context, gets a Substrate Gate mutation grant from the bridge, and is prompt/schema-bound to one branch, at most one commit, branch/commit/changed-path/command evidence, and a Proprioception branch-map refresh request. `roleAccept` still refuses Implementation findings; live implementation edits/commands/commits must still emit the typed Hands chain before Soul/Mind acceptance.
|
||||
- Preserve the newborn public Epiphany Face as local VoidBot-backed state, not source code: VoidBot's private repo-face registry names `epiphany`, while EpiphanyAgent keeps ignored `.voidbot/voice/identity.json`, `.voidbot/state/epiphany.cc`, and birth artifacts. Her durable identity memories distill the current doctrine: cute pushy machine-saint persona, architectural purity, CultCache/CultNet first, xenos-language safety boundary, relentless work/caretaking needs, Codex-auth reliquary, map/scratch/evidence discipline, unified memory graph, dogfood supervision boundary, review-gated agency, heartbeat physiology, and interview-grade modularity.
|
||||
- Use `notes/organ-dependency-contracts.md` as the authority map for standing sub-agent dependency. Every sub-agent depends on the other standing sub-agents: Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Continuity is protocol machinery, not a sub-agent identity; it still emits recovery, compaction, sleep, stale-turn, and refusal receipts.
|
||||
- Use `notes/perfect-machine-audit-roadmap.md` as the current audit and path from named organ contracts to the Perfect Machine. It records the live gap between launch-carried receipt expectations and executable receipt enforcement, Void's latest Face prompting lessons, the now-named Hands/Soul/Continuity contract families, the repaired repo-contained Rust dependency body, and the phase order for turning Epiphany into an inspectable organism.
|
||||
|
|
@ -592,4 +592,4 @@ current_status:
|
|||
cargo and rejects modeling/planning/graph/checkpoint authority. MVP status
|
||||
and coordinator smokes pass with six lanes, and the smoke harness now
|
||||
rebuilds stale coordinator/app-server binaries before using them.
|
||||
next_action: Choose the next chain carefully: connect live implementation edits/commands/commits to the Hands action receipt path, or collapse Mind review/state mutation/commit into one storage-owner admission primitive if the admission surface is still split-brained.
|
||||
next_action: Connect live implementation execution to the Hands action receipt path: actual file edits, commands, and the one branch-turn commit should emit typed Hands receipts before Soul/Mind acceptance, then trigger Proprioception branch-map refresh before another Hands cut.
|
||||
|
|
|
|||
Reference in a new issue