653 lines
28 KiB
Rust
653 lines
28 KiB
Rust
use crate::EpiphanyLocalVerseContext;
|
|
use epiphany_state_model::EpiphanyMemoryContextPacket;
|
|
use epiphany_state_model::EpiphanyMemoryFreshnessStatus;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct EpiphanyPromptContextInput {
|
|
pub focus: String,
|
|
pub local_verse: EpiphanyLocalVerseContext,
|
|
pub memory_context: EpiphanyMemoryContextPacket,
|
|
}
|
|
|
|
pub fn render_epiphany_prompt_context(input: &EpiphanyPromptContextInput) -> String {
|
|
let mut lines = vec![
|
|
"<epiphany_dynamic_context>".to_string(),
|
|
"## Dynamic Context".to_string(),
|
|
format!("- Focus: {}", compact_line(&input.focus)),
|
|
"- Boundary: this packet is prompt context, not durable state admission.".to_string(),
|
|
"- Boundary: Mind reviews durable state effects; Substrate Gate reviews repo access; public Verse material is thought weather until adoption.".to_string(),
|
|
String::new(),
|
|
"## Local Verse".to_string(),
|
|
format!("- Runtime: `{}`", input.local_verse.runtime_id),
|
|
format!("- Store: `{}`", input.local_verse.store_path),
|
|
format!("- Odin: {}", compact_line(&input.local_verse.odin_scope)),
|
|
format!(
|
|
"- Yggdrasil: {}",
|
|
compact_line(&input.local_verse.yggdrasil_scope)
|
|
),
|
|
format!(
|
|
"- Prompt assembly: {}",
|
|
compact_line(&input.local_verse.prompt_assembly_note)
|
|
),
|
|
];
|
|
|
|
for policy in input.local_verse.verse_policies.iter().take(3) {
|
|
lines.push(format!(
|
|
"- Verse `{}` [{}]: private={}, untrusted_ingress={}, yggdrasil_tunnel={}; {}",
|
|
policy.verse_id,
|
|
policy.tier,
|
|
policy.private_state_allowed,
|
|
policy.untrusted_ingress_allowed,
|
|
policy.yggdrasil_tunnel_allowed,
|
|
compact_line(&policy.purpose)
|
|
));
|
|
}
|
|
|
|
if !input.local_verse.cluster_topology.is_empty() {
|
|
lines.push("## Declared Cluster Topology".to_string());
|
|
for cluster in input.local_verse.cluster_topology.iter().take(7) {
|
|
lines.push(format!(
|
|
"- `{}` -> declared private Verse route `{}`; body domain={}, declared daemon target={}, Eve route={}",
|
|
cluster.display_name,
|
|
cluster.private_verse_id,
|
|
cluster.body_domain,
|
|
cluster.daemon_id,
|
|
cluster.eve_surface_id
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.local_verse.cluster_topology.len(),
|
|
7,
|
|
"cluster topology rows",
|
|
);
|
|
}
|
|
|
|
if !input.local_verse.odin_advertisements.is_empty() {
|
|
lines.push("## Odin Discovery".to_string());
|
|
for advertisement in input.local_verse.odin_advertisements.iter().take(7) {
|
|
lines.push(format!(
|
|
"- `{}` advertises Verse `{}` via Eve `{}`; private_state_exposed={}",
|
|
advertisement.cluster_id,
|
|
advertisement.advertised_verse_id,
|
|
advertisement.eve_surface_id,
|
|
advertisement.private_state_exposed
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.local_verse.odin_advertisements.len(),
|
|
7,
|
|
"Odin advertisements",
|
|
);
|
|
}
|
|
|
|
if let Some(intent) = input.local_verse.latest_eve_connection_intent.as_ref() {
|
|
lines.push("## Eve Collaboration".to_string());
|
|
lines.push(format!(
|
|
"- Intent `{}`: {} -> {} via {}; feedback_route={}; private_state_requested={}",
|
|
intent.intent_id,
|
|
intent.source_cluster_id,
|
|
intent.target_cluster_id,
|
|
intent.target_eve_surface_id,
|
|
intent.feedback_route,
|
|
intent.private_state_requested
|
|
));
|
|
if let Some(receipt) = input
|
|
.local_verse
|
|
.latest_eve_connection_receipt
|
|
.as_ref()
|
|
.filter(|receipt| receipt.intent_id == intent.intent_id)
|
|
{
|
|
lines.push(format!(
|
|
"- Receipt `{}`: status={}, private_state_exposed={}",
|
|
receipt.receipt_id, receipt.status, receipt.private_state_exposed
|
|
));
|
|
}
|
|
}
|
|
|
|
if !input.local_verse.daemon_tool_capabilities.is_empty() {
|
|
lines.push("## Daemon Tool Directory".to_string());
|
|
for capability in input.local_verse.daemon_tool_capabilities.iter().take(10) {
|
|
lines.push(format!(
|
|
"- `{}` hosted by `{}` via `{}`: op={}, available_to_all_agents={}, gate={}",
|
|
capability.capability_id,
|
|
capability.host_daemon_id,
|
|
capability.eve_surface_id,
|
|
capability.operation,
|
|
capability.available_to_all_agents,
|
|
capability.authority_gate
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.local_verse.daemon_tool_capabilities.len(),
|
|
10,
|
|
"daemon tool capabilities",
|
|
);
|
|
}
|
|
|
|
if let Some(summary) = input.local_verse.latest_agent_state_soa_summary.as_ref() {
|
|
lines.push("## Agent State SoA".to_string());
|
|
lines.push(format!(
|
|
"- Summary `{}`: rows={}, source={}, private_state_exposed={}",
|
|
summary.summary_id,
|
|
summary.row_count,
|
|
summary.source_store,
|
|
summary.private_state_exposed
|
|
));
|
|
for index in 0..summary.role_ids.len().min(7) {
|
|
lines.push(format!(
|
|
"- `{}` / `{}`: profile={}, contract={}, semantic={}, episodic={}, relationship={}, goals={}, values={}",
|
|
summary.role_ids[index],
|
|
summary.agent_ids.get(index).cloned().unwrap_or_default(),
|
|
summary.profile_kinds.get(index).cloned().unwrap_or_default(),
|
|
summary
|
|
.portable_contracts
|
|
.get(index)
|
|
.cloned()
|
|
.unwrap_or_default(),
|
|
summary
|
|
.semantic_memory_counts
|
|
.get(index)
|
|
.copied()
|
|
.unwrap_or_default(),
|
|
summary
|
|
.episodic_memory_counts
|
|
.get(index)
|
|
.copied()
|
|
.unwrap_or_default(),
|
|
summary
|
|
.relationship_memory_counts
|
|
.get(index)
|
|
.copied()
|
|
.unwrap_or_default(),
|
|
summary.goal_counts.get(index).copied().unwrap_or_default(),
|
|
summary.value_counts.get(index).copied().unwrap_or_default()
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
summary.role_ids.len(),
|
|
7,
|
|
"agent state SoA rows",
|
|
);
|
|
}
|
|
|
|
if let Some(intent) = input
|
|
.local_verse
|
|
.latest_daemon_tool_invocation_intent
|
|
.as_ref()
|
|
{
|
|
lines.push("## Daemon Tool Invocation".to_string());
|
|
lines.push(format!(
|
|
"- Intent `{}`: {} requested `{}` on `{}` via {}; gate={}; private_state_requested={}",
|
|
intent.intent_id,
|
|
intent.requesting_agent_id,
|
|
intent.operation,
|
|
intent.host_daemon_id,
|
|
intent.eve_surface_id,
|
|
intent.authority_gate,
|
|
intent.private_state_requested
|
|
));
|
|
if let Some(receipt) = input
|
|
.local_verse
|
|
.latest_daemon_tool_invocation_receipt
|
|
.as_ref()
|
|
.filter(|receipt| receipt.intent_id == intent.intent_id)
|
|
{
|
|
lines.push(format!(
|
|
"- Receipt `{}`: status={}, receipt_contract={}, private_state_exposed={}",
|
|
receipt.receipt_id,
|
|
receipt.status,
|
|
receipt.receipt_contract_type,
|
|
receipt.private_state_exposed
|
|
));
|
|
}
|
|
}
|
|
|
|
if let Some(intent) = input
|
|
.local_verse
|
|
.arrival_latest_bifrost_body_change_publication_intent
|
|
.as_ref()
|
|
{
|
|
lines.push("## Bifrost Publication Gate".to_string());
|
|
lines.push(format!(
|
|
"- Intent `{}`: {} -> {}; paths={}, verification_receipts={}, review_receipts={}, private_state_included={}",
|
|
intent.intent_id,
|
|
intent.source_agent_id,
|
|
intent.target_repository,
|
|
intent.changed_paths.len(),
|
|
intent.verification_receipt_ids.len(),
|
|
intent.review_receipt_ids.len(),
|
|
intent.private_state_included
|
|
));
|
|
if let Some(receipt) = input
|
|
.local_verse
|
|
.arrival_latest_bifrost_body_change_publication_receipt
|
|
.as_ref()
|
|
.filter(|receipt| receipt.intent_id == intent.intent_id)
|
|
{
|
|
lines.push(format!(
|
|
"- Receipt `{}`: status={}, ledger={}, github_receipt={}, private_state_exposed={}",
|
|
receipt.receipt_id,
|
|
receipt.status,
|
|
receipt.bifrost_ledger_entry_id,
|
|
receipt.github_publication_receipt_id,
|
|
receipt.private_state_exposed
|
|
));
|
|
if let Some(github) = input
|
|
.local_verse
|
|
.arrival_latest_bifrost_github_publication_receipt
|
|
.as_ref()
|
|
.filter(|github| github.bifrost_publication_receipt_id == receipt.receipt_id)
|
|
{
|
|
lines.push(format!(
|
|
"- GitHub `{}`: pr={}, hands_pr={}, ledger={}, private_state_exposed={}",
|
|
github.receipt_id,
|
|
github.pull_request_url,
|
|
github.hands_pr_receipt_id,
|
|
github.ledger_entry_id,
|
|
github.private_state_exposed
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(summary) = input.local_verse.latest_work_loop_summary.as_ref() {
|
|
lines.push("## Work Loop Receipt Digest".to_string());
|
|
lines.push(format!(
|
|
"- Telemetry `{}`: {} -> {}; hands=({}/{}/{}), changed_paths={}, source_refs={}, soul_receipts={}, verification_assertions={}",
|
|
summary.telemetry_id,
|
|
summary.source_stage,
|
|
summary.target_stages.join(","),
|
|
summary.hands_patch_receipt_id,
|
|
summary.hands_command_receipt_id,
|
|
summary.hands_commit_receipt_id,
|
|
summary.changed_path_count,
|
|
summary.source_ref_count,
|
|
summary.soul_receipt_ids.len(),
|
|
summary.verification_assertion_count
|
|
));
|
|
lines.push(format!("- {}", compact_line(&summary.sealed_preview_note)));
|
|
}
|
|
|
|
if !input.local_verse.contract_summaries.is_empty() {
|
|
lines.push("## Organ Contract Summary".to_string());
|
|
for contract in input.local_verse.contract_summaries.iter().take(8) {
|
|
lines.push(format!(
|
|
"- `{}` [{} -> {}]: ops={}, receipts={}",
|
|
contract.contract_id,
|
|
contract.authority,
|
|
contract.verse_id,
|
|
contract.operations.len(),
|
|
contract.receipt_document_types.len()
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.local_verse.contract_summaries.len(),
|
|
8,
|
|
"organ contract summaries",
|
|
);
|
|
}
|
|
|
|
lines.push("## Semantic Memory Context".to_string());
|
|
lines.push(format!(
|
|
"- Packet `{}` from query `{}`",
|
|
input.memory_context.id, input.memory_context.query_id
|
|
));
|
|
lines.push(format!(
|
|
"- Canonical RepoModel: revision={}, hash=`{}`",
|
|
input.memory_context.repo_model_revision, input.memory_context.repo_model_hash
|
|
));
|
|
|
|
for item in input.memory_context.frontier.iter().take(6) {
|
|
lines.push(format!(
|
|
"- Frontier `{}` [{}] next `{}`: body={}; question={}; gap={}; dependencies={}",
|
|
item.id,
|
|
render_frontier_status(item.status),
|
|
item.recommended_next_organ,
|
|
compact_line(&item.migration_body),
|
|
compact_line(&item.question),
|
|
compact_line(&item.gap),
|
|
if item.dependency_item_ids.is_empty() {
|
|
"none".to_string()
|
|
} else {
|
|
item.dependency_item_ids.join(", ")
|
|
}
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.memory_context.frontier.len(),
|
|
6,
|
|
"repo frontier items",
|
|
);
|
|
|
|
for summary in input.memory_context.summaries.iter().take(4) {
|
|
lines.push(format!(
|
|
"- Summary `{}` [{}]: {}; next: {}",
|
|
summary.id,
|
|
render_freshness(summary.freshness),
|
|
compact_line(&summary.claim),
|
|
compact_line(&summary.action_implication)
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.memory_context.summaries.len(),
|
|
4,
|
|
"memory summaries",
|
|
);
|
|
|
|
for node in input.memory_context.nodes.iter().take(6) {
|
|
lines.push(format!(
|
|
"- Node `{}` [{}]: {}; next: {}",
|
|
node.id,
|
|
node.title,
|
|
compact_line(&node.claim),
|
|
compact_line(&node.action_implication)
|
|
));
|
|
}
|
|
push_omitted_count(
|
|
&mut lines,
|
|
input.memory_context.nodes.len(),
|
|
6,
|
|
"memory nodes",
|
|
);
|
|
|
|
if !input.memory_context.warnings.is_empty() {
|
|
lines.push("## Memory Context Warnings".to_string());
|
|
for warning in input.memory_context.warnings.iter().take(4) {
|
|
lines.push(format!("- {}", compact_line(warning)));
|
|
}
|
|
}
|
|
|
|
if !input.memory_context.missing_node_ids.is_empty()
|
|
|| !input.memory_context.missing_edge_ids.is_empty()
|
|
{
|
|
lines.push("## Missing Memory References".to_string());
|
|
if !input.memory_context.missing_node_ids.is_empty() {
|
|
lines.push(format!(
|
|
"- Missing nodes: {}",
|
|
input.memory_context.missing_node_ids.join(", ")
|
|
));
|
|
}
|
|
if !input.memory_context.missing_edge_ids.is_empty() {
|
|
lines.push(format!(
|
|
"- Missing edges: {}",
|
|
input.memory_context.missing_edge_ids.join(", ")
|
|
));
|
|
}
|
|
}
|
|
|
|
lines.push("</epiphany_dynamic_context>".to_string());
|
|
lines.join("\n")
|
|
}
|
|
|
|
fn render_freshness(status: EpiphanyMemoryFreshnessStatus) -> &'static str {
|
|
match status {
|
|
EpiphanyMemoryFreshnessStatus::Missing => "missing",
|
|
EpiphanyMemoryFreshnessStatus::Ready => "ready",
|
|
EpiphanyMemoryFreshnessStatus::Stale => "stale",
|
|
EpiphanyMemoryFreshnessStatus::Indexing => "indexing",
|
|
EpiphanyMemoryFreshnessStatus::Unavailable => "unavailable",
|
|
}
|
|
}
|
|
|
|
fn render_frontier_status(status: epiphany_state_model::RepoFrontierStatus) -> &'static str {
|
|
use epiphany_state_model::RepoFrontierStatus::*;
|
|
match status {
|
|
Proposed => "proposed",
|
|
Active => "active",
|
|
Blocked => "blocked",
|
|
Resolved => "resolved",
|
|
Retired => "retired",
|
|
Superseded => "superseded",
|
|
}
|
|
}
|
|
|
|
fn compact_line(value: &str) -> String {
|
|
let mut compacted = value.split_whitespace().collect::<Vec<_>>().join(" ");
|
|
if compacted.len() > 260 {
|
|
compacted.truncate(257);
|
|
compacted.push_str("...");
|
|
}
|
|
compacted
|
|
}
|
|
|
|
fn push_omitted_count(lines: &mut Vec<String>, total: usize, shown: usize, label: &str) {
|
|
if total > shown {
|
|
lines.push(format!("- ... {} more {} not shown", total - shown, label));
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::EPIPHANY_CULTMESH_INTERNAL_VERSE_ID;
|
|
use crate::EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_SCHEMA_VERSION;
|
|
use crate::EpiphanyAgentStateSoaEntry;
|
|
use crate::EpiphanyCultMeshWorkLoopTelemetryEntry;
|
|
use crate::epiphany_cultmesh_agent_state_soa_summary_from_entry;
|
|
use crate::epiphany_cultmesh_bifrost_body_change_publication_intent;
|
|
use crate::epiphany_cultmesh_bifrost_body_change_publication_receipt_for_intent;
|
|
use crate::epiphany_cultmesh_bifrost_github_publication_receipt_for_publication;
|
|
use crate::query_epiphany_local_verse_context;
|
|
use crate::seed_epiphany_local_verse_context;
|
|
use crate::write_epiphany_cultmesh_agent_state_soa_summary;
|
|
use crate::write_epiphany_cultmesh_bifrost_body_change_publication_intent;
|
|
use crate::write_epiphany_cultmesh_bifrost_body_change_publication_receipt;
|
|
use crate::write_epiphany_cultmesh_bifrost_github_publication_receipt;
|
|
use crate::write_epiphany_cultmesh_work_loop_telemetry;
|
|
use epiphany_state_model::EpiphanyMemoryContextPacket;
|
|
use epiphany_state_model::EpiphanyMemoryFreshnessStatus;
|
|
use epiphany_state_model::EpiphanyMemorySummary;
|
|
|
|
#[test]
|
|
fn prompt_context_renders_verse_and_memory_without_state_authority() -> anyhow::Result<()> {
|
|
let temp = tempfile::tempdir()?;
|
|
let store = temp.path().join("epiphany-local-verse.ccmp");
|
|
seed_epiphany_local_verse_context(&store, "epiphany-test", "2026-06-02T00:00:00Z")?;
|
|
let _seeded_verse = query_epiphany_local_verse_context(&store, "epiphany-test")?;
|
|
let bifrost_intent = epiphany_cultmesh_bifrost_body_change_publication_intent(
|
|
"bifrost-publication-intent-prompt-test",
|
|
"epiphany.cluster.hands",
|
|
"epiphany.Hands",
|
|
"repo:E:/Projects/EpiphanyAgent",
|
|
"E:/Projects/EpiphanyAgent",
|
|
"codex/perfect-machine-cultmesh",
|
|
"Route body change through Bifrost before GitHub publication.",
|
|
"Bifrost must ledger review, verification, credit, and GitHub routing.",
|
|
vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
|
|
vec!["soul-verdict-prompt-test".to_string()],
|
|
vec!["maintainer-review-prompt-test".to_string()],
|
|
vec!["epiphany.Hands".to_string()],
|
|
vec!["GameCult/EpiphanyAgent".to_string()],
|
|
);
|
|
write_epiphany_cultmesh_bifrost_body_change_publication_intent(
|
|
&store,
|
|
"epiphany-test",
|
|
bifrost_intent.clone(),
|
|
)?;
|
|
let bifrost_receipt = epiphany_cultmesh_bifrost_body_change_publication_receipt_for_intent(
|
|
"bifrost-publication-receipt-prompt-test",
|
|
&bifrost_intent,
|
|
"accepted-for-github-publication",
|
|
"bifrost-ledger-prompt-test",
|
|
"github-publication-prompt-test",
|
|
vec!["credit-receipt-prompt-test".to_string()],
|
|
vec!["maintainer-review-prompt-test".to_string()],
|
|
"https://github.com/GameCult/EpiphanyAgent/pull/prompt-test",
|
|
);
|
|
write_epiphany_cultmesh_bifrost_body_change_publication_receipt(
|
|
&store,
|
|
"epiphany-test",
|
|
bifrost_receipt.clone(),
|
|
)?;
|
|
let github_receipt = epiphany_cultmesh_bifrost_github_publication_receipt_for_publication(
|
|
"github-publication-receipt-prompt-test",
|
|
&bifrost_receipt,
|
|
"hands-pr-prompt-test",
|
|
"E:/Projects/EpiphanyAgent",
|
|
"codex/perfect-machine-cultmesh",
|
|
"prompt-test",
|
|
"dry-run-no-commit",
|
|
"epiphany.Hands",
|
|
);
|
|
write_epiphany_cultmesh_bifrost_github_publication_receipt(
|
|
&store,
|
|
"epiphany-test",
|
|
github_receipt,
|
|
)?;
|
|
write_epiphany_cultmesh_work_loop_telemetry(
|
|
&store,
|
|
EpiphanyCultMeshWorkLoopTelemetryEntry {
|
|
schema_version: EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_SCHEMA_VERSION.to_string(),
|
|
runtime_id: "epiphany-test".to_string(),
|
|
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
|
|
telemetry_id: "work-loop-prompt-test".to_string(),
|
|
thread_id: "thread-prompt-test".to_string(),
|
|
produced_at_utc: "2026-06-18T00:00:00Z".to_string(),
|
|
source_stage: "Hands".to_string(),
|
|
target_stages: vec!["Soul".to_string(), "Modeling".to_string()],
|
|
lower_bound_receipt_at: "2026-06-18T00:00:00Z".to_string(),
|
|
hands_intent_id: "hands-intent-prompt-test".to_string(),
|
|
hands_review_id: "hands-review-prompt-test".to_string(),
|
|
hands_runtime_job_id: "hands-job-prompt-test".to_string(),
|
|
substrate_gate_grant_receipt_id: "substrate-grant-prompt-test".to_string(),
|
|
hands_patch_receipt_id: "hands-patch-prompt-test".to_string(),
|
|
hands_command_receipt_id: "hands-command-prompt-test".to_string(),
|
|
hands_commit_receipt_id: "hands-commit-prompt-test".to_string(),
|
|
command: "cargo test".to_string(),
|
|
exit_code: "0".to_string(),
|
|
stdout_artifact: "stdout.log".to_string(),
|
|
stderr_artifact: "stderr.log".to_string(),
|
|
commit_sha: "abc123".to_string(),
|
|
branch: "codex/perfect-machine-cultmesh".to_string(),
|
|
changed_paths: vec!["epiphany-core/src/prompt_context.rs".to_string()],
|
|
artifact_previews: vec!["sealed stdout preview should stay internal".to_string()],
|
|
source_refs: vec!["epiphany-core/src/prompt_context.rs".to_string()],
|
|
source_path_proof: vec!["source proof should stay internal".to_string()],
|
|
soul_receipt_ids: vec!["soul-acceptance-prompt-test".to_string()],
|
|
summary: "Hands consequence digest for prompt assembly.".to_string(),
|
|
receipt_payload_previews: vec![
|
|
"sealed patch payload should stay internal".to_string(),
|
|
],
|
|
commit_diff_preview: "diff --git sealed".to_string(),
|
|
verification_assertions: vec!["prompt renders digest only".to_string()],
|
|
},
|
|
)?;
|
|
let agent_state_soa = EpiphanyAgentStateSoaEntry {
|
|
schema_version: "epiphany.agent_state_soa.v0".to_string(),
|
|
generated_at: "2026-06-18T00:00:00Z".to_string(),
|
|
source_store: "state/agents.msgpack".to_string(),
|
|
role_ids: vec!["Persona".to_string(), "implementation".to_string()],
|
|
agent_ids: vec!["epiphany.Persona".to_string(), "epiphany.hands".to_string()],
|
|
display_names: vec!["Persona".to_string(), "Hands".to_string()],
|
|
profile_kinds: vec!["Persona".to_string(), "WorkOrgan".to_string()],
|
|
portable_contracts: vec![
|
|
"gamecult.persona_state.v0".to_string(),
|
|
"epiphany.work_organ_state.v0".to_string(),
|
|
],
|
|
semantic_memory_counts: vec![3, 2],
|
|
episodic_memory_counts: vec![1, 0],
|
|
relationship_memory_counts: vec![2, 0],
|
|
goal_counts: vec![1, 1],
|
|
value_counts: vec![4, 3],
|
|
};
|
|
let agent_state_summary = epiphany_cultmesh_agent_state_soa_summary_from_entry(
|
|
"epiphany-test",
|
|
"agent-state-soa-summary-prompt-test",
|
|
&agent_state_soa,
|
|
);
|
|
write_epiphany_cultmesh_agent_state_soa_summary(&store, agent_state_summary)?;
|
|
let local_verse = query_epiphany_local_verse_context(&store, "epiphany-test")?;
|
|
let memory_context = EpiphanyMemoryContextPacket {
|
|
id: "memctx-test".to_string(),
|
|
query_id: "query-test".to_string(),
|
|
frontier: vec![epiphany_state_model::RepoFrontierItem {
|
|
id: "frontier-prompt-test".to_string(),
|
|
migration_body: "Migrate repository authority into typed Modeling state."
|
|
.to_string(),
|
|
question: "Can downstream organs see the frontier?".to_string(),
|
|
gap: "Prompt context previously carried claims without migration anatomy."
|
|
.to_string(),
|
|
recommended_next_organ: "Soul".to_string(),
|
|
dependency_item_ids: vec!["frontier-foundation".to_string()],
|
|
status: epiphany_state_model::RepoFrontierStatus::Blocked,
|
|
..Default::default()
|
|
}],
|
|
summaries: vec![EpiphanyMemorySummary {
|
|
id: "summary-test".to_string(),
|
|
claim: "Shared graph law lets prompt assembly ask for relevant memory instead of hauling the archive.".to_string(),
|
|
action_implication:
|
|
"Inject the compact packet, then let Mind review any durable effect."
|
|
.to_string(),
|
|
freshness: EpiphanyMemoryFreshnessStatus::Ready,
|
|
confidence: 90,
|
|
..Default::default()
|
|
}],
|
|
..Default::default()
|
|
};
|
|
|
|
let mut prompt_input = EpiphanyPromptContextInput {
|
|
focus: "Assemble context for a bounded worker prompt.".to_string(),
|
|
local_verse,
|
|
memory_context,
|
|
};
|
|
let rendered = render_epiphany_prompt_context(&prompt_input);
|
|
|
|
assert!(rendered.contains("<epiphany_dynamic_context>"));
|
|
assert!(rendered.contains("frontier-prompt-test"));
|
|
assert!(rendered.contains("Migrate repository authority into typed Modeling state."));
|
|
assert!(rendered.contains("Can downstream organs see the frontier?"));
|
|
assert!(rendered.contains("Prompt context previously carried claims"));
|
|
assert!(rendered.contains("next `Soul`"));
|
|
assert!(rendered.contains("frontier-foundation"));
|
|
assert!(rendered.contains("blocked"));
|
|
assert!(rendered.contains("Odin"));
|
|
assert!(rendered.contains("Yggdrasil"));
|
|
assert!(rendered.contains("Bifrost"));
|
|
assert!(rendered.contains("Cluster Topology"));
|
|
assert!(rendered.contains("eve://epiphany/persona"));
|
|
assert!(rendered.contains("private_state_exposed=false"));
|
|
assert!(!rendered.contains("inspectCompactSurface"));
|
|
assert!(!rendered.contains("watchTypedReceipts"));
|
|
assert!(rendered.contains("Agent State SoA"));
|
|
assert!(rendered.contains("agent-state-soa-summary-prompt-test"));
|
|
assert!(rendered.contains("gamecult.persona_state.v0"));
|
|
assert!(rendered.contains("epiphany.work_organ_state.v0"));
|
|
assert!(rendered.contains("Bifrost Publication Gate"));
|
|
assert!(rendered.contains("bifrost-publication-intent-prompt-test"));
|
|
assert!(rendered.contains("github_receipt=github-publication-prompt-test"));
|
|
assert!(rendered.contains("github-publication-receipt-prompt-test"));
|
|
assert!(rendered.contains("hands_pr=hands-pr-prompt-test"));
|
|
assert!(rendered.contains("Work Loop Receipt Digest"));
|
|
assert!(rendered.contains("work-loop-prompt-test"));
|
|
assert!(rendered.contains("hands-patch-prompt-test"));
|
|
assert!(rendered.contains("hands-command-prompt-test"));
|
|
assert!(rendered.contains("hands-commit-prompt-test"));
|
|
assert!(rendered.contains("exposes only this digest"));
|
|
assert!(!rendered.contains("sealed patch payload should stay internal"));
|
|
assert!(!rendered.contains("diff --git sealed"));
|
|
assert!(!rendered.contains("sealed stdout preview should stay internal"));
|
|
assert!(rendered.contains("gamecult-local"));
|
|
assert!(rendered.contains("Shared graph law"));
|
|
assert!(rendered.contains("Mind reviews durable state effects"));
|
|
assert!(!rendered.contains("raw worker transcript"));
|
|
|
|
prompt_input
|
|
.local_verse
|
|
.arrival_latest_bifrost_body_change_publication_receipt
|
|
.as_mut()
|
|
.expect("Bifrost receipt remains available for mismatch probe")
|
|
.intent_id = "another-bifrost-intent".to_string();
|
|
let mismatched = render_epiphany_prompt_context(&prompt_input);
|
|
assert!(mismatched.contains("bifrost-publication-intent-prompt-test"));
|
|
assert!(!mismatched.contains("bifrost-publication-receipt-prompt-test"));
|
|
assert!(!mismatched.contains("github-publication-receipt-prompt-test"));
|
|
Ok(())
|
|
}
|
|
}
|