Purge selfPatch JSON from role results
This commit is contained in:
parent
0060cbbe4f
commit
bd71f1e6dc
8 changed files with 236 additions and 371 deletions
|
|
@ -366,15 +366,45 @@ pub fn review_agent_self_patch(
|
|||
}
|
||||
};
|
||||
|
||||
if !patch_value.is_object() {
|
||||
reasons.push("selfPatch must be a JSON object".to_string());
|
||||
match decode_agent_self_patch(patch_value) {
|
||||
Ok(patch) => reasons.extend(review_agent_self_patch_contract(&target_agent_id, &patch)),
|
||||
Err(reason) => reasons.push(reason),
|
||||
}
|
||||
|
||||
let patch: AgentSelfPatch = serde_json::from_value(patch_value.clone()).unwrap_or_default();
|
||||
if patch.agent_id.as_deref() != Some(target_agent_id.as_str()) {
|
||||
AgentMemoryReview {
|
||||
status: if reasons.is_empty() {
|
||||
"accepted"
|
||||
} else {
|
||||
"rejected"
|
||||
}
|
||||
.to_string(),
|
||||
target_agent_id,
|
||||
target_role_id: role_id.to_string(),
|
||||
target_store: store_path.display().to_string(),
|
||||
reasons,
|
||||
applied: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn decode_agent_self_patch(
|
||||
patch_value: &Value,
|
||||
) -> std::result::Result<AgentSelfPatch, String> {
|
||||
if !patch_value.is_object() {
|
||||
return Err("selfPatch must be a JSON object".to_string());
|
||||
}
|
||||
serde_json::from_value(patch_value.clone())
|
||||
.map_err(|err| format!("selfPatch is not a valid AgentSelfPatch document: {err}"))
|
||||
}
|
||||
|
||||
pub(crate) fn review_agent_self_patch_contract(
|
||||
expected_agent_id: &str,
|
||||
patch: &AgentSelfPatch,
|
||||
) -> Vec<String> {
|
||||
let mut reasons = Vec::new();
|
||||
if patch.agent_id.as_deref() != Some(expected_agent_id) {
|
||||
reasons.push(format!(
|
||||
"selfPatch agentId {:?} does not match this lane; expected {:?}",
|
||||
patch.agent_id, target_agent_id
|
||||
patch.agent_id, expected_agent_id
|
||||
));
|
||||
}
|
||||
match patch.reason.as_deref() {
|
||||
|
|
@ -384,17 +414,15 @@ pub fn review_agent_self_patch(
|
|||
),
|
||||
}
|
||||
|
||||
if let Some(object) = patch_value.as_object() {
|
||||
for key in object.keys() {
|
||||
if forbidden_patch_field(key) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is project truth or authority; use the proper Epiphany control surface instead"
|
||||
));
|
||||
} else if !allowed_patch_field(key) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is not part of the bounded memory mutation contract"
|
||||
));
|
||||
}
|
||||
for key in patch.extra.keys() {
|
||||
if forbidden_patch_field(key) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is project truth or authority; use the proper Epiphany control surface instead"
|
||||
));
|
||||
} else if !allowed_patch_field(key) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is not part of the bounded memory mutation contract"
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -431,19 +459,7 @@ pub fn review_agent_self_patch(
|
|||
);
|
||||
}
|
||||
|
||||
AgentMemoryReview {
|
||||
status: if reasons.is_empty() {
|
||||
"accepted"
|
||||
} else {
|
||||
"rejected"
|
||||
}
|
||||
.to_string(),
|
||||
target_agent_id,
|
||||
target_role_id: role_id.to_string(),
|
||||
target_store: store_path.display().to_string(),
|
||||
reasons,
|
||||
applied: None,
|
||||
}
|
||||
reasons
|
||||
}
|
||||
|
||||
pub fn apply_agent_self_patch(
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ pub struct EpiphanyRoleFindingInterpretation {
|
|||
pub evidence_gaps: Vec<String>,
|
||||
pub risks: Vec<String>,
|
||||
pub state_patch: Option<serde_json::Value>,
|
||||
pub self_patch: Option<serde_json::Value>,
|
||||
pub self_patch: Option<AgentSelfPatch>,
|
||||
pub self_persistence: Option<EpiphanyRoleSelfPersistenceReview>,
|
||||
pub job_error: Option<String>,
|
||||
pub item_error: Option<String>,
|
||||
|
|
@ -114,10 +114,10 @@ pub fn interpret_role_finding(
|
|||
item_error: Option<String>,
|
||||
) -> EpiphanyRoleFindingInterpretation {
|
||||
let state_patch = raw_result.get("statePatch").cloned();
|
||||
let self_patch = raw_result.get("selfPatch").cloned();
|
||||
let self_persistence = self_patch
|
||||
.as_ref()
|
||||
.map(|patch| review_role_self_patch(role_id, patch));
|
||||
let (self_patch, self_persistence) = raw_result
|
||||
.get("selfPatch")
|
||||
.map(|patch| decode_role_self_patch(role_id, patch))
|
||||
.unwrap_or((None, None));
|
||||
let item_error = match role_id {
|
||||
EpiphanyRoleResultRoleId::Imagination => merge_item_error(
|
||||
item_error,
|
||||
|
|
@ -358,95 +358,11 @@ pub fn review_role_self_patch(
|
|||
patch: &serde_json::Value,
|
||||
) -> EpiphanyRoleSelfPersistenceReview {
|
||||
let (expected_agent_id, target_path) = role_self_memory_target(role_id);
|
||||
let mut reasons = Vec::new();
|
||||
let Some(object) = patch.as_object() else {
|
||||
return EpiphanyRoleSelfPersistenceReview {
|
||||
status: EpiphanyRoleSelfPersistenceStatus::Rejected,
|
||||
target_agent_id: Some(expected_agent_id.to_string()),
|
||||
target_path: Some(target_path.to_string()),
|
||||
reasons: vec!["selfPatch must be a JSON object".to_string()],
|
||||
};
|
||||
let reasons = match decode_agent_self_patch(patch) {
|
||||
Ok(patch) => review_agent_self_patch_contract(expected_agent_id, &patch),
|
||||
Err(reason) => vec![reason],
|
||||
};
|
||||
|
||||
let agent_id = object.get("agentId").and_then(serde_json::Value::as_str);
|
||||
match agent_id {
|
||||
Some(id) if id == expected_agent_id => {}
|
||||
Some(id) => reasons.push(format!(
|
||||
"selfPatch agentId {id:?} does not match this lane; expected {expected_agent_id:?}"
|
||||
)),
|
||||
None => reasons.push(format!(
|
||||
"selfPatch must include agentId {expected_agent_id:?}"
|
||||
)),
|
||||
}
|
||||
match object.get("reason").and_then(serde_json::Value::as_str) {
|
||||
Some(reason) if reason.trim().len() >= 16 && reason.len() <= 800 => {}
|
||||
Some(_) => reasons.push(
|
||||
"selfPatch reason must be a bounded explanation of at least 16 characters".to_string(),
|
||||
),
|
||||
None => reasons.push(
|
||||
"selfPatch must include a reason explaining why this improves the lane".to_string(),
|
||||
),
|
||||
}
|
||||
|
||||
let allowed = [
|
||||
"agentId",
|
||||
"reason",
|
||||
"evidenceIds",
|
||||
"semanticMemories",
|
||||
"episodicMemories",
|
||||
"relationshipMemories",
|
||||
"goals",
|
||||
"values",
|
||||
"privateNotes",
|
||||
];
|
||||
let forbidden = [
|
||||
"statePatch",
|
||||
"objective",
|
||||
"activeSubgoalId",
|
||||
"subgoals",
|
||||
"invariants",
|
||||
"graphs",
|
||||
"graphFrontier",
|
||||
"graphCheckpoint",
|
||||
"scratch",
|
||||
"investigationCheckpoint",
|
||||
"jobBindings",
|
||||
"planning",
|
||||
"churn",
|
||||
"mode",
|
||||
"codeEdits",
|
||||
"files",
|
||||
"authorityScope",
|
||||
"backendJobId",
|
||||
"rawResult",
|
||||
];
|
||||
for key in object.keys() {
|
||||
if forbidden.contains(&key.as_str()) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is project truth or authority; use statePatch, roleAccept, or another explicit control surface instead"
|
||||
));
|
||||
} else if !allowed.contains(&key.as_str()) {
|
||||
reasons.push(format!(
|
||||
"selfPatch field {key:?} is not part of the bounded memory mutation contract"
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
let mut mutation_count = 0usize;
|
||||
mutation_count += review_self_patch_memories(&mut reasons, object, "semanticMemories");
|
||||
mutation_count += review_self_patch_memories(&mut reasons, object, "episodicMemories");
|
||||
mutation_count += review_self_patch_memories(&mut reasons, object, "relationshipMemories");
|
||||
mutation_count += review_self_patch_goals(&mut reasons, object);
|
||||
mutation_count += review_self_patch_values(&mut reasons, object);
|
||||
mutation_count += review_self_patch_private_notes(&mut reasons, object);
|
||||
review_self_patch_string_array(&mut reasons, object, "evidenceIds", 16, 160);
|
||||
if mutation_count == 0 {
|
||||
reasons.push(
|
||||
"selfPatch must contain at least one semantic memory, episodic memory, relationship memory, goal, value, or private note"
|
||||
.to_string(),
|
||||
);
|
||||
}
|
||||
|
||||
EpiphanyRoleSelfPersistenceReview {
|
||||
status: if reasons.is_empty() {
|
||||
EpiphanyRoleSelfPersistenceStatus::Accepted
|
||||
|
|
@ -459,6 +375,22 @@ pub fn review_role_self_patch(
|
|||
}
|
||||
}
|
||||
|
||||
fn decode_role_self_patch(
|
||||
role_id: EpiphanyRoleResultRoleId,
|
||||
patch: &serde_json::Value,
|
||||
) -> (
|
||||
Option<AgentSelfPatch>,
|
||||
Option<EpiphanyRoleSelfPersistenceReview>,
|
||||
) {
|
||||
let review = review_role_self_patch(role_id, patch);
|
||||
let decoded = if review.status == EpiphanyRoleSelfPersistenceStatus::Accepted {
|
||||
decode_agent_self_patch(patch).ok()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
(decoded, Some(review))
|
||||
}
|
||||
|
||||
pub fn modeling_role_state_patch_policy_errors(patch: &serde_json::Value) -> Vec<String> {
|
||||
let mut errors = Vec::new();
|
||||
if has_field(patch, "objective") {
|
||||
|
|
@ -853,237 +785,6 @@ fn non_empty_array_field(value: &serde_json::Value, key: &str) -> bool {
|
|||
.is_some_and(|items| !items.is_empty())
|
||||
}
|
||||
|
||||
fn review_self_patch_memories(
|
||||
reasons: &mut Vec<String>,
|
||||
object: &serde_json::Map<String, serde_json::Value>,
|
||||
field: &str,
|
||||
) -> usize {
|
||||
let Some(value) = object.get(field) else {
|
||||
return 0;
|
||||
};
|
||||
let Some(items) = value.as_array() else {
|
||||
reasons.push(format!("selfPatch {field} must be an array"));
|
||||
return 0;
|
||||
};
|
||||
if items.len() > 8 {
|
||||
reasons.push(format!("selfPatch {field} may contain at most 8 records"));
|
||||
}
|
||||
let mut valid = 0usize;
|
||||
for (index, item) in items.iter().enumerate() {
|
||||
let Some(record) = item.as_object() else {
|
||||
reasons.push(format!("selfPatch {field}[{index}] must be an object"));
|
||||
continue;
|
||||
};
|
||||
review_self_patch_id(reasons, record, field, index, "memoryId", "mem-");
|
||||
review_self_patch_summary(reasons, record, field, index, "summary", 600);
|
||||
review_self_patch_unit(reasons, record, field, index, "salience");
|
||||
review_self_patch_unit(reasons, record, field, index, "confidence");
|
||||
valid += 1;
|
||||
}
|
||||
valid
|
||||
}
|
||||
|
||||
fn review_self_patch_goals(
|
||||
reasons: &mut Vec<String>,
|
||||
object: &serde_json::Map<String, serde_json::Value>,
|
||||
) -> usize {
|
||||
let Some(value) = object.get("goals") else {
|
||||
return 0;
|
||||
};
|
||||
let Some(items) = value.as_array() else {
|
||||
reasons.push("selfPatch goals must be an array".to_string());
|
||||
return 0;
|
||||
};
|
||||
if items.len() > 6 {
|
||||
reasons.push("selfPatch goals may contain at most 6 records".to_string());
|
||||
}
|
||||
let mut valid = 0usize;
|
||||
for (index, item) in items.iter().enumerate() {
|
||||
let Some(record) = item.as_object() else {
|
||||
reasons.push(format!("selfPatch goals[{index}] must be an object"));
|
||||
continue;
|
||||
};
|
||||
review_self_patch_id(reasons, record, "goals", index, "goalId", "goal-");
|
||||
review_self_patch_summary(reasons, record, "goals", index, "description", 700);
|
||||
review_self_patch_string(reasons, record, "goals", index, "scope", 80);
|
||||
review_self_patch_unit(reasons, record, "goals", index, "priority");
|
||||
review_self_patch_string(reasons, record, "goals", index, "emotionalStake", 400);
|
||||
review_self_patch_string(reasons, record, "goals", index, "status", 80);
|
||||
valid += 1;
|
||||
}
|
||||
valid
|
||||
}
|
||||
|
||||
fn review_self_patch_values(
|
||||
reasons: &mut Vec<String>,
|
||||
object: &serde_json::Map<String, serde_json::Value>,
|
||||
) -> usize {
|
||||
let Some(value) = object.get("values") else {
|
||||
return 0;
|
||||
};
|
||||
let Some(items) = value.as_array() else {
|
||||
reasons.push("selfPatch values must be an array".to_string());
|
||||
return 0;
|
||||
};
|
||||
if items.len() > 6 {
|
||||
reasons.push("selfPatch values may contain at most 6 records".to_string());
|
||||
}
|
||||
let mut valid = 0usize;
|
||||
for (index, item) in items.iter().enumerate() {
|
||||
let Some(record) = item.as_object() else {
|
||||
reasons.push(format!("selfPatch values[{index}] must be an object"));
|
||||
continue;
|
||||
};
|
||||
review_self_patch_id(reasons, record, "values", index, "valueId", "value-");
|
||||
review_self_patch_summary(reasons, record, "values", index, "label", 240);
|
||||
review_self_patch_unit(reasons, record, "values", index, "priority");
|
||||
if !record
|
||||
.get("unforgivableIfBetrayed")
|
||||
.is_some_and(serde_json::Value::is_boolean)
|
||||
{
|
||||
reasons.push(format!(
|
||||
"selfPatch values[{index}].unforgivableIfBetrayed must be a boolean"
|
||||
));
|
||||
}
|
||||
valid += 1;
|
||||
}
|
||||
valid
|
||||
}
|
||||
|
||||
fn review_self_patch_private_notes(
|
||||
reasons: &mut Vec<String>,
|
||||
object: &serde_json::Map<String, serde_json::Value>,
|
||||
) -> usize {
|
||||
let Some(value) = object.get("privateNotes") else {
|
||||
return 0;
|
||||
};
|
||||
let Some(items) = value.as_array() else {
|
||||
reasons.push("selfPatch privateNotes must be an array".to_string());
|
||||
return 0;
|
||||
};
|
||||
if items.len() > 6 {
|
||||
reasons.push("selfPatch privateNotes may contain at most 6 records".to_string());
|
||||
}
|
||||
for (index, item) in items.iter().enumerate() {
|
||||
match item.as_str() {
|
||||
Some(text) if !text.trim().is_empty() && text.len() <= 600 => {}
|
||||
_ => reasons.push(format!(
|
||||
"selfPatch privateNotes[{index}] must be non-empty text under 600 characters"
|
||||
)),
|
||||
}
|
||||
}
|
||||
items.len()
|
||||
}
|
||||
|
||||
fn review_self_patch_string_array(
|
||||
reasons: &mut Vec<String>,
|
||||
object: &serde_json::Map<String, serde_json::Value>,
|
||||
field: &str,
|
||||
max_items: usize,
|
||||
max_len: usize,
|
||||
) {
|
||||
let Some(value) = object.get(field) else {
|
||||
return;
|
||||
};
|
||||
let Some(items) = value.as_array() else {
|
||||
reasons.push(format!("selfPatch {field} must be an array"));
|
||||
return;
|
||||
};
|
||||
if items.len() > max_items {
|
||||
reasons.push(format!(
|
||||
"selfPatch {field} may contain at most {max_items} records"
|
||||
));
|
||||
}
|
||||
for (index, item) in items.iter().enumerate() {
|
||||
match item.as_str() {
|
||||
Some(text) if !text.trim().is_empty() && text.len() <= max_len => {}
|
||||
_ => reasons.push(format!(
|
||||
"selfPatch {field}[{index}] must be non-empty text under {max_len} characters"
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn review_self_patch_id(
|
||||
reasons: &mut Vec<String>,
|
||||
record: &serde_json::Map<String, serde_json::Value>,
|
||||
collection: &str,
|
||||
index: usize,
|
||||
field: &str,
|
||||
prefix: &str,
|
||||
) {
|
||||
match record.get(field).and_then(serde_json::Value::as_str) {
|
||||
Some(id)
|
||||
if id.starts_with(prefix)
|
||||
&& id.len() <= 120
|
||||
&& id
|
||||
.chars()
|
||||
.all(|ch| ch.is_ascii_alphanumeric() || "-_.".contains(ch)) => {}
|
||||
Some(_) => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} must start with {prefix:?}, avoid whitespace, and stay under 120 characters"
|
||||
)),
|
||||
None => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} is required"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn review_self_patch_summary(
|
||||
reasons: &mut Vec<String>,
|
||||
record: &serde_json::Map<String, serde_json::Value>,
|
||||
collection: &str,
|
||||
index: usize,
|
||||
field: &str,
|
||||
max_len: usize,
|
||||
) {
|
||||
match record.get(field).and_then(serde_json::Value::as_str) {
|
||||
Some(text) if !text.trim().is_empty() && text.len() <= max_len => {}
|
||||
Some(_) => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} must be non-empty text under {max_len} characters"
|
||||
)),
|
||||
None => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} is required"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn review_self_patch_string(
|
||||
reasons: &mut Vec<String>,
|
||||
record: &serde_json::Map<String, serde_json::Value>,
|
||||
collection: &str,
|
||||
index: usize,
|
||||
field: &str,
|
||||
max_len: usize,
|
||||
) {
|
||||
match record.get(field).and_then(serde_json::Value::as_str) {
|
||||
Some(text) if !text.trim().is_empty() && text.len() <= max_len => {}
|
||||
Some(_) => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} must be non-empty text under {max_len} characters"
|
||||
)),
|
||||
None => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} is required"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn review_self_patch_unit(
|
||||
reasons: &mut Vec<String>,
|
||||
record: &serde_json::Map<String, serde_json::Value>,
|
||||
collection: &str,
|
||||
index: usize,
|
||||
field: &str,
|
||||
) {
|
||||
match record.get(field).and_then(serde_json::Value::as_f64) {
|
||||
Some(value) if (0.0..=1.0).contains(&value) => {}
|
||||
Some(_) => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} must be between 0 and 1"
|
||||
)),
|
||||
None => reasons.push(format!(
|
||||
"selfPatch {collection}[{index}].{field} is required"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
@ -1403,6 +1104,9 @@ mod tests {
|
|||
}));
|
||||
}
|
||||
}
|
||||
use crate::agent_memory::AgentSelfPatch;
|
||||
use crate::agent_memory::decode_agent_self_patch;
|
||||
use crate::agent_memory::review_agent_self_patch_contract;
|
||||
use codex_protocol::protocol::EpiphanyAcceptanceReceipt;
|
||||
use codex_protocol::protocol::EpiphanyCodeRef;
|
||||
use codex_protocol::protocol::EpiphanyEvidenceRecord;
|
||||
|
|
|
|||
72
notes/codex-auth-spine-inventory.md
Normal file
72
notes/codex-auth-spine-inventory.md
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
# Codex Auth Spine Inventory
|
||||
|
||||
Objective: keep only the Codex organ that proves OpenAI entitlement and moves typed model-call requests to the OpenAI edge. Everything else is suspect until it earns a live invariant.
|
||||
|
||||
## Live Spine
|
||||
|
||||
Plain path:
|
||||
|
||||
1. Epiphany prepares a typed turn/request document.
|
||||
2. A small auth spine resolves OpenAI credentials.
|
||||
3. A small model transport spine serializes the typed request at the OpenAI wire edge.
|
||||
4. The OpenAI stream is decoded into typed Epiphany runtime events/results.
|
||||
5. Epiphany stores durable state as CultCache documents and exposes CultNet schemas at network edges.
|
||||
|
||||
Current Codex mechanism:
|
||||
|
||||
- `vendor/codex/codex-rs/login/src/auth/manager.rs`
|
||||
- Owns `CodexAuth`, `AuthManager`, token refresh, API-key auth, ChatGPT subscription auth, agent identity auth, and unauthorized recovery.
|
||||
- Real need: OpenAI subscription/API entitlement and refresh behavior.
|
||||
- Smell: imports app-server protocol auth modes and wider Codex protocol types. The auth organ is not cleanly independent.
|
||||
- `vendor/codex/codex-rs/codex-api/src/auth.rs`
|
||||
- Owns `AuthProvider` and `SharedAuthProvider`.
|
||||
- Real need: small async boundary that applies auth headers to transport requests.
|
||||
- Keep candidate. This is close to the shape Epiphany wants.
|
||||
- `vendor/codex/codex-rs/codex-api/src/provider.rs`
|
||||
- Owns endpoint base URL, headers, retry policy, idle timeout, and request construction.
|
||||
- Real need: OpenAI/Azure endpoint configuration.
|
||||
- Keep candidate, but only as model transport configuration.
|
||||
- `vendor/codex/codex-rs/codex-api/src/endpoint/session.rs`
|
||||
- Owns request construction, auth application, retry telemetry, and HTTP/SSE execution.
|
||||
- Real need: authenticated OpenAI HTTP/SSE execution.
|
||||
- Keep candidate if carved away from telemetry and generic endpoint spread.
|
||||
- `vendor/codex/codex-rs/codex-api/src/endpoint/responses.rs`
|
||||
- Owns Responses API request serialization and SSE request launch.
|
||||
- Real need: OpenAI wire adapter.
|
||||
- Allowed JSON: `serde_json::to_value` at this exact external wire edge.
|
||||
- `vendor/codex/codex-rs/codex-client/src/default_client.rs`
|
||||
- Owns reqwest client setup and trace header injection.
|
||||
- Real need: HTTP transport.
|
||||
- Keep candidate, but it should become a small transport dependency, not a Codex identity.
|
||||
- `vendor/codex/codex-rs/core/src/client.rs`
|
||||
- Owns the current live request path from prompt/model info through `ApiResponsesClient`.
|
||||
- Real need: some of this is model-call orchestration.
|
||||
- Smell: currently embedded in a broad Codex session core with tools, session telemetry, prompt assembly, realtime/websocket alternatives, and unauthorized retry loops.
|
||||
|
||||
## Not The Spine
|
||||
|
||||
These may remain in the vendored tree during quarantine, but they are not Epiphany organs:
|
||||
|
||||
- Apps, skills, plugins, marketplace, startup sync, connector inventory.
|
||||
- TUI/CLI/chat UI/session lifecycle except a temporary login UX if needed.
|
||||
- Multi-agent tool plumbing from Codex. Epiphany owns swarm physiology through CultNet/CultCache.
|
||||
- App-server protocol surfaces that exist to mirror Codex product features.
|
||||
- JSON-RPC shapes that expose internal accidents instead of CultNet contracts.
|
||||
- Realtime/websocket, review, guardian, cloud task, backend task, and account UI surfaces unless a specific auth entitlement dependency proves otherwise.
|
||||
|
||||
## Invariants
|
||||
|
||||
- OpenAI auth is a sealed reliquary: it may authenticate and refresh, not own Epiphany runtime shape.
|
||||
- The OpenAI API wire adapter may serialize JSON because OpenAI speaks JSON. That permission does not leak inward.
|
||||
- CultNet schemas describe network edges. CultCache documents carry live state.
|
||||
- A Codex type survives only if it protects one of these invariants: credential validity, authenticated request construction, streaming decode, or model capability/provider metadata.
|
||||
- `codex_message_processor.rs` is not allowed to be the owner of Epiphany runtime truth.
|
||||
|
||||
## Suspicious Load-Bearing Questions
|
||||
|
||||
- Can `AuthManager` be extracted without `codex_app_server_protocol`, `codex_protocol::auth`, and app-server-specific auth modes?
|
||||
- Does Epiphany need Codex websocket/realtime paths, or only Responses SSE?
|
||||
- Which model-provider metadata is genuinely required to keep subscription compatibility?
|
||||
- Can unauthorized recovery live entirely in the auth spine instead of the session/chat processor layer?
|
||||
- Can model-call input/output become one typed Epiphany document pair before the OpenAI edge serialization?
|
||||
|
||||
|
|
@ -366,23 +366,29 @@ that change what the next agent should believe.
|
|||
|
||||
Do not continue implementation automatically from a rehydrate-only request.
|
||||
|
||||
The next real move is Codex starvation, not outward bridge work. The first
|
||||
bounded slice is:
|
||||
The next real move remains Codex starvation, not outward bridge work. The
|
||||
inventory and ledger now exist:
|
||||
|
||||
1. create `notes/codex-auth-spine-inventory.md`
|
||||
2. inventory the minimum vendored Codex path required for OpenAI subscription
|
||||
auth, account/session refresh, model provider config, model request
|
||||
construction, streaming response handling, and rate/error handling
|
||||
3. create `notes/json-contamination-ledger.md`
|
||||
4. classify every Epiphany-relevant `serde_json::Value`, `json!`,
|
||||
`from_value`, and `to_value` as schema/wire descriptor, hostile ingress,
|
||||
sealed forensic artifact, quarantine experiment, or heretek internal blob
|
||||
5. choose the first typed-document replacement target, preferably `selfPatch`
|
||||
or worker launch/result cargo
|
||||
- `notes/codex-auth-spine-inventory.md` maps the minimal Codex auth/model-call
|
||||
reliquary: `login` auth/token refresh, `codex-api` auth/provider/session and
|
||||
Responses edge, `codex-client` transport, and the suspect current
|
||||
`core/src/client.rs` orchestration.
|
||||
- `notes/json-contamination-ledger.md` classifies the major Epiphany JSON
|
||||
contamination. Edge JSON is allowed only for schema/wire boundaries,
|
||||
hostile ingress before typed parse, sealed forensic artifacts, or named
|
||||
quarantine.
|
||||
- First cut landed: role-result `selfPatch` is now an internal typed
|
||||
`AgentSelfPatch` document reviewed by the same contract used by agent memory.
|
||||
The legacy app-server protocol projection serializes it back to JSON only at
|
||||
the quarantine wall.
|
||||
|
||||
Do not resume Rider, Unity, Aquarium, Face, dogfood, planning, app, skill,
|
||||
marketplace, or bridge expansion until this liberation pass has an inventory,
|
||||
ledger, and first cut. No fresh balcony on the contaminated cathedral.
|
||||
Continue with worker launch/result cargo. Replace
|
||||
`EpiphanyJobLaunchRequest.input_json` and `output_schema_json` with typed
|
||||
launch/result documents plus schema ids in `epiphany-core`, then make
|
||||
`codex_message_processor.rs` project those documents instead of assembling
|
||||
loose JSON blobs. Do not resume Rider, Unity, Aquarium, Face, dogfood,
|
||||
planning, app, skill, marketplace, or bridge expansion until this organ is
|
||||
being cut cleanly.
|
||||
|
||||
The Phase 6 freshness slice is landed. It exposes read-only
|
||||
`thread/epiphany/freshness` from live retrieval summaries plus graph
|
||||
|
|
|
|||
64
notes/json-contamination-ledger.md
Normal file
64
notes/json-contamination-ledger.md
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
# JSON Contamination Ledger
|
||||
|
||||
Rule: JSON is allowed at external schema/wire boundaries. Inside Epiphany, live data should be typed CultCache documents or typed CultNet messages. A `serde_json::Value` inside core logic is guilty until it identifies its border checkpoint.
|
||||
|
||||
## Allowed Wire Or Schema JSON
|
||||
|
||||
- `vendor/codex/codex-rs/codex-api/src/endpoint/responses.rs`
|
||||
- Current mechanism: typed `ResponsesApiRequest` is serialized to JSON for the OpenAI Responses HTTP body.
|
||||
- Real need: OpenAI wire protocol.
|
||||
- Verdict: allowed edge JSON.
|
||||
- `vendor/codex/codex-rs/codex-api/src/requests/responses.rs`
|
||||
- Current mechanism: mutates serialized request JSON to attach item ids for Azure.
|
||||
- Real need: compatibility with upstream API quirks.
|
||||
- Smell: typed request loses shape before a provider-specific patch is applied.
|
||||
- Simpler architecture: provider-specific typed request rendering, then JSON emission once.
|
||||
- Schema fixtures, schema catalogs, and protocol snapshot tests.
|
||||
- Verdict: allowed if they test wire schema, not internal state.
|
||||
|
||||
## Internal JSON To Purge
|
||||
|
||||
- `vendor/codex/codex-rs/core/src/codex_thread.rs`
|
||||
- Current mechanism: `EpiphanyJobLaunchRequest.input_json` and `output_schema_json`.
|
||||
- Real need: launch role workers with structured instructions and expected response shape.
|
||||
- What breaks if deleted: current job launch path cannot carry worker input/schema to Codex runtime.
|
||||
- Essential or bad ownership: bad ownership. Worker launch intent should be a typed document plus schema id, not two loose blobs.
|
||||
- Simpler architecture: `EpiphanyWorkerLaunchDocument` in CultCache/CultNet, with typed payload and `output_contract_id`.
|
||||
- Files: `vendor/codex/codex-rs/core/src/codex_thread.rs`, `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs`, `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`, `epiphany-core/src/runtime_spine.rs`.
|
||||
- `epiphany-core/src/surfaces/role_result.rs`
|
||||
- Current mechanism: `state_patch` and `self_patch` are `serde_json::Value`; `selfPatch` is manually revalidated here.
|
||||
- Real need: interpret worker findings and review bounded lane-local memory petitions.
|
||||
- What breaks if deleted: app-server mapping still expects JSON protocol fields.
|
||||
- Essential or bad ownership: bad ownership. `selfPatch` already has a typed `AgentSelfPatch` document in `agent_memory.rs`; role-result review duplicated the contract.
|
||||
- Simpler architecture: role interpretation stores `AgentSelfPatch`, and only the protocol projection serializes JSON for the existing app-server surface.
|
||||
- Files: `epiphany-core/src/agent_memory.rs`, `epiphany-core/src/surfaces/role_result.rs`, `vendor/codex/codex-rs/app-server/src/codex_message_processor.rs`, `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`.
|
||||
- `vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs`
|
||||
- Current mechanism: `ThreadEpiphanyRoleFinding.self_patch: Option<serde_json::Value>`, `ThreadEpiphanyJobLaunchRequest.input_json`, and `output_schema_json`.
|
||||
- Real need: app-server compatibility while Epiphany is still hosted inside Codex.
|
||||
- What breaks if deleted: frontend/server protocol compilation.
|
||||
- Essential or bad ownership: temporary compatibility reliquary, not a final contract.
|
||||
- Simpler architecture: CultNet schema messages generated from typed document structs.
|
||||
|
||||
## Quarantine JSON
|
||||
|
||||
- `epiphany-core/src/heartbeat_state.rs`
|
||||
- Current mechanism: heartbeat cognition stores some `serde_json::Value` fields.
|
||||
- Real need: experimental cognition payloads still changing shape.
|
||||
- Verdict: quarantine only. It must either become typed heartbeat documents or remain clearly marked as volatile cognition scratch.
|
||||
- MCP tool call arguments/results in `vendor/codex/codex-rs/core/src/mcp_tool_call.rs`.
|
||||
- Current mechanism: arbitrary MCP payloads are raw JSON.
|
||||
- Real need: MCP is an external protocol with schema-bearing tools.
|
||||
- Verdict: edge adapter. It does not belong in the Codex auth organ.
|
||||
- Simpler architecture: CultNet MCP adapter with typed request/result wrappers and raw JSON sealed at the MCP edge.
|
||||
- Unity/Rider/void-memory CLI outputs.
|
||||
- Current mechanism: JSON command output and ad hoc parsing.
|
||||
- Real need: bridge external tools while native surfaces mature.
|
||||
- Verdict: quarantine bridges; do not let them define internal contracts.
|
||||
|
||||
## Ranking
|
||||
|
||||
1. Done: purge `selfPatch` as internal JSON. Role-result interpretation now stores the typed `AgentSelfPatch` document and shares the agent-memory contract; JSON remains only at the legacy app-server projection.
|
||||
2. Replace worker launch `input_json` and `output_schema_json` with typed launch documents and schema ids.
|
||||
3. Replace role `statePatch` JSON with typed map/planning/graph patch documents.
|
||||
4. Seal MCP JSON behind a CultNet MCP adapter.
|
||||
5. Audit heartbeat cognition values and either type them or explicitly expire them.
|
||||
Binary file not shown.
|
|
@ -278,5 +278,5 @@ rejected_paths:
|
|||
reason: making Epiphany cleaner inside Codex still preserves the wrong organ; Codex must be starved down to OpenAI subscription auth/model transport, while Epiphany data and subsystem communication move to typed CultCache/CultNet.
|
||||
|
||||
current_status:
|
||||
summary: The prior app-server control-plane rebuild is complete enough as a scar, not as the destination. The new active doctrine is Codex starvation and CultNet liberation: runtime data should be typed CultCache documents; Epiphany-controlled subsystems should communicate through CultNet typed contracts; generic JSON is contamination except at schema/wire, hostile ingress, sealed forensic, or named quarantine boundaries; and vendored Codex should shrink to OpenAI subscription auth/model transport only. `codex_message_processor.rs` remains a contaminated host organ until Epiphany operator surfaces, worker intents/results, runtime lifecycle, and tests are evacuated to native CultNet/CultCache surfaces.
|
||||
next_action: Start the liberation pass, not outward bridge work: create `notes/codex-auth-spine-inventory.md` to inventory the minimum Codex auth/model-call path, create `notes/json-contamination-ledger.md` to classify Epiphany-relevant JSON uses, then choose the first typed-document replacement target such as `selfPatch` or worker launch/result cargo.
|
||||
summary: The Codex starvation pass has its first receipts. `notes/codex-auth-spine-inventory.md` maps the minimal vendored OpenAI auth/model-call spine; `notes/json-contamination-ledger.md` classifies the major Epiphany JSON uses by allowed edge, quarantine, or internal contamination. The first cut moved role-result `selfPatch` handling from raw JSON plus duplicated validators to the typed `AgentSelfPatch` document contract, with JSON serialization retained only at the legacy app-server protocol projection.
|
||||
next_action: Continue the liberation pass by replacing worker launch/result cargo: remove `EpiphanyJobLaunchRequest.input_json` and `output_schema_json` as internal authority, define typed launch/result documents plus schema ids in `epiphany-core`, and make `codex_message_processor.rs` project those documents instead of assembling loose JSON blobs.
|
||||
|
|
|
|||
|
|
@ -13371,7 +13371,10 @@ fn map_protocol_role_finding(
|
|||
evidence_gaps: finding.evidence_gaps,
|
||||
risks: finding.risks,
|
||||
state_patch,
|
||||
self_patch: finding.self_patch,
|
||||
self_patch: finding.self_patch.map(|patch| {
|
||||
serde_json::to_value(patch)
|
||||
.expect("AgentSelfPatch is a serializable protocol projection")
|
||||
}),
|
||||
self_persistence: finding
|
||||
.self_persistence
|
||||
.map(map_protocol_role_self_persistence_review),
|
||||
|
|
|
|||
Reference in a new issue