Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
fix(capture): retain safe tool context
AkitaOnRails885f6795d602
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex a9f5ce68..7a763c42 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0## [Unreleased]### Added+- Tool lifecycle capture now records safe metadata summaries for the closed+ Claude Code, OpenCode, Pi, and Antigravity schemas: canonical family,+ validated agent-provided call ID where available, and a PostToolUse outcome.+ PreToolUse never stores tool inputs, commands, paths, or arbitrary tool+ names; PostToolUse keeps its bounded response/error excerpt. Stop and+ assistant-message capture remain disabled/deferred ([#190]).- Per-repository capture exclusions via `[capture] ignore_paths` in the nearest`.ai-memory.toml` ([#194]). Supported native hooks and generatedOpenCode/OMP/Pi/OpenClaw integrations apply the policy before local spool ordiff --git a/crates/ai-memory-consolidate/src/auto_improve.rs b/crates/ai-memory-consolidate/src/auto_improve.rsindex e0627288..b7e69ef6 100644--- a/crates/ai-memory-consolidate/src/auto_improve.rs+++ b/crates/ai-memory-consolidate/src/auto_improve.rs@@ -2466,6 +2466,45 @@ mod tests {);}+ #[test]+ fn prompt_keeps_paired_safe_tool_observations_below_sampling_threshold() {+ let call_id = "stable-call-190";+ let observations = vec![+ obs(+ 0,+ ObservationKind::PreToolUse,+ "tool non-file",+ &format!("tool_family: non-file\ntool_call_id: {call_id}"),+ 5,+ ),+ obs(+ 1,+ ObservationKind::PostToolUse,+ "tool non-file",+ &format!(+ "tool_family: non-file\ntool_call_id: {call_id}\noutcome: unknown\n---\nPOST_OUTPUT_SURVIVES"+ ),+ 5,+ ),+ ];+ assert!(observations.len() < 48);+ let prompt = build_prompt_input(+ SessionId::new(),+ &observations,+ 3_600,+ None,+ &[],+ &[],+ &[],+ &cfg(),+ );+ assert_eq!(prompt.prompt.matches(call_id).count(), 2);+ assert!(prompt.prompt.contains("POST_OUTPUT_SURVIVES"));+ for sentinel in ["SENTINEL_COMMAND", "SENTINEL_PATH"] {+ assert!(!prompt.prompt.contains(sentinel));+ }+ }+#[test]fn prompt_bounds_patchable_context_and_charges_observation_budget() {let session_id = SessionId::new();diff --git a/crates/ai-memory-consolidate/src/projection.rs b/crates/ai-memory-consolidate/src/projection.rsindex 9844a4c2..a3cfcda9 100644--- a/crates/ai-memory-consolidate/src/projection.rs+++ b/crates/ai-memory-consolidate/src/projection.rs@@ -547,7 +547,7 @@ mod tests {78,ObservationKind::PostToolUse,"final correction",- "final state supersedes earlier draft",+ "tool_family: file\noutcome: unknown\n---\nfinal state supersedes earlier draft",3,);observations[79] = obs(79, ObservationKind::SessionEnd, "session end", "done", 5);diff --git a/crates/ai-memory-hooks/src/capture_policy.rs b/crates/ai-memory-hooks/src/capture_policy.rsindex 570ad997..7b0aef8d 100644--- a/crates/ai-memory-hooks/src/capture_policy.rs+++ b/crates/ai-memory-hooks/src/capture_policy.rs@@ -92,6 +92,94 @@ pub enum ToolFamily {Unknown,}+/// Safe, closed-schema tool metadata suitable for an observation body.+#[derive(Clone, Debug, PartialEq, Eq)]+pub(crate) struct ToolObservationMetadata {+ pub(crate) tool_family: ToolFamily,+ pub(crate) tool_call_id: Option<String>,+}++/// Safe outcome class for a completed tool call.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum ToolOutcome {+ Success,+ Error,+ Unknown,+}++impl ToolOutcome {+ pub(crate) const fn as_str(self) -> &'static str {+ match self {+ Self::Success => "success",+ Self::Error => "error",+ Self::Unknown => "unknown",+ }+ }+}++/// Extracts only the closed, fixture-backed metadata schemas used for tool+/// observations. It intentionally does not reuse broad envelope fallbacks.+pub(crate) fn tool_observation_metadata(+ agent: AgentKind,+ raw: &Value,+ require_input: bool,+) -> Option<ToolObservationMetadata> {+ let object = raw.as_object()?;+ let (name, id) = match agent {+ AgentKind::ClaudeCode => (+ object.get("tool_name")?.as_str()?,+ object.get("tool_use_id").and_then(Value::as_str),+ ),+ AgentKind::OpenCode => (+ object.get("tool")?.as_str()?,+ object.get("callID").and_then(Value::as_str),+ ),+ AgentKind::Pi => (+ object.get("tool")?.as_str()?,+ object.get("callID").and_then(Value::as_str),+ ),+ AgentKind::AntigravityCli => (object.get("toolCall")?.get("name")?.as_str()?, None),+ _ => return None,+ };+ // PreToolUse needs a proven input shape. PostToolUse deliberately does+ // not: established adapters commonly omit inputs from their response.+ let has_args = !require_input+ || match agent {+ AgentKind::AntigravityCli => object.get("toolCall")?.get("args").is_some(),+ _ => object+ .get(if agent == AgentKind::ClaudeCode {+ "tool_input"+ } else {+ "args"+ })+ .is_some(),+ };+ has_args.then(|| ToolObservationMetadata {+ tool_family: family(name),+ tool_call_id: id.filter(|id| valid_call_id(id)).map(str::to_owned),+ })+}++/// Extracts an outcome only where the adapter protocol proves its meaning.+pub(crate) fn tool_observation_outcome(agent: AgentKind, raw: &Value) -> ToolOutcome {+ match agent {+ AgentKind::Pi => match raw.get("isError").and_then(Value::as_bool) {+ Some(true) => ToolOutcome::Error,+ Some(false) => ToolOutcome::Success,+ None => ToolOutcome::Unknown,+ },+ AgentKind::AntigravityCli+ if raw+ .get("error")+ .and_then(Value::as_str)+ .is_some_and(|error| !error.is_empty()) =>+ {+ ToolOutcome::Error+ }+ _ => ToolOutcome::Unknown,+ }+}+/// Strict, bounded reserved protocol body.#[derive(Clone, Debug, Serialize, PartialEq, Eq)]pub struct CaptureProtocol {@@ -486,7 +574,7 @@ fn canonical(family: ToolFamily) -> CanonicalTool {ToolFamily::Unknown => CanonicalTool::Unknown,}}-fn valid_call_id(id: &str) -> bool {+pub(crate) fn valid_call_id(id: &str) -> bool {!id.is_empty()&& id.chars().count() <= MAX_CALL_ID_CHARS&& iddiff --git a/crates/ai-memory-hooks/src/payload.rs b/crates/ai-memory-hooks/src/payload.rsindex 79198d27..20f296a2 100644--- a/crates/ai-memory-hooks/src/payload.rs+++ b/crates/ai-memory-hooks/src/payload.rs@@ -3,6 +3,10 @@use ai_memory_core::{AgentKind, ObservationKind};use serde::{Deserialize, Serialize};+use crate::capture_policy::{+ ToolObservationMetadata, tool_observation_metadata, tool_observation_outcome,+};+/// Query-string parameters on `POST /hook`.#[derive(Debug, Clone, Default, Deserialize)]pub struct HookQuery {@@ -328,16 +332,39 @@ impl HookEnvelope {} else {None};- let title_hint = best_title_hint(event, &raw).or_else(|| {- source_event- .as_deref()- .map(|source| extension_title_hint(&raw, source))- });- let body_excerpt = best_body_excerpt(event, &raw).or_else(|| {- source_event- .as_deref()- .and_then(|_| extension_body_excerpt(&raw))- });+ let tool_metadata = tool_observation_metadata(agent, &raw, event == HookEvent::PreToolUse);+ let closed_tool_event = matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse)+ && closed_tool_agent(agent);+ let title_hint = if closed_tool_event {+ tool_metadata.as_ref().map(safe_tool_title).or_else(|| {+ (event == HookEvent::PostToolUse && agent == AgentKind::OpenCode)+ .then(|| legacy_tool_title(event, agent, &raw))+ .flatten()+ })+ } else if matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse) {+ legacy_tool_title(event, agent, &raw)+ } else {+ best_title_hint(event, &raw).or_else(|| {+ source_event+ .as_deref()+ .map(|source| extension_title_hint(&raw, source))+ })+ };+ let body_excerpt = if closed_tool_event {+ safe_tool_body(event, tool_metadata.as_ref(), agent, &raw).or_else(|| {+ (event == HookEvent::PostToolUse && agent == AgentKind::OpenCode)+ .then(|| legacy_tool_body(event, agent, &raw))+ .flatten()+ })+ } else if matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse) {+ legacy_tool_body(event, agent, &raw)+ } else {+ best_body_excerpt(event, &raw).or_else(|| {+ source_event+ .as_deref()+ .and_then(|_| extension_body_excerpt(&raw))+ })+ };Self {event,agent,@@ -357,6 +384,89 @@ impl HookEnvelope {}}+fn legacy_tool_title(+ event: HookEvent,+ agent: AgentKind,+ raw: &serde_json::Value,+) -> Option<String> {+ let payload = (event == HookEvent::PostToolUse && agent == AgentKind::OpenCode)+ .then(|| raw.get("payload"))+ .flatten()?;+ extract_string(payload, &["tool"]).filter(|_| {+ extract_content(+ payload,+ &["tool_response", "tool_output", "output", "result", "error"],+ )+ .is_some()+ })+}++fn legacy_tool_body(event: HookEvent, agent: AgentKind, raw: &serde_json::Value) -> Option<String> {+ let payload = (event == HookEvent::PostToolUse && agent == AgentKind::OpenCode)+ .then(|| raw.get("payload"))+ .flatten()?;+ let tool = extract_string(payload, &["tool"])?;+ let result = extract_content(+ payload,+ &["tool_response", "tool_output", "output", "result"],+ )+ .or_else(|| extract_content(payload, &["error"]))?;+ Some(truncate_excerpt(&format!("tool: {tool}\n---\n{result}")))+}++const fn closed_tool_agent(agent: AgentKind) -> bool {+ matches!(+ agent,+ AgentKind::ClaudeCode | AgentKind::OpenCode | AgentKind::Pi | AgentKind::AntigravityCli+ )+}++fn safe_tool_title(metadata: &ToolObservationMetadata) -> String {+ format!(+ "tool {}",+ serde_json::to_string(&metadata.tool_family)+ .unwrap_or_default()+ .trim_matches('"')+ )+}++fn safe_tool_body(+ event: HookEvent,+ metadata: Option<&ToolObservationMetadata>,+ agent: AgentKind,+ raw: &serde_json::Value,+) -> Option<String> {+ let metadata = metadata?;+ let mut summary = format!(+ "tool_family: {}",+ serde_json::to_string(&metadata.tool_family)+ .ok()?+ .trim_matches('"')+ );+ if let Some(id) = &metadata.tool_call_id {+ summary.push_str("\ntool_call_id: ");+ summary.push_str(id);+ }+ match event {+ HookEvent::PreToolUse => Some(summary),+ HookEvent::PostToolUse => {+ summary.push_str("\noutcome: ");+ summary.push_str(tool_observation_outcome(agent, raw).as_str());+ if metadata.tool_family == crate::capture_policy::ToolFamily::Unknown {+ return Some(summary);+ }+ let result =+ extract_content(raw, &["tool_response", "tool_output", "output", "result"])+ .or_else(|| extract_content(raw, &["error"]))+ .unwrap_or_else(|| "(no output captured)".into());+ summary.push_str("\n---\n");+ summary.push_str(&result);+ Some(truncate_excerpt(&summary))+ }+ _ => None,+ }+}+fn extract_string(value: &serde_json::Value, keys: &[&str]) -> Option<String> {for key in keys {for candidate in extraction_candidates(value) {@@ -585,11 +695,13 @@ fn truncate_excerpt(s: &str) -> String {if s.len() <= MAX {s.to_string()} else {- let mut buf = String::with_capacity(MAX + '…'.len_utf8());+ // Reserve the ellipsis within the byte cap, not beyond it.+ let limit = MAX - '…'.len_utf8();+ let mut buf = String::with_capacity(MAX);let mut end = 0;for (idx, ch) in s.char_indices() {let next = idx + ch.len_utf8();- if next > MAX {+ if next > limit {break;}end = next;@@ -790,7 +902,7 @@ mod tests {"cwd": "/tmp/x","model": "claude-sonnet-4-6"});- let env = HookEnvelope::from_query_and_body(q, raw);+ let env = HookEnvelope::from_query_and_body(q.clone(), raw);assert_eq!(env.event, HookEvent::SessionStart);assert_eq!(env.session_id.as_deref(), Some("abc-123"));assert_eq!(env.cwd.as_deref(), Some("/tmp/x"));@@ -813,7 +925,7 @@ mod tests {"tool_response": {"success": true, "output": "ok", "error": null}});- let env = HookEnvelope::from_query_and_body(q, raw);+ let env = HookEnvelope::from_query_and_body(q.clone(), raw);assert_eq!(env.event, HookEvent::PostToolUse);assert_eq!(env.agent, AgentKind::Devin);@@ -939,7 +1051,7 @@ mod tests {Some("ec33ebf9-0cba-4100-8142-c61503f6c587"));assert_eq!(env.cwd.as_deref(), Some("/workspace/project"));- assert_eq!(env.title_hint.as_deref(), Some("run_command"));+ assert_eq!(env.title_hint.as_deref(), Some("tool non-file"));}#[test]@@ -956,13 +1068,8 @@ mod tests {"error": "exit status 1"});let env = HookEnvelope::from_query_and_body(q, raw);-- assert_eq!(env.title_hint.as_deref(), Some("step 5"));- assert!(- env.body_excerpt- .as_deref()- .is_some_and(|body| body.contains("exit status 1"))- );+ assert!(env.title_hint.is_none());+ assert!(env.body_excerpt.is_none());}/// OpenCode's plugin SDK sends `sessionID` (capital `ID`) on the@@ -1006,17 +1113,19 @@ mod tests {"output": "tests passed"}});- let env = HookEnvelope::from_query_and_body(q, raw);+ let env = HookEnvelope::from_query_and_body(q.clone(), raw);assert_eq!(env.session_id.as_deref(), Some("ses_nested"));assert_eq!(env.cwd.as_deref(), Some("/home/user/ai-memory"));assert_eq!(env.title_hint.as_deref(), Some("bash"));- assert!(- env.body_excerpt- .as_deref()- .is_some_and(|body| body.contains("tests passed")),- "post-tool body should include nested output: {:?}",- env.body_excerpt+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool: bash\n---\ntests passed")+ );+ let long = HookEnvelope::from_query_and_body(+ q,+ serde_json::json!({"payload":{"tool":"bash","output":"é".repeat(2_000)}}),);+ assert!(long.body_excerpt.unwrap().len() <= 2_000);}/// OpenCode's plugin `event` hook receives bus events shaped like@@ -1190,13 +1299,14 @@ mod tests {let env = HookEnvelope::from_query_and_body(q,serde_json::json!({- "tool": "bash",+ "tool_name": "Bash",+ "tool_input": {},"result": output,}),);let excerpt = env.body_excerpt.unwrap();assert!(excerpt.ends_with('…'));- assert!(excerpt.starts_with("tool: bash\n---\n"));+ assert!(excerpt.starts_with("tool_family: non-file\noutcome: unknown\n---\n"));}/// Regression: the native-binary hook command sends the script stem@@ -1230,6 +1340,7 @@ mod tests {q,serde_json::json!({"tool_name": "Bash",+ "tool_input": {},"tool_response": [{"type": "text", "text": "MARKER_OUTPUT_123"}],}),);@@ -1257,6 +1368,7 @@ mod tests {q,serde_json::json!({"tool_name": "Read",+ "tool_input": {},"tool_response": {"stdout": "MARKER_OBJ_456"},}),);@@ -1283,4 +1395,250 @@ mod tests {assert_eq!(env.event, HookEvent::UserPrompt);assert_eq!(env.body_excerpt.as_deref(), Some("MARKER_PROMPT_789"));}++ #[test]+ fn closed_tool_summaries_keep_only_safe_metadata_and_cap_total_body() {+ let fixtures = [+ (+ "claude-code",+ serde_json::json!({"tool_name":"Bash","tool_input":{"command":"SENTINEL_COMMAND","path":"SENTINEL_PATH"},"tool_use_id":"claude-1","output":"SENTINEL_OUTPUT"}),+ "claude-1",+ "unknown",+ ),+ (+ "open-code",+ serde_json::json!({"tool":"bash","args":{"command":"SENTINEL_COMMAND"},"callID":"open-1","output":"SENTINEL_OUTPUT"}),+ "open-1",+ "unknown",+ ),+ (+ "pi",+ serde_json::json!({"tool":"bash","args":{"command":"SENTINEL_COMMAND"},"callID":"pi-1","isError":true,"output":"SENTINEL_OUTPUT"}),+ "pi-1",+ "error",+ ),+ ];+ for (agent, raw, id, outcome) in fixtures {+ let pre = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "pre-tool-use".into(),+ agent: Some(agent.into()),+ ..Default::default()+ },+ raw.clone(),+ );+ let pre_body = pre.body_excerpt.expect("pre summary");+ assert!(pre_body.contains(id));+ for sentinel in ["SENTINEL_COMMAND", "SENTINEL_PATH", "SENTINEL_OUTPUT"] {+ assert!(!pre_body.contains(sentinel));+ }+ let post = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some(agent.into()),+ ..Default::default()+ },+ raw,+ );+ let post_body = post.body_excerpt.expect("post summary");+ assert!(post_body.contains(&format!("outcome: {outcome}")));+ }++ let long = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("claude-code".into()),+ ..Default::default()+ },+ serde_json::json!({"tool_name":"Bash","tool_input":{},"tool_use_id":"utf8-1","output": "é".repeat(2_000)}),+ );+ assert!(long.body_excerpt.unwrap().len() <= 2_000);+ }++ #[test]+ fn unknown_closed_tool_post_never_includes_output_or_name() {+ let env = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("claude-code".into()),+ ..Default::default()+ },+ serde_json::json!({"tool_name":"ARBITRARY_TOOL_SENTINEL","tool_use_id":"unknown-1","output":"OUTPUT_SENTINEL"}),+ );+ let body = env.body_excerpt.unwrap();+ assert!(body.contains("tool_family: unknown"));+ assert!(body.contains("tool_call_id: unknown-1"));+ assert!(body.contains("outcome: unknown"));+ assert!(!body.contains("ARBITRARY_TOOL_SENTINEL"));+ assert!(!body.contains("OUTPUT_SENTINEL"));+ }++ #[test]+ fn claude_and_opencode_paired_summaries_share_agent_ids() {+ for (agent, pre_raw, post_raw, id) in [+ (+ "claude-code",+ serde_json::json!({"tool_name":"Bash","tool_input":{"command":"PRE_COMMAND_SENTINEL"},"tool_use_id":"claude-pair"}),+ serde_json::json!({"tool_name":"Bash","tool_use_id":"claude-pair","output":"POST_OUTPUT"}),+ "claude-pair",+ ),+ (+ "open-code",+ serde_json::json!({"tool":"bash","args":{"path":"PRE_PATH_SENTINEL"},"callID":"open-pair"}),+ serde_json::json!({"tool":"bash","callID":"open-pair","output":"POST_OUTPUT"}),+ "open-pair",+ ),+ ] {+ let pre = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "pre-tool-use".into(),+ agent: Some(agent.into()),+ ..Default::default()+ },+ pre_raw,+ );+ let post = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some(agent.into()),+ ..Default::default()+ },+ post_raw,+ );+ let pre_body = pre.body_excerpt.unwrap();+ let post_body = post.body_excerpt.unwrap();+ assert!(pre_body.contains(id) && post_body.contains(id));+ assert!(post_body.contains("POST_OUTPUT"));+ assert!(!pre_body.contains("SENTINEL"));+ }+ }++ #[test]+ fn antigravity_omits_id_and_unsupported_pre_has_no_body() {+ let antigravity = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("antigravity-cli".into()),+ ..Default::default()+ },+ serde_json::json!({"toolCall":{"name":"run_command","args":{}},"error":"private"}),+ );+ let body = antigravity.body_excerpt.unwrap();+ assert!(body.contains("outcome: error"));+ assert!(!body.contains("tool_call_id"));+ let unsupported = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "pre-tool-use".into(),+ agent: Some("codex".into()),+ ..Default::default()+ },+ serde_json::json!({"tool_name":"Bash","tool_input":{"command":"private"}}),+ );+ assert!(unsupported.body_excerpt.is_none());+ }++ #[test]+ fn unsupported_and_stop_tool_payloads_never_render_content() {+ for event in ["pre-tool-use", "post-tool-use"] {+ let env = HookEnvelope::from_query_and_body(+ HookQuery {+ event: event.into(),+ agent: Some("other".into()),+ ..Default::default()+ },+ serde_json::json!({"tool":"SENTINEL_TOOL","args":{"command":"SENTINEL_COMMAND","path":"SENTINEL_PATH"},"output":"SENTINEL_OUTPUT"}),+ );+ assert!(env.title_hint.is_none());+ assert!(env.body_excerpt.is_none());+ }+ let stop = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "stop".into(),+ agent: Some("claude-code".into()),+ ..Default::default()+ },+ serde_json::json!({"last_assistant_message":"SENTINEL_ASSISTANT"}),+ );+ assert!(stop.body_excerpt.is_none());+ }++ #[test]+ fn antigravity_outcome_and_call_id_boundaries_are_closed() {+ let absent = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("antigravity-cli".into()),+ ..Default::default()+ },+ serde_json::json!({"toolCall":{"name":"run_command","args":{}}}),+ );+ assert!(absent.body_excerpt.unwrap().contains("outcome: unknown"));+ for (error, outcome) in [+ (serde_json::json!(null), "unknown"),+ (serde_json::json!(""), "unknown"),+ (serde_json::json!("failed"), "error"),+ ] {+ let env = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("antigravity-cli".into()),+ ..Default::default()+ },+ serde_json::json!({"toolCall":{"name":"run_command","args":{}},"error":error}),+ );+ assert!(+ env.body_excerpt+ .unwrap()+ .contains(&format!("outcome: {outcome}"))+ );+ }+ let id = "a".repeat(129);+ let env = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "pre-tool-use".into(),+ agent: Some("claude-code".into()),+ ..Default::default()+ },+ serde_json::json!({"tool_name":"Bash","tool_input":{},"tool_use_id":id}),+ );+ assert!(!env.body_excerpt.unwrap().contains("tool_call_id"));+ }++ #[test]+ fn pi_post_outcomes_and_stable_id_are_rendered() {+ for (is_error, outcome) in [+ (Some(false), "success"),+ (Some(true), "error"),+ (None, "unknown"),+ ] {+ let mut raw = serde_json::json!({"tool":"bash","args":{},"callID":"pi-stable-190","output":"result"});+ if let Some(is_error) = is_error {+ raw["isError"] = serde_json::json!(is_error);+ }+ let pre = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "pre-tool-use".into(),+ agent: Some("pi".into()),+ ..Default::default()+ },+ raw.clone(),+ );+ let post = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some("pi".into()),+ ..Default::default()+ },+ raw,+ );+ assert!(+ pre.body_excerpt+ .unwrap()+ .contains("tool_call_id: pi-stable-190")+ );+ let body = post.body_excerpt.unwrap();+ assert!(body.contains("tool_call_id: pi-stable-190"));+ assert!(body.contains(&format!("outcome: {outcome}")));+ }+ }}diff --git a/crates/ai-memory-hooks/src/router.rs b/crates/ai-memory-hooks/src/router.rsindex 0533caf0..91870f8c 100644--- a/crates/ai-memory-hooks/src/router.rs+++ b/crates/ai-memory-hooks/src/router.rs@@ -33,7 +33,7 @@ use uuid::Uuid;use crate::capture_policy::{CaptureConfig, CaptureDisposition, CapturePolicy, CaptureProtocol, CaptureSource, PolicyState,- ToolFamily, metadata_only_body,+ ToolFamily, metadata_only_body, tool_observation_outcome, valid_call_id,};use crate::log;use crate::payload::{@@ -759,7 +759,12 @@ fn metadata_only_protocol_envelope();raw.insert("_ai_memory_capture".into(), serde_json::json!(protocol));env.title_hint = Some(canonical_tool_name(protocol.tool_family()).into());- env.body_excerpt = None;+ env.body_excerpt = metadata_summary_with_outcome(+ env.event,+ protocol.tool_family(),+ object.get("tool_call_id"),+ "unknown",+ );env.raw = serde_json::Value::Object(raw);Some(env)}@@ -772,13 +777,7 @@ const fn metadata_protocol_is_legal(protocol: &CaptureProtocol) -> bool {}fn valid_metadata_call_id(value: &serde_json::Value) -> bool {- value.as_str().is_some_and(|id| {- !id.is_empty()- && id.len() <= 256- && id- .bytes()- .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.'))- })+ value.as_str().is_some_and(valid_call_id)}/// Whether a claimed protocol can be produced by the claimed policy state for@@ -833,6 +832,7 @@ fn metadata_envelope(protocol: Option<&CaptureProtocol>,) -> HookEnvelope {let protocol = protocol.unwrap_or(decision.protocol());+ let outcome = tool_observation_outcome(env.agent, &env.raw);let mut raw = metadata_only_body(env.session_id.as_deref(), env.cwd.as_deref(), decision);if let Some(object) = raw.as_object_mut() {object.insert(@@ -848,11 +848,37 @@ fn metadata_envelope(// These were extracted from the pre-replacement raw body. Clearing them is// essential: normal extraction must never retain a removed payload.env.title_hint = Some(canonical_tool_name(protocol.tool_family()).into());- env.body_excerpt = None;+ env.body_excerpt = metadata_summary_with_outcome(+ env.event,+ protocol.tool_family(),+ raw.get("tool_call_id"),+ outcome.as_str(),+ );env.raw = raw;env}+fn metadata_summary_with_outcome(+ event: HookEvent,+ family: ToolFamily,+ call_id: Option<&serde_json::Value>,+ outcome: &str,+) -> Option<String> {+ if !matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse) {+ return None;+ }+ let mut body = format!("tool_family: {}", canonical_tool_name(family));+ if let Some(id) = call_id.and_then(serde_json::Value::as_str) {+ body.push_str("\ntool_call_id: ");+ body.push_str(id);+ }+ if event == HookEvent::PostToolUse {+ body.push_str("\noutcome: ");+ body.push_str(outcome);+ }+ Some(body)+}+const fn canonical_tool_name(family: ToolFamily) -> &'static str {match family {ToolFamily::File => "file",@@ -5923,7 +5949,10 @@ mod tests {);let env = inspect_capture_envelope(env).unwrap();assert_eq!(env.title_hint.as_deref(), Some("file"));- assert!(env.body_excerpt.is_none());+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool_family: file\noutcome: unknown")+ );assert!(!env.raw.to_string().contains("SENTINEL_SECRET"));assert_eq!(env.raw["tool_name"], "file");}@@ -6027,7 +6056,10 @@ mod tests {assert_eq!(env.raw["session_id"], "native-metadata");assert_eq!(env.raw["cwd"], "/repo");assert_eq!(env.raw["tool_call_id"], "safe-ID.1");- assert!(env.body_excerpt.is_none());+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool_family: file\ntool_call_id: safe-ID.1\noutcome: unknown")+ );}#[test]@@ -6047,7 +6079,10 @@ mod tests {let env = inspect_capture_envelope(env).unwrap();assert_eq!(env.raw["session_id"], "generated-metadata");assert_eq!(env.raw["cwd"], "/generated");- assert!(env.body_excerpt.is_none());+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool_family: file\noutcome: unknown")+ );}#[test]@@ -6069,6 +6104,48 @@ mod tests {assert!(env.raw.get("extra").is_none());}+ #[test]+ fn capture_protocol_metadata_only_ignores_pi_and_antigravity_outcome_extras() {+ for (agent, extra) in [+ (+ "pi",+ serde_json::json!({"isError": true, "output": "PI_SENTINEL"}),+ ),+ (+ "antigravity-cli",+ serde_json::json!({"error": "AGY_SENTINEL", "output": "OUTPUT_SENTINEL"}),+ ),+ ] {+ let mut body = serde_json::json!({+ "tool_family": "file", "tool_name": "file",+ "_ai_memory_capture": capture_protocol("metadata-only", "invalid", "file", 0, "missing-or-malformed"),+ });+ body.as_object_mut()+ .unwrap()+ .extend(extra.as_object().unwrap().clone());+ let env = HookEnvelope::from_query_and_body(+ HookQuery {+ event: "post-tool-use".into(),+ agent: Some(agent.into()),+ ..Default::default()+ },+ body,+ );+ let env = inspect_capture_envelope(env).unwrap();+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool_family: file\noutcome: unknown")+ );+ for sentinel in ["PI_SENTINEL", "AGY_SENTINEL", "OUTPUT_SENTINEL"] {+ assert!(!env.raw.to_string().contains(sentinel));+ assert!(!env.body_excerpt.as_deref().unwrap().contains(sentinel));+ }+ assert!(env.raw.get("isError").is_none());+ assert!(env.raw.get("error").is_none());+ assert!(env.raw.get("output").is_none());+ }+ }+#[tokio::test]async fn privacy_protocol_evidence_never_persists_protected_tool_sentinel() {const SENTINEL: &str = "PHASE3_PROTECTED_PATH_AND_CONTENT_7f6c";@@ -6131,8 +6208,8 @@ mod tests {);let metadata = inspect_capture_envelope(metadata).expect("valid metadata is retained");assert!(- metadata.body_excerpt.is_none(),- "old envelope extraction sees no body"+ metadata.body_excerpt.as_deref() == Some("tool_family: file\noutcome: unknown"),+ "metadata-only protocol renders only its safe summary");process(&state, metadata, None).await.unwrap();@@ -6169,11 +6246,9 @@ mod tests {assert!(observations.iter().all(|observation| {observation.body.is_empty() || !observation.body.contains(SENTINEL)}));- assert!(- observations- .iter()- .any(|observation| observation.title == "file" && observation.body.is_empty())- );+ assert!(observations.iter().any(|observation| {+ observation.title == "file" && observation.body == "tool_family: file\noutcome: unknown"+ }));assert!(state.reader@@ -6260,7 +6335,10 @@ mod tests {);let env = inspect_capture_envelope(env).unwrap();assert_eq!(env.title_hint.as_deref(), Some("file"));- assert!(env.body_excerpt.is_none());+ assert_eq!(+ env.body_excerpt.as_deref(),+ Some("tool_family: file\noutcome: unknown")+ );assert!(!env.raw.to_string().contains("SENTINEL_SECRET"));assert_eq!(env.raw["_ai_memory_capture"]["policy_state"], "invalid");assert_eq!(@@ -6347,7 +6425,7 @@ mod tests {assert_eq!(observations.len(), 2, "Drop must not be stored");let metadata = observations.last().unwrap();assert_eq!(metadata.title, "file");- assert!(metadata.body.is_empty());+ assert_eq!(metadata.body, "tool_family: file\noutcome: unknown");assert!(observations.iter()diff --git a/docs/marker-file.md b/docs/marker-file.mdindex 680f6cf9..94e244f8 100644--- a/docs/marker-file.md+++ b/docs/marker-file.md@@ -192,10 +192,19 @@ printf '%s\n' '{"session_id":"demo","cwd":"/example/workspace","tool_name":"Edit--server-url http://127.0.0.1:49374 --check-capture```-The normal capture contract is intentionally narrow: `PostToolUse` stores the-tool-response excerpt, capped at 2,000 bytes. User-prompt stores its prompt+The normal capture contract is intentionally narrow: supported Claude Code,+OpenCode, Pi, and Antigravity tool events retain only canonical tool family,+an agent-provided validated call ID when their documented schema proves one,+and a PostToolUse outcome class. `PreToolUse` never retains commands,+arguments, paths, input bodies, or arbitrary tool names. `PostToolUse` appends+its existing tool-response/error excerpt and caps the complete rendered body at+2,000 UTF-8-safe bytes. Unsupported tool envelopes do not gain a PreToolUse+body, and association is only by matching agent-provided call IDs. User-prompt stores its prompttext, notification stores its message/text, and post-compaction stores itssummary; other event bodies are currently empty unless explicitly supported.+Stop and assistant-message capture remain disabled and deferred. The metadata+header is closed; the PostToolUse response/error excerpt remains the existing+bounded content capture.Capture exclusions are evaluated only where paths have a proven schema, so theydo not claim to filter those other bodies.