Skip to content

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.md
index 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 generated
OpenCode/OMP/Pi/OpenClaw integrations apply the policy before local spool or
diff --git a/crates/ai-memory-consolidate/src/auto_improve.rs b/crates/ai-memory-consolidate/src/auto_improve.rs
index 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.rs
index 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.rs
index 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
&& id
diff --git a/crates/ai-memory-hooks/src/payload.rs b/crates/ai-memory-hooks/src/payload.rs
index 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.rs
index 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.md
index 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 prompt
text, notification stores its message/text, and post-compaction stores its
summary; 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 they
do not claim to filter those other bodies.