@shanesaravia/hive 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to Hive will be documented in this file.
 
+## 0.2.1 — 2026-08-25
+
+### Added
+
+- Plan tab shows a "Phases" / "Tasks" section header, clarifying that task numbers are global across phases.
+- Pending decisions appear in the top notice slot as a compact strip and slide-over, visible from every tab and both presentations, replacing the Conversation-tab-only placement.
+- Office desks are click targets that behave exactly like their avatar, across manager, worker, and direct seats in both the fleet floor and the mission room.
+- Shared `DetailDrawer` shell so worker inspection and pending decisions match in width, background, header rhythm, and dismissal.
+
+### Changed
+
+- Mission room collapses its goal to one line, compacts summary tiles, drops duplicate side-panel titles, and lets the room and chat grow with the viewport, adding roughly 100px of chat at 900px tall and 320px on tall displays.
+- Widened the mission room viewBox so the whole floor stays inside the canvas, with height capped to avoid empty canvas beneath it.
+
+### Fixed
+
+- Reclaim a mission's worktree and branch when it is deleted, archived, or completed, instead of leaving every worktree-isolated mission behind on disk forever. Completion keeps a worktree that holds uncommitted changes, since a follow-up message reopens a completed mission and **Clear completed desks** completes many at once.
+- Resume a reopened mission in its base repository when its worktree has already been reclaimed, rather than resuming into a path that no longer exists.
+- An unanswered decision keeps a mission in `waiting_on_you` instead of decaying to idle or stalled once the session record goes quiet, so office lighting, desks, status pill, and the attention badge stay in agreement.
+- Suppressed the duplicate "Waiting for your reply" banner when a structured decision already covers it.
+
 ## 0.2.0 — 2026-08-25
 
 Adds the visual office, a second presentation of the same fleet state alongside the existing cards.

package/README.md

@@ -311,6 +311,20 @@ Hive deliberately separates the durable mission lifecycle from current runtime a
 
 A Claude job ending does **not** automatically mean its mission succeeded. Orchestrators move missions to **Awaiting acceptance**; the user accepts completion or requests changes. Manual lifecycle controls are available in the mission header.
 
+### Worktree reclamation
+
+Missions launched with worktree isolation get a checked-out worktree under `.claude/worktrees/` and a matching `worktree-` branch. Hive reclaims both when a mission reaches a terminal state, so repositories do not accumulate abandoned checkouts.
+
+| Mission reaches | Worktree |
+| --- | --- |
+| Deleted | Removed |
+| Archived | Removed |
+| Completed | Removed when clean; **kept** when it holds uncommitted changes |
+
+Completion is treated more cautiously than deletion or archiving because it is reversible — sending a follow-up message to a completed mission reopens it — and because **Clear completed desks** completes many Direct missions at once. Uncommitted work in a worktree therefore survives completion, and a worktree left behind for that reason is recorded in the mission's Activity tab.
+
+Reclamation only ever touches worktrees in Hive's managed layout; a repository or a hand-made directory is never removed, whatever a stale job record claims. If a reopened mission's worktree has already been reclaimed, Hive resumes it in the repository the worktree was cut from and records the change.
+
 ## MCP servers, skills, and project configuration
 
 Hive launches the normal local provider CLI rather than a separate container or account.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shanesaravia/hive",
   "private": false,
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Provider-neutral local mission control for Claude Code, Codex, and agent fleets.",
   "license": "MIT",

package/packages/server/dist/api/rest.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import fs from "node:fs";
 import { canClearDirectStudioMission } from "@hive/shared";
 import { CONTEXT_BUDGETS } from "../messages/messagesStore.js";
 import { allPlanTasks } from "../plans/plansStore.js";
@@ -17,6 +18,7 @@ import { createTemplate, deleteTemplate, discoverTemplates, discoverTemplatesDet
 import { publishGitHubReport } from "../reports/githubPublisher.js";
 import { enforceWorkingDirectory, normalize } from "../policies/policiesStore.js";
 import { detectProviderModels } from "../control/providerModels.js";
+import { reclaimEventDetail, reclaimWorktree } from "../worktrees/worktreeReclaim.js";
 export function registerRest(app, deps) {
     const { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex } = deps;
     const missionSendTails = new Map();
@@ -27,6 +29,47 @@ export function registerRest(app, deps) {
         const sessionId = missions.latestSessionFor(missionId) ?? latest?.[1].sessionId ?? latest?.[1].resumeSessionId;
         return latest && sessionId ? { jobId: latest[0], sessionId } : undefined;
     }
+    /**
+     * Worktree identity lives on the provider job records, not the durable
+     * mission, so it must be read while those jobs are still linked — callers
+     * that also delete the mission have to resolve this first.
+     */
+    function missionWorktree(missionId) {
+        const jobs = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === missionId);
+        const carrier = jobs.find(([, job]) => job.worktreePath)?.[1];
+        return { path: carrier?.worktreePath, branch: carrier?.worktreeBranch };
+    }
+    /**
+     * The working directory to resume a mission in. Normally the recorded
+     * repository; when that was a worktree Hive has since reclaimed, the base
+     * repository the worktree was cut from.
+     */
+    function resumeRepository(missionId, repository) {
+        if (!repository || fs.existsSync(repository))
+            return repository;
+        const jobs = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === missionId);
+        const origin = jobs.map(([, job]) => job.originCwd).find((cwd) => cwd && fs.existsSync(cwd));
+        return origin ?? repository;
+    }
+    /**
+     * Reclaims the mission's worktree and records the outcome on the timeline.
+     * Never throws: losing a worktree cleanup must not fail the lifecycle
+     * change the user actually asked for.
+     */
+    function reclaimMissionWorktree(missionId, trigger, target, worktree = missionWorktree(missionId)) {
+        if (!worktree.path)
+            return;
+        let detail;
+        try {
+            detail = reclaimEventDetail(reclaimWorktree(worktree, trigger), trigger);
+        }
+        catch (error) {
+            detail = `Worktree reclaim failed: ${error.message}`;
+        }
+        if (detail && target) {
+            events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail });
+        }
+    }
     async function withMissionQueue(missionId, run) {
         const previous = missionSendTails.get(missionId) ?? Promise.resolve();
         const operation = previous.catch(() => undefined).then(run);
@@ -63,10 +106,19 @@ export function registerRest(app, deps) {
             const reopening = ["ready_for_review", "completed", "archived", "failed", "paused"].includes(summary.lifecycleStatus);
             if (reopening)
                 missions.setLifecycleStatus(missionId, "active");
+            // A follow-up implicitly reopens a closed mission, but reaching a
+            // terminal state reclaims its worktree — so the recorded repository can
+            // be a directory that no longer exists. Fall back to the repository the
+            // worktree was cut from rather than resuming into a dead path.
+            const repository = resumeRepository(missionId, summary.repository);
+            if (repository && repository !== summary.repository) {
+                missions.setRepository(missionId, repository);
+                events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission worktree was reclaimed; resuming in ${repository}` });
+            }
             let result;
             try {
                 result = provider === "codex"
-                    ? await codex.start({ task: prompt, cwd: summary.repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
+                    ? await codex.start({ task: prompt, cwd: repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
                     : await sendMessage(target.sessionId, prompt, policy, additionalRepos);
             }
             catch (error) {
@@ -90,6 +142,9 @@ export function registerRest(app, deps) {
         for (const node of eligible) {
             missions.setLifecycleStatus(node.missionId, "completed");
             events.add({ ts: Date.now(), sessionId: node.sessionId, jobId: node.jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: "Direct mission completed through Clear completed desks" });
+            // Bulk completion reclaims on the same clean-only terms as a single
+            // completion: uncommitted work in any desk's worktree survives.
+            reclaimMissionWorktree(node.missionId, "completed", { jobId: node.jobId, sessionId: node.sessionId });
         }
         return { ok: true, cleared: eligible.map((node) => node.missionId), remaining: snapshot.orchestrators.filter((node) => node.mission.mode === "direct" && node.lifecycleStatus === "active").length - eligible.length };
     });
@@ -816,6 +871,11 @@ Revise the structured plan to remove that requirement and stop work that was nee
         const target = latestMissionTarget(req.params.missionId);
         if (target)
             events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission status changed from ${previous} to ${req.body.status}` });
+        // Reclaim only on entry into a terminal state, so re-archiving an already
+        // archived mission does not re-run git against a path that is long gone.
+        if (previous !== req.body.status && (req.body.status === "archived" || req.body.status === "completed")) {
+            reclaimMissionWorktree(req.params.missionId, req.body.status, target);
+        }
         return { ok: true };
     });
     app.post("/api/mission/:missionId/action", async (req, reply) => {
@@ -900,6 +960,9 @@ Revise the structured plan to remove that requirement and stop work that was nee
     });
     app.delete("/api/mission/:missionId", async (req, reply) => {
         const target = latestMissionTarget(req.params.missionId);
+        // Resolved before removal: missions.remove() unlinks the jobs that carry
+        // the worktree path, and afterwards it can no longer be found.
+        const worktree = missionWorktree(req.params.missionId);
         if (target)
             events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission permanently deleted: ${req.params.missionId}` });
         if (!missions.remove(req.params.missionId)) {
@@ -908,6 +971,7 @@ Revise the structured plan to remove that requirement and stop work that was nee
         }
         messages.removeMission(req.params.missionId);
         plans.removeMission(req.params.missionId);
+        reclaimMissionWorktree(req.params.missionId, "deleted", target, worktree);
         return { ok: true };
     });
     app.post("/api/session/:pid/stop", async (req, reply) => {

package/packages/server/dist/missions/missionsStore.js

@@ -190,6 +190,16 @@ export class MissionsStore {
         mission.updatedAt = Date.now();
         this.changed();
     }
+    /**
+     * Repoints a mission at a different working directory. Used when a mission's
+     * worktree has been reclaimed and work must continue in the base repository.
+     */
+    setRepository(missionId, repository) {
+        const mission = this.ensureLegacyMission(missionId);
+        mission.repository = repository;
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
     setLifecycleStatus(missionId, status) {
         const mission = this.ensureLegacyMission(missionId);
         mission.lifecycleStatus = status;

package/packages/server/dist/roster/rosterBuilder.js

@@ -52,6 +52,51 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
         group.push({ jobId, job });
         groups.set(missionId, group);
     }
+    // Per-mission pending decisions. Used both for the global inbox and, inside the
+    // mission loop, to keep a mission reading as waiting_on_you for as long as a
+    // decision is unanswered — even after the provider session record has gone
+    // quiet — so the office lighting, desk, status pill, and "?" badge agree.
+    const pendingDecisionsFor = (node) => {
+        if (node.lifecycleStatus === "completed" || node.lifecycleStatus === "archived")
+            return [];
+        const resolved = new Set(node.recentEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
+        const missionContext = { missionObjective: node.mission.objective || undefined, repository: node.mission.repository };
+        // Only the current, mid-turn blocker belongs in the decision inbox. An
+        // unresolved event from an older/completed turn is history: the mission
+        // may remain open for optional follow-up, but it is not waiting on the
+        // user. Requiring the blocker to be the latest observed event also clears
+        // it as soon as provider activity resumes.
+        const latestEvent = node.recentEvents.at(-1);
+        const fromEvents = !node.turnCompleted && latestEvent?.phase === "blocked_on_user"
+            && latestEvent.decisionId && !resolved.has(latestEvent.decisionId)
+            && (!latestEvent.jobId || latestEvent.jobId === node.jobId)
+            ? [{
+                    id: latestEvent.decisionId, missionId: node.missionId, missionName: node.name,
+                    kind: latestEvent.decisionKind ?? "question", question: latestEvent.detail, context: latestEvent.context,
+                    choices: latestEvent.choices ?? [], recommendation: latestEvent.recommendation, impact: latestEvent.impact, createdAt: latestEvent.ts, ...missionContext,
+                }]
+            : [];
+        // A permission prompt parks the session mid-turn (tempo blocked, the ask
+        // in needs) with no TTY to answer it — surface it as an answerable
+        // decision. It self-clears once the job is no longer parked.
+        const latestJob = jobs.get(node.jobId);
+        const parked = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && /^approve\s/i.test(latestJob.needs) && !resolved.has(`perm:${node.jobId}`)
+            ? [{
+                    id: `perm:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "permission", question: latestJob.needs, context: latestJob.detail,
+                    choices: ["Approve & continue", "Deny"], impact: "The session is parked at this prompt until you answer.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        const hasStructuredPrompt = node.recentEvents.some((event) => event.jobId === node.jobId && event.phase === "blocked_on_user" && event.decisionId?.startsWith("skill-prompt:"));
+        const providerPrompt = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && (latestJob.promptChoices?.length ?? 0) > 0 && !/^approve\s/i.test(latestJob.needs) && !/rate limit|spend limit/i.test(latestJob.needs) && !hasStructuredPrompt && !resolved.has(`prompt:${node.jobId}`)
+            ? [{
+                    id: `prompt:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "question", question: latestJob.needs, context: latestJob.detail,
+                    choices: latestJob.promptChoices ?? [], impact: "The provider is waiting for this answer before the skill can continue.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        return [...fromEvents, ...parked, ...providerPrompt];
+    };
     for (const [missionId, group] of groups) {
         group.sort((a, b) => dateMs(a.job.createdAt) - dateMs(b.job.createdAt));
         const latest = group[group.length - 1];
@@ -298,8 +343,15 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 activityStatus = "stalled";
             }
         }
+        const name = missions?.nameFor(missionId) ?? oldest.job.name ?? latest.job.name ?? missionId;
+        const turnCompleted = latest.job.state === "done";
+        const pendingDecisions = pendingDecisionsFor({ missionId, name, jobId: latest.jobId, mission, lifecycleStatus: mission.lifecycleStatus, turnCompleted, recentEvents, updatedAt });
+        // An unanswered decision is, by definition, waiting on the user. Do not let the
+        // runtime's quiet session decay it to idle/stalled while the question stands.
+        if (mission.lifecycleStatus === "active" && pendingDecisions.length && (activityStatus === "idle" || activityStatus === "stalled"))
+            activityStatus = "waiting_on_you";
         const runStartedAt = dateMs(latest.job.createdAt) || createdAt;
-        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted: latest.job.state === "done", workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
+        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted, workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
         orchestrators.push({
             missionId,
             threadId: missionId,
@@ -312,14 +364,11 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 latest.job.resumeSessionId ??
                 latest.jobId,
             pid: session?.pid ?? -1,
-            name: missions?.nameFor(missionId) ??
-                oldest.job.name ??
-                latest.job.name ??
-                missionId,
+            name,
             status: activityStatus,
             lifecycleStatus: mission.lifecycleStatus,
             activityStatus,
-            turnCompleted: latest.job.state === "done",
+            turnCompleted,
             inactiveForMs,
             waitingFor: mission.lifecycleStatus === "completed" || mission.lifecycleStatus === "archived" ? undefined : session?.waitingFor ?? latest.job.needs,
             worktreePath: latest.job.worktreePath ?? oldest.job.worktreePath,
@@ -362,46 +411,6 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
         });
     }
     orchestrators.sort((a, b) => b.updatedAt - a.updatedAt);
-    const decisions = orchestrators.flatMap((node) => {
-        if (node.lifecycleStatus === "completed" || node.lifecycleStatus === "archived")
-            return [];
-        const resolved = new Set(node.recentEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
-        const missionContext = { missionObjective: node.mission.objective || undefined, repository: node.mission.repository };
-        // Only the current, mid-turn blocker belongs in the decision inbox. An
-        // unresolved event from an older/completed turn is history: the mission
-        // may remain open for optional follow-up, but it is not waiting on the
-        // user. Requiring the blocker to be the latest observed event also clears
-        // it as soon as provider activity resumes.
-        const latestEvent = node.recentEvents.at(-1);
-        const fromEvents = !node.turnCompleted && latestEvent?.phase === "blocked_on_user"
-            && latestEvent.decisionId && !resolved.has(latestEvent.decisionId)
-            && (!latestEvent.jobId || latestEvent.jobId === node.jobId)
-            ? [{
-                    id: latestEvent.decisionId, missionId: node.missionId, missionName: node.name,
-                    kind: latestEvent.decisionKind ?? "question", question: latestEvent.detail, context: latestEvent.context,
-                    choices: latestEvent.choices ?? [], recommendation: latestEvent.recommendation, impact: latestEvent.impact, createdAt: latestEvent.ts, ...missionContext,
-                }]
-            : [];
-        // A permission prompt parks the session mid-turn (tempo blocked, the ask
-        // in needs) with no TTY to answer it — surface it as an answerable
-        // decision. It self-clears once the job is no longer parked.
-        const latestJob = jobs.get(node.jobId);
-        const parked = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && /^approve\s/i.test(latestJob.needs) && !resolved.has(`perm:${node.jobId}`)
-            ? [{
-                    id: `perm:${node.jobId}`, missionId: node.missionId, missionName: node.name,
-                    kind: "permission", question: latestJob.needs, context: latestJob.detail,
-                    choices: ["Approve & continue", "Deny"], impact: "The session is parked at this prompt until you answer.", createdAt: node.updatedAt, ...missionContext,
-                }]
-            : [];
-        const hasStructuredPrompt = node.recentEvents.some((event) => event.jobId === node.jobId && event.phase === "blocked_on_user" && event.decisionId?.startsWith("skill-prompt:"));
-        const providerPrompt = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && (latestJob.promptChoices?.length ?? 0) > 0 && !/^approve\s/i.test(latestJob.needs) && !/rate limit|spend limit/i.test(latestJob.needs) && !hasStructuredPrompt && !resolved.has(`prompt:${node.jobId}`)
-            ? [{
-                    id: `prompt:${node.jobId}`, missionId: node.missionId, missionName: node.name,
-                    kind: "question", question: latestJob.needs, context: latestJob.detail,
-                    choices: latestJob.promptChoices ?? [], impact: "The provider is waiting for this answer before the skill can continue.", createdAt: node.updatedAt, ...missionContext,
-                }]
-            : [];
-        return [...fromEvents, ...parked, ...providerPrompt];
-    }).sort((a, b) => b.createdAt - a.createdAt);
+    const decisions = orchestrators.flatMap((node) => pendingDecisionsFor(node)).sort((a, b) => b.createdAt - a.createdAt);
     return { orchestrators, decisions, other, generatedAt: Date.now() };
 }

package/packages/server/dist/worktrees/worktreeReclaim.js

@@ -0,0 +1,156 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Hive launches missions through the provider CLI's native `--worktree`
+ * primitive (see control/launcher.ts) but nothing ever reclaimed the result,
+ * so every templated mission leaked a checked-out worktree and a branch.
+ *
+ * Reclamation is deliberately scoped to worktrees Hive itself caused to
+ * exist: the CLI creates them under `<repo>/.claude/worktrees/<name>` on a
+ * `worktree-<name>` branch. Anything outside that layout is left alone, so a
+ * stale or wrong `worktreePath` on a job record can never delete a real
+ * checkout.
+ */
+/** Path segment the provider CLI uses for its managed worktrees. */
+const MANAGED_SEGMENT = path.join(".claude", "worktrees");
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+/**
+ * git may answer --git-common-dir with either an absolute or a
+ * repository-relative path depending on where it runs, and resolving a
+ * relative answer against the wrong base silently yields a bogus path.
+ * --path-format is authoritative where available (git 2.31+).
+ */
+function commonGitDir(cwd) {
+    try {
+        return git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    }
+    catch {
+        return path.resolve(cwd, git(cwd, ["rev-parse", "--git-common-dir"]));
+    }
+}
+/**
+ * A managed worktree lives under `.claude/worktrees/` AND reports a git common
+ * directory different from its own git dir. Both checks matter: the path shape
+ * alone would trust unverified job metadata, and the git check alone would
+ * happily remove a worktree the user created by hand somewhere else.
+ */
+export function isManagedWorktree(worktreePath) {
+    if (!worktreePath.includes(MANAGED_SEGMENT))
+        return false;
+    let gitEntry;
+    try {
+        gitEntry = fs.statSync(path.join(worktreePath, ".git"));
+    }
+    catch {
+        return false;
+    }
+    // A linked worktree records its git directory in a `.git` FILE; a main
+    // checkout has a `.git` DIRECTORY. That distinction is what stops a real
+    // repository from ever being reclaimed, and unlike comparing
+    // --git-dir against --git-common-dir it cannot be fooled by git mixing
+    // absolute and relative path output for a nested directory.
+    if (!gitEntry.isFile())
+        return false;
+    try {
+        return git(worktreePath, ["rev-parse", "--is-inside-work-tree"]) === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/** Uncommitted tracked or untracked changes in the worktree. */
+export function isWorktreeDirty(worktreePath) {
+    try {
+        return git(worktreePath, ["status", "--porcelain"]).length > 0;
+    }
+    catch {
+        // Unreadable means unverifiable, and unverifiable must not be discarded.
+        return true;
+    }
+}
+/**
+ * `completed` is reversible — a follow-up message implicitly reopens a
+ * completed mission (see rest.ts), and "Clear completed desks" completes many
+ * missions at once — so uncommitted work survives it. `deleted` and `archived`
+ * are explicit, per-mission, terminal gestures and reclaim unconditionally.
+ */
+function discardsUncommittedWork(trigger) {
+    return trigger !== "completed";
+}
+/**
+ * Removes a mission's worktree and its branch. Safe to call for any mission:
+ * missions without a worktree, and worktrees already gone, report "absent".
+ */
+export function reclaimWorktree(target, trigger) {
+    const worktreePath = target.path;
+    if (!worktreePath)
+        return { status: "absent" };
+    if (!fs.existsSync(worktreePath))
+        return { status: "absent", path: worktreePath, branch: target.branch };
+    if (!isManagedWorktree(worktreePath)) {
+        return { status: "unmanaged", path: worktreePath, branch: target.branch, detail: "not a Hive-managed worktree" };
+    }
+    if (!discardsUncommittedWork(trigger) && isWorktreeDirty(worktreePath)) {
+        return { status: "kept_dirty", path: worktreePath, branch: target.branch, detail: "uncommitted changes preserved" };
+    }
+    // The main checkout owns the worktree administrative data, so removal and
+    // branch deletion must run from the common repository, not from inside the
+    // directory being deleted.
+    let repositoryRoot;
+    try {
+        repositoryRoot = path.dirname(commonGitDir(worktreePath));
+    }
+    catch (error) {
+        return { status: "failed", path: worktreePath, branch: target.branch, detail: error.message };
+    }
+    try {
+        // Locked worktrees are Hive's own (the CLI locks some during launch);
+        // unlock is a no-op when the worktree was never locked.
+        try {
+            git(repositoryRoot, ["worktree", "unlock", worktreePath]);
+        }
+        catch { /* not locked */ }
+        git(repositoryRoot, ["worktree", "remove", "--force", worktreePath]);
+    }
+    catch (error) {
+        return { status: "failed", path: worktreePath, branch: target.branch, detail: error.message };
+    }
+    let detail;
+    if (target.branch) {
+        const branch = target.branch.replace(/^refs\/heads\//, "");
+        try {
+            // -D rather than -d: the branch was just verified to hold no
+            // uncommitted work, and an unmerged experiment branch is exactly what
+            // this reclaim is meant to collect. The commits stay in the reflog.
+            git(repositoryRoot, ["branch", "-D", branch]);
+        }
+        catch {
+            detail = `worktree removed; branch ${branch} retained`;
+        }
+    }
+    try {
+        git(repositoryRoot, ["worktree", "prune"]);
+    }
+    catch { /* best effort */ }
+    return { status: "removed", path: worktreePath, branch: target.branch, detail };
+}
+/** Human-readable line for the mission activity timeline. */
+export function reclaimEventDetail(result, trigger) {
+    const name = result.path ? path.basename(result.path) : "worktree";
+    if (result.status === "removed") {
+        return `Worktree ${name} reclaimed after mission ${trigger}${result.detail ? ` · ${result.detail}` : ""}`;
+    }
+    if (result.status === "kept_dirty") {
+        return `Worktree ${name} kept: uncommitted changes remain after mission ${trigger}`;
+    }
+    if (result.status === "failed") {
+        return `Worktree ${name} could not be reclaimed: ${result.detail ?? "git error"}`;
+    }
+    if (result.status === "unmanaged") {
+        return `Worktree ${name} left in place: not a Hive-managed worktree`;
+    }
+    return undefined;
+}