Fix native lifecycle hooks in uninitialized worktrees

.claude-plugin/marketplace.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/TerminallyLazy"
   },
   "description": "Claude Code marketplace for Tree Ring Memory v0.15 verified bootstrap, lifecycle recall, strict automatic capture, and receipt-backed harness readiness.",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "plugins": [
     {
       "name": "tree-ring-memory",

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.15.12"
+version = "0.15.13"
 edition = "2021"
 license = "MIT"
 authors = ["TerminallyLazy"]

README.md

@@ -114,6 +114,11 @@ hooks for project-local installs; see the
 The current public-directory upload also includes native Codex lifecycle hooks;
 ordinary Chat hosts without the Codex hook runtime remain guidance-only.
 
+CLI 0.15.13 and the Codex 0.3.9 / Claude 0.3.7 plugins quietly skip lifecycle
+hooks in uninitialized projects and linked worktrees. Each checkout keeps its
+own memory root; inherited hooks never initialize it or reuse another
+checkout's store. Existing roots with broken activation still report errors.
+
 Default `init` creates the canonical project-local store and configures
 maintained adapters where new project-local bridge and manifest entries can be
 created safely. It does not require copying a skill or manually running

crates/tree-ring-memory-cli/src/activation/AGENTS.md

@@ -10,7 +10,7 @@ Adapter detection, bridge filesystem operations, manifests, lifecycle parsing, p
 
 ## Local Contracts
 
-Use SessionStart/SubagentStart for recall and Stop/SubagentStop for bounded agent capture. Normalize equivalent local paths without following symlinks; retain descriptor-relative no-follow access and create-only publication. Missing activation records need review; only a fresh matching receipt establishes active status.
+Use SessionStart/SubagentStart for recall and Stop/SubagentStop for bounded agent capture. Normalize equivalent local paths without following symlinks; retain descriptor-relative no-follow access and create-only publication. Lifecycle hooks may skip only a genuinely absent project-local .tree-ring root after input and project-path validation. Existing invalid roots or missing activation records remain errors; only a fresh matching receipt establishes active status. Generated hook guards do not apply to explicit preflight or capture commands.
 
 ## Work Guidance
 
@@ -21,6 +21,8 @@ runtime and minor series. Coordinate the core allowlist and plugin descriptor
 before publishing either release; verify the actual pair with CLI activation,
 preflight, and receipt-backed status. A passing version probe alone is insufficient.
 
+Recognize earlier Claude handler bundles only by exact recorded ownership, commands, and generated entry shape. Preserve custom handlers and settings; bridge reconciliation still follows create-only publication and cannot silently replace existing hooks or manifests.
+
 When creating root AGENTS.md, record ownership of only the marked Tree Ring block so surrounding project instructions remain editable. Preserve legacy complete-file ownership until explicitly reconciled; never migrate an existing activation manifest automatically.
 
 ## Verification

crates/tree-ring-memory-cli/src/activation/bridge.rs

@@ -465,6 +465,20 @@ impl ProjectFs {
         Ok(project_fs)
     }
 
+    /// Only a genuinely absent project-local root is an inactive lifecycle hook.
+    /// The pinned project descriptor preserves existing path-alias semantics;
+    /// O_NOFOLLOW on the child keeps redirected or broken installations errors.
+    pub(crate) fn lifecycle_memory_root_absent(&self) -> Result<bool, String> {
+        self.ensure_root_binding()?;
+        let absent = match open_child_directory(&self.root, OsStr::new(".tree-ring")) {
+            Ok(_) => false,
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => true,
+            Err(error) => return Err(io_error(&self.project_root.join(".tree-ring"), error)),
+        };
+        self.ensure_root_binding()?;
+        Ok(absent)
+    }
+
     pub(crate) fn lock_manifest(&self) -> Result<ManifestLock, String> {
         self.ensure_root_binding()?;
         let file = self
@@ -1167,6 +1181,13 @@ impl ProjectFs {
         Err("bridge mutation requires descriptor-relative no-follow filesystem support".to_string())
     }
 
+    pub(crate) fn lifecycle_memory_root_absent(&self) -> Result<bool, String> {
+        Err(
+            "lifecycle root inspection requires descriptor-relative no-follow filesystem support"
+                .to_string(),
+        )
+    }
+
     pub(crate) fn lock_manifest(&self) -> Result<ManifestLock, String> {
         Err("bridge mutation requires descriptor-relative no-follow filesystem support".to_string())
     }
@@ -1544,6 +1565,12 @@ pub fn validate_isolated_preflight_roots(
         .map_err(|_| "isolated preflight roots are invalid".to_string())
 }
 
+/// Checks inactivity for lifecycle hooks without creating a store or suppressing
+/// invalid existing roots. Explicit preflight and capture do not use this path.
+pub fn lifecycle_memory_root_absent(project: &ActivationProject) -> Result<bool, String> {
+    ProjectFs::open(project)?.lifecycle_memory_root_absent()
+}
+
 /// Reads the init manifest through the pinned project descriptor. A missing
 /// manifest is returned as `None`; callers may then construct the first
 /// in-memory identity for creation-only batch publication.
@@ -2004,8 +2031,14 @@ fn prepare_claude_settings(
     let before = project_fs.read_optional(&write.path)?;
     let path = relative_string(&write.path)?;
     let handler_hash = sha256(&serde_json::to_vec(&claude_handlers()).map_err(json_error)?);
-    let legacy_handler_hash =
-        sha256(&serde_json::to_vec(&legacy_claude_handlers()).map_err(json_error)?);
+    let legacy_handler_hashes = [legacy_claude_handlers(), previous_v4_claude_handlers()]
+        .iter()
+        .map(|handlers| {
+            serde_json::to_vec(handlers)
+                .map(|bytes| sha256(&bytes))
+                .map_err(json_error)
+        })
+        .collect::<Result<Vec<_>, _>>()?;
     if before.is_none() {
         if owned_files.iter().any(|owned| owned.path == path)
             || managed_blocks
@@ -2068,7 +2101,7 @@ fn prepare_claude_settings(
     let owns_legacy_bundle = managed_blocks.iter().any(|owned| {
         owned.path == path
             && owned.block_id == write.block_id
-            && owned.sha256 == legacy_handler_hash
+            && legacy_handler_hashes.contains(&owned.sha256)
     });
     match state {
         ClaudeHandlerState::Conflict => {
@@ -2381,6 +2414,34 @@ fn legacy_claude_handlers() -> Vec<(&'static str, Value)> {
     ]
 }
 
+// Freeze the exact pre-absence-guard v4 bundle; ownership checks must never
+// adopt commands that merely resemble a previous generated template.
+fn previous_v4_claude_handlers() -> Vec<(&'static str, Value)> {
+    let command = r#"project_root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"; tree_ring="$project_root/.tree-ring/bin/tree-ring"; if [ ! -x "$tree_ring" ]; then tree_ring=tree-ring; fi; exec "$tree_ring" --root "$project_root/.tree-ring" integrations hook --harness claude-code --input-json-stdin"#;
+    [
+        ("SessionStart", "Tree Ring Memory managed lifecycle v4"),
+        (
+            "SubagentStart",
+            "Tree Ring Memory managed subagent lifecycle v4",
+        ),
+        ("Stop", "Tree Ring Memory managed capture checkpoint v4"),
+        (
+            "SubagentStop",
+            "Tree Ring Memory managed subagent capture checkpoint v4",
+        ),
+    ]
+    .into_iter()
+    .map(|(event, description)| {
+        (
+            event,
+            json!({
+                "type": "command", "command": command, "description": description, "timeout": 10
+            }),
+        )
+    })
+    .collect()
+}
+
 fn claude_handlers() -> Vec<(&'static str, Value)> {
     vec![
         ("SessionStart", claude_handler()),
@@ -2499,27 +2560,56 @@ fn insert_claude_handlers(root: &mut Map<String, Value>) -> Result<(), String> {
 }
 
 fn replace_legacy_claude_handlers(root: &mut Map<String, Value>) -> Result<bool, String> {
-    let legacy = legacy_claude_handlers();
+    for legacy in [legacy_claude_handlers(), previous_v4_claude_handlers()] {
+        // Failed matches must not partially remove handlers from the caller.
+        let mut candidate = root.clone();
+        if replace_exact_claude_handlers(&mut candidate, &legacy)? {
+            *root = candidate;
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+fn replace_exact_claude_handlers(
+    root: &mut Map<String, Value>,
+    legacy: &[(&str, Value)],
+) -> Result<bool, String> {
     let Some(hooks) = root.get_mut("hooks").and_then(Value::as_object_mut) else {
         return Ok(false);
     };
     let mut removed = 0usize;
-    for (event, expected_handler) in &legacy {
+    for (event, expected_handler) in legacy {
         let Some(entries) = hooks.get_mut(*event).and_then(Value::as_array_mut) else {
             return Ok(false);
         };
+        let mut event_removed = 0usize;
         for entry in entries.iter_mut() {
+            let contains_expected = entry
+                .get("hooks")
+                .and_then(Value::as_array)
+                .is_some_and(|handlers| handlers.contains(expected_handler));
+            if contains_expected
+                && (entry.get("matcher").and_then(Value::as_str) != Some("")
+                    || entry.as_object().is_none_or(|object| object.len() != 2))
+            {
+                return Ok(false);
+            }
             let Some(handlers) = entry.get_mut("hooks").and_then(Value::as_array_mut) else {
                 continue;
             };
             handlers.retain(|handler| {
                 let matches = handler == expected_handler;
                 if matches {
                     removed += 1;
+                    event_removed += 1;
                 }
                 !matches
             });
         }
+        if event_removed != 1 {
+            return Ok(false);
+        }
         entries.retain(|entry| {
             entry
                 .get("hooks")
@@ -2533,6 +2623,10 @@ fn replace_legacy_claude_handlers(root: &mut Map<String, Value>) -> Result<bool,
     if removed != legacy.len() {
         return Ok(false);
     }
+    // A partial, duplicated, or custom claimed handler is never adopted.
+    if inspect_claude_handler(root)? != ClaudeHandlerState::Absent {
+        return Ok(false);
+    }
     insert_claude_handlers(root)?;
     Ok(true)
 }
@@ -3756,6 +3850,128 @@ mod tests {
             .exists());
     }
 
+    #[test]
+    fn exact_owned_previous_v4_claude_bundle_is_prepared_without_automatic_publication() {
+        for complete_file in [true, false] {
+            let (_temp, project, mut manifest) = fixture();
+            let settings = Path::new(".claude/settings.json");
+            let mut root = json!({"permissions": {"allow": ["Read"]}, "hooks": {}})
+                .as_object()
+                .unwrap()
+                .clone();
+            for (event, handler) in previous_v4_claude_handlers() {
+                root["hooks"].as_object_mut().unwrap().insert(
+                    event.to_string(),
+                    json!([{"matcher": "", "hooks": [handler]}]),
+                );
+            }
+            let before = pretty_json(&Value::Object(root)).unwrap();
+            fs::create_dir(project.project_root.join(".claude")).unwrap();
+            fs::write(project.project_root.join(settings), &before).unwrap();
+            let mut owned = Vec::new();
+            let mut blocks = Vec::new();
+            if complete_file {
+                upsert_owned_file(
+                    &mut owned,
+                    settings.to_string_lossy().into_owned(),
+                    sha256(&before),
+                );
+            } else {
+                upsert_managed_block(
+                    &mut blocks,
+                    settings.to_string_lossy().into_owned(),
+                    "claude-code".to_string(),
+                    sha256(&serde_json::to_vec(&previous_v4_claude_handlers()).unwrap()),
+                    String::new(),
+                );
+            }
+            let existing_owned = owned.clone();
+            let existing_blocks = blocks.clone();
+            let project_fs = ProjectFs::open(&project).unwrap();
+            let prepared = prepare_claude_settings(
+                &project_fs,
+                &ManagedBlockUpdate {
+                    path: settings.into(),
+                    block_id: "claude-code".to_string(),
+                },
+                &mut owned,
+                &mut blocks,
+            )
+            .unwrap()
+            .unwrap();
+            assert_eq!(prepared.before.as_ref(), Some(&before));
+            let after = parse_json_object(prepared.after.as_ref().unwrap()).unwrap();
+            assert_eq!(
+                inspect_claude_handler(&after).unwrap(),
+                ClaudeHandlerState::Exact
+            );
+            assert_eq!(after["permissions"]["allow"][0], "Read");
+            assert!(files_require_existing_entry_mutation(&[prepared]));
+            manifest.harnesses.insert(
+                "claude-code".to_string(),
+                HarnessActivation {
+                    state: ActivationState::ConfiguredAwaitingProof,
+                    adapter_capability: AdapterCapability::NativePreflight,
+                    adapter_version: "4".to_string(),
+                    bridge_fingerprint: "a".repeat(64),
+                    bridge_path: Some(settings.to_string_lossy().into_owned()),
+                    owned_files: existing_owned,
+                    managed_blocks: existing_blocks,
+                },
+            );
+            let result = apply_bridge_plan(
+                &project,
+                &mut manifest,
+                plan("claude-code", &project),
+                false,
+            )
+            .unwrap();
+            assert_eq!(result.state, ActivationState::NeedsUserReview);
+            assert!(result.changed_paths.is_empty());
+            assert_eq!(
+                fs::read(project.project_root.join(settings)).unwrap(),
+                before
+            );
+            assert!(!project.memory_root.join("activation.json").exists());
+        }
+    }
+
+    #[test]
+    fn previous_v4_claude_replacement_rejects_modified_or_duplicate_handlers() {
+        for change in ["custom", "duplicate", "missing", "matcher", "metadata"] {
+            let mut root = json!({"hooks": {}}).as_object().unwrap().clone();
+            for (event, handler) in previous_v4_claude_handlers() {
+                root["hooks"].as_object_mut().unwrap().insert(
+                    event.to_string(),
+                    json!([{"matcher": "", "hooks": [handler]}]),
+                );
+            }
+            if change == "matcher" {
+                root["hooks"]["SessionStart"][0]["matcher"] = json!("resume");
+            }
+            if change == "metadata" {
+                root["hooks"]["SessionStart"][0]["custom"] = json!(true);
+            }
+            let handlers = root["hooks"]["SessionStart"][0]["hooks"]
+                .as_array_mut()
+                .unwrap();
+            match change {
+                "custom" => {
+                    handlers[0]["command"] = json!("echo custom tree-ring --harness claude-code")
+                }
+                "duplicate" => handlers.push(handlers[0].clone()),
+                "missing" => {
+                    handlers.clear();
+                }
+                "matcher" | "metadata" => {}
+                _ => unreachable!(),
+            }
+            let before = root.clone();
+            assert!(!replace_legacy_claude_handlers(&mut root).unwrap());
+            assert_eq!(root, before);
+        }
+    }
+
     #[test]
     fn exact_legacy_claude_bundle_upgrades_without_touching_user_settings() {
         let mut root = json!({