fix(work): supervisor-dispatched jobs can claim their own assigned item

crates/flare-git-core/src/branch.rs

@@ -179,6 +179,19 @@ pub fn is_linked_worktree(repo_root: &Path) -> bool {
     }
 }
 
+/// The main/canonical checkout's root, even when `repo_root` is itself a
+/// linked worktree -- derived from `--git-common-dir`, which always points
+/// at the shared `.git` inside the main checkout no matter which worktree
+/// it's run from. `None` outside a git repo. `--git-common-dir` can return
+/// either an absolute path or one relative to `repo_root` depending on git
+/// version; `repo_root.join(..)` handles both (joining an absolute path
+/// onto any base just returns that absolute path unchanged).
+#[must_use]
+pub fn main_worktree_root(repo_root: &Path) -> Option<PathBuf> {
+    let common_dir = run_in_opt(repo_root, &["rev-parse", "--git-common-dir"])?;
+    repo_root.join(common_dir).parent().map(Path::to_path_buf)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -287,6 +300,38 @@ mod tests {
         assert!(is_linked_worktree(&wt_path));
     }
 
+    #[test]
+    fn main_worktree_root_resolves_to_the_main_checkout_from_inside_a_linked_worktree() {
+        let repo = init_repo_with_branch("master");
+        let wt_parent = tempfile::TempDir::new().unwrap();
+        let wt_path = wt_parent.path().join("wt-check");
+        crate::shell::run_in(
+            &repo.path,
+            &[
+                "worktree",
+                "add",
+                wt_path.to_str().unwrap(),
+                "-b",
+                "wt-branch",
+            ],
+        )
+        .unwrap();
+        assert_eq!(
+            main_worktree_root(&wt_path).map(|p| p.canonicalize().unwrap()),
+            repo.path.canonicalize().ok(),
+            "must resolve to the main checkout, not the linked worktree it was called from"
+        );
+    }
+
+    #[test]
+    fn main_worktree_root_is_its_own_root_from_the_main_checkout() {
+        let repo = init_repo_with_branch("master");
+        assert_eq!(
+            main_worktree_root(&repo.path).map(|p| p.canonicalize().unwrap()),
+            repo.path.canonicalize().ok()
+        );
+    }
+
     fn init_remote_and_stale_local_clone()
     -> (crate::shell::test_support::Repo, PathBuf, tempfile::TempDir) {
         let remote = init_repo_with_branch("master");

src/cli/work.rs

@@ -276,13 +276,30 @@ fn run_work(args: WorkArgs) -> i32 {
     // same resolver `resolve_agent` uses further down post-claim — so this
     // check and the real resolution can never diverge. Auto-routing needs
     // the claimed item's own attributes, so it's resolved further down.
-    if let Some(explicit) = args.agent.as_deref()
-        && agent_registry::agent_by_name(explicit).is_none()
-    {
-        crate::ui::error(&format!(
-            "unknown agent: {explicit} — use `agentflare agents list`"
-        ));
-        return 1;
+    if let Some(explicit) = args.agent.as_deref() {
+        let Some(resolved) = agent_registry::agent_by_name(explicit) else {
+            crate::ui::error(&format!(
+                "unknown agent: {explicit} — use `agentflare agents list`"
+            ));
+            return 1;
+        };
+        // The claim below identifies its own owner via `claims::owner_id()`,
+        // which falls back to agent-detector's parent-process/env sniffing
+        // when AGENTFLARE_AGENT isn't set. That sniffing finds nothing when
+        // this process is spawned headless (e.g. by the supervisor's
+        // dispatch job, no parent agent process, no session env) and falls
+        // back further to owner "cli" — which then loses to `item::claim`'s
+        // BlockedByAssignee check against whatever agent the item was
+        // actually assigned/dispatched to. An explicit `--agent` is a
+        // stronger, unambiguous statement of identity than any of that
+        // sniffing, so it wins outright here, same for a human typing it
+        // directly or the supervisor dispatching this exact command.
+        //
+        // SAFETY: set once, synchronously, before any worker threads exist
+        // in this process (this is the first thing `run_work` does).
+        unsafe {
+            std::env::set_var("AGENTFLARE_AGENT", resolved.as_str());
+        }
     }
 
     // --- Claim ---

src/mcp_server.rs

@@ -552,10 +552,24 @@ impl AgentflareMcp {
     /// `repo_root()`, but honoring `worktree_repo_root_override` — used only
     /// by the worktree-on-claim feature so tests never run real `git
     /// worktree`/branch operations against this actual repository.
+    ///
+    /// Also redirects to the main checkout when `repo_root()` itself
+    /// resolves to a linked worktree (e.g. a job spawned from inside an
+    /// existing item worktree) — otherwise every item's `.worktrees/`
+    /// lands wherever the calling process's cwd happened to be, nesting a
+    /// fresh worktree inside whatever worktree launched it instead of
+    /// alongside it in the one shared location.
     pub(crate) fn worktree_repo_root(&self) -> std::path::PathBuf {
-        self.worktree_repo_root_override
-            .clone()
-            .unwrap_or_else(Self::repo_root)
+        if let Some(root) = self.worktree_repo_root_override.clone() {
+            return root;
+        }
+        let root = Self::repo_root();
+        if flare_git_core::branch::is_linked_worktree(&root)
+            && let Some(main_root) = flare_git_core::branch::main_worktree_root(&root)
+        {
+            return main_root;
+        }
+        root
     }
 
     /// Test-only constructor: an isolated instance backed entirely by the