@shanesaravia/hive 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to Hive will be documented in this file.
 
+## 0.5.0 — 2026-09-03
+
+Turns the composer's mention system into a full reference picker — files, directories, and other repositories alongside agents and skills — carries a pasted image as part of the message text itself, and settles a run of places where the fleet misattributed a worker, mis-scored a mission's status, or left a stale manager still holding a session.
+
+### Added
+
+- `@agent`, `/skill`, and Hive's own `/loop` now work in every composer (Quick Ask, the New Mission modal, and the conversation composer), not only the one they first shipped in.
+- A pasted or dropped image now becomes an inline `[Image #N]` placeholder in the message text itself — the same way Claude Code's own CLI handles a paste — rather than a separate attachment strip. Deleting the placeholder drops the image from what's sent; Backspace/Delete removes one whole placeholder rather than eating it character by character.
+- `@` completes files and directories under a mission's own working directory too, alongside agent mentions — reachable beyond the mission's own repository with a home-relative (`~/...`) or absolute path, one segment at a time with Tab, the way a shell completes a path.
+- A new `#` sigil completes repository names for describing work spanning more than one repository — siblings of the mission's repository and recently used ones, with the mission's own repository offered too and labeled "current repo" rather than hidden.
+
+### Fixed
+
+- A worker's identity could be claimed by the wrong manager when two orchestrators on one mission delegated a task under the same plan id or `--target` label.
+- An enriched internal prompt could appear as a second, duplicate user message.
+- `a`/`d` now act on the top item of an open "Needs You" queue without it needing to be selected first.
+- A reviewed orchestrated mission now returns to acceptance once follow-up work completes, instead of staying marked reviewed against stale work.
+- A previous Claude manager is now stopped once a resumed background job takes over, instead of leaving both able to act on one mission.
+- Read-only environment probes with useful output are classified as neutral diagnostic checks rather than errors.
+- Plan approval now shows only for missions actually launched with Plan First.
+- An orchestrator's own completion evidence is reconciled against equivalent user-created gates instead of showing duplicates.
+- Needs You acceptance is blocked while required gates remain unresolved.
+
 ## 0.4.0 — 2026-09-02
 
 Makes the conversation trustworthy to read, gives Hive loops it can actually turn off, and settles two places where a mission misreported what it was doing.

package/node_modules/@hive/shared/dist/types.d.ts

@@ -288,6 +288,14 @@ export declare const NATIVE_COMMANDS: NativeCommand[];
  * at risk of being run out-of-band by mistake.
  */
 export declare const BUILTIN_SKILLS: ClaudeSkillSummary[];
+/**
+ * The built-ins that already mean something before a mission exists, so a
+ * composer that starts one can offer them. `/loop` qualifies: the mission's
+ * opening turn is the loop's first pass and Hive keeps the schedule. `/tasks`
+ * and the native commands do not — they report on a session that is not
+ * running yet.
+ */
+export declare const MISSION_START_SKILLS: ClaudeSkillSummary[];
 /** One readable transcript belonging to a mission. */
 export interface TerminalCapability {
     /** Interactive writes target a live channel; follow_up starts/resumes a provider turn. */

package/node_modules/@hive/shared/dist/types.js

@@ -39,3 +39,11 @@ export const BUILTIN_SKILLS = [
         source: "built-in",
     },
 ];
+/**
+ * The built-ins that already mean something before a mission exists, so a
+ * composer that starts one can offer them. `/loop` qualifies: the mission's
+ * opening turn is the loop's first pass and Hive keeps the schedule. `/tasks`
+ * and the native commands do not — they report on a session that is not
+ * running yet.
+ */
+export const MISSION_START_SKILLS = BUILTIN_SKILLS.filter((skill) => skill.name === "loop");

package/package.json

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

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

@@ -6,20 +6,20 @@ import { allPlanTasks } from "../plans/plansStore.js";
 import { buildFleetSnapshot } from "../roster/rosterBuilder.js";
 import { orchestratorTranscriptPath, readTranscript, transcriptSources, workerTranscriptPath } from "../transcripts/transcriptReader.js";
 import { skillPromptEvents, toHiveEvent } from "../hooks/hookIngest.js";
-import { isWorkEvent, reopensOnWork } from "../missions/reopenOnWork.js";
+import { isWorkEvent, reopensOnWork, returnsToReviewOnStop } from "../missions/reopenOnWork.js";
 import { startOrchestrator } from "../control/launcher.js";
 import { matchNativeCommand, runNativeCommand } from "../control/nativeCommands.js";
 import { sendMessage } from "../control/messaging.js";
-import { jobsToQuiesce } from "../control/missionQuiesce.js";
+import { jobsToQuiesce, replacedManagerAfterResume } from "../control/missionQuiesce.js";
 import { parsePermissionAsk, permissionGrant } from "../control/permissionPark.js";
 import { forceStopSession, stopSession } from "../control/killer.js";
 import { discoverSkills } from "../skills/skillDiscovery.js";
 import { discoverAgents } from "../agents/agentDiscovery.js";
 import { AttachmentStore, isSupportedMediaType, MAX_ATTACHMENT_BYTES } from "../messages/attachmentStore.js";
-import { formatInterval, parseLoopCommand } from "../loops/loopCommand.js";
+import { formatInterval, parseLoopCommand, parseMissionStartLoop } from "../loops/loopCommand.js";
 import { activeMonitors } from "../loops/monitors.js";
 import { translateSkillInvocations } from "../skills/skillInvocation.js";
-import { detectRepositoryMentions, foreignRepositoryForPath, inspectWorkingDirectory, recentRepositories, requireWorkingDirectory, suggestDirectories } from "../paths/pathResolver.js";
+import { detectRepositoryMentions, foreignRepositoryForPath, inspectWorkingDirectory, recentRepositories, requireWorkingDirectory, suggestDirectories, suggestPathEntries, suggestRepositories } from "../paths/pathResolver.js";
 import { missionReport, reportMarkdown } from "../reports/missionReport.js";
 import { createTemplate, deleteTemplate, discoverTemplates, discoverTemplatesDetailed, updateTemplate } from "../templates/templateDiscovery.js";
 import { publishGitHubReport } from "../reports/githubPublisher.js";
@@ -113,13 +113,16 @@ export function planRevisionSummary(previous, next) {
  * Named paths rather than an opaque "see attachment": the agent has to be able
  * to open them, and an absolute path is the one instruction that works whether
  * the turn runs in the repository, a worktree, or somewhere else entirely.
+ * Each attachment's name is the same "[Image #N]" token the user sees inline
+ * in their own message text, so this list is a direct lookup from what they
+ * already typed to the file the agent needs to read.
  */
 export function promptWithAttachments(text, attached) {
     if (!attached.length)
         return text;
-    const list = attached.map((item) => `- ${item.path}`).join("\n");
+    const list = attached.map((item) => `- [${item.name}]: ${item.path}`).join("\n");
     const preamble = attached.length === 1 ? "The user attached an image" : `The user attached ${attached.length} images`;
-    return `${text ? `${text}\n\n` : ""}${preamble}. Read ${attached.length === 1 ? "it" : "them"} before replying:\n${list}`;
+    return `${text ? `${text}\n\n` : ""}${preamble}, referenced inline in the message above. Read ${attached.length === 1 ? "it" : "them"} before replying:\n${list}`;
 }
 /** Returns the mission send path, so the loop scheduler drives turns exactly as a person's message does. */
 export function registerRest(app, deps) {
@@ -220,6 +223,7 @@ export function registerRest(app, deps) {
             missionId,
             targetJobId,
         });
+        const stopped = [];
         for (const jobId of stopping) {
             const job = jobsWatcher.getAll().get(jobId);
             const sessionId = job?.sessionId ?? job?.resumeSessionId ?? jobId;
@@ -229,19 +233,38 @@ export function registerRest(app, deps) {
                     await codex.stop(jobId);
                 else
                     await stopSession(jobId);
+                stopped.push(jobId);
                 events.add({ ts: Date.now(), sessionId, jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: superseded ? `Stopped superseded manager ${jobId.slice(0, 8)} before resuming: only one job may act on a mission.` : `Ended the parked turn on ${jobId.slice(0, 8)} so this message continues the conversation instead of branching it.` });
             }
             catch (error) {
                 events.add({ ts: Date.now(), sessionId, jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Could not stop ${superseded ? "superseded" : "parked"} manager ${jobId.slice(0, 8)}: ${error.message}` });
             }
         }
+        return stopped;
+    }
+    async function resumeClaude(previousJobId, sessionId, prompt, policy, additionalRepos) {
+        const result = await sendMessage(sessionId, prompt, policy, additionalRepos);
+        const replaced = replacedManagerAfterResume(previousJobId, result.jobId);
+        if (replaced) {
+            try {
+                await stopSession(replaced);
+                events.add({ ts: Date.now(), sessionId, jobId: replaced, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Retired manager ${replaced.slice(0, 8)} after resumed job ${result.jobId.slice(0, 8)} took over` });
+            }
+            catch (error) {
+                // The continuation is already live. Preserve it and make cleanup
+                // failure visible rather than turning a successful send into an error
+                // that invites the user to retry and create yet another manager.
+                events.add({ ts: Date.now(), sessionId, jobId: replaced, source: "custom", phase: "custom", activityKind: "lifecycle", outcome: "failure", detail: `Could not retire replaced manager ${replaced.slice(0, 8)}: ${error.message}` });
+            }
+        }
+        return result;
     }
     async function sendToMission(missionId, text) {
         return withMissionQueue(missionId, async () => {
             const target = latestMissionTarget(missionId);
             if (!target)
                 throw new Error("mission not found");
-            await quiesceMission(missionId, target.jobId);
+            const quiesced = await quiesceMission(missionId, target.jobId);
             const summary = missions.summaryFor(missionId);
             const policy = summary.policy ?? policies.get();
             const provider = summary.provider ?? "claude";
@@ -276,7 +299,7 @@ export function registerRest(app, deps) {
             try {
                 result = provider === "codex"
                     ? await codex.start({ task: prompt, cwd: repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
-                    : await sendMessage(target.sessionId, prompt, policy, additionalRepos);
+                    : await resumeClaude(quiesced.includes(target.jobId) ? undefined : target.jobId, target.sessionId, prompt, policy, additionalRepos);
             }
             catch (error) {
                 if (reopening)
@@ -571,6 +594,17 @@ export function registerRest(app, deps) {
             events.add(promptEvent);
         if (jobId)
             reopenIfWorking(event, jobId);
+        if (jobId && event.hookEventName === "Stop") {
+            const missionId = missions.missionFor(jobId);
+            const mission = missions.get(missionId);
+            const pendingDecision = events.recentFor(event.sessionId).some((candidate) => candidate.jobId === jobId && candidate.phase === "blocked_on_user" && candidate.ts <= event.ts);
+            if (mission && returnsToReviewOnStop(mission, pendingDecision)) {
+                const finalMessage = typeof req.body.last_assistant_message === "string" ? req.body.last_assistant_message : undefined;
+                missions.setLifecycleStatus(missionId, "ready_for_review");
+                missions.updateContext(missionId, { compactSummary: finalMessage?.slice(0, 1_200), currentState: "Awaiting user acceptance" });
+                events.add({ ts: Date.now(), sessionId: event.sessionId, jobId, source: "custom", phase: "ready_for_review", activityKind: "lifecycle", detail: "Follow-up work finished and returned to user acceptance" });
+            }
+        }
         // A write landing in another known repo marks that repo as touched by
         // the mission, so its footprint chips reflect reality, not just intent.
         if (event.activityKind === "file_write" && event.filePath && jobId) {
@@ -671,7 +705,7 @@ export function registerRest(app, deps) {
                 // One emit may name several workers (`--target a,b,c`); the task moves for each.
                 const targets = targetWorker && /[,;]/.test(targetWorker) ? [...new Set(targetWorker.split(/[,;]/).map((value) => value.trim()).filter(Boolean))] : [targetWorker];
                 for (const target of targets) {
-                    const canonicalWorker = workerIdentity.canonicalFor(missionId, target);
+                    const canonicalWorker = workerIdentity.canonicalFor(missionId, target, effectiveJobId);
                     try {
                         plans.applyTaskEvent(missionId, { phase, targetTask, targetWorker: target, canonicalWorker, evidence: phase === "worker_reported" ? detail : undefined });
                     }
@@ -820,12 +854,32 @@ Revise the structured plan to remove that requirement and stop work that was nee
             return { error: err.message };
         }
     });
-    app.post("/api/orchestrator/start", async (req, reply) => {
+    app.post("/api/orchestrator/start", { bodyLimit: Math.ceil(MAX_ATTACHMENT_BYTES * 1.4 * 8) }, async (req, reply) => {
         const { task, name, cwd, templateId } = req.body;
         if (!task) {
             reply.code(400);
             return { error: "task is required" };
         }
+        const pendingAttachments = req.body.attachments ?? [];
+        for (const item of pendingAttachments) {
+            if (!isSupportedMediaType(item.mediaType)) {
+                reply.code(415);
+                return { error: `unsupported image type: ${item.mediaType || "none given"}` };
+            }
+            if (!item.data) {
+                reply.code(400);
+                return { error: "attachment data is required" };
+            }
+        }
+        // `/loop …` is Hive's wherever it is typed, not only in a conversation.
+        // Handed to the CLI as a task it would run as the agent's own loop, which
+        // Hive cannot list or stop — the failure this feature exists to prevent.
+        const start = parseMissionStartLoop(task);
+        if ("error" in start) {
+            reply.code(400);
+            return { error: start.error };
+        }
+        const missionTask = start.prompt;
         try {
             const template = templateId ? discoverTemplates(cwd).find((item) => item.id === templateId) : undefined;
             if (templateId && !template) {
@@ -855,17 +909,23 @@ Revise the structured plan to remove that requirement and stop work that was nee
             const provider = req.body.provider ?? "claude";
             const model = req.body.model?.trim() || undefined;
             const planFirst = mode === "orchestrated" && req.body.planFirst === true;
-            const additionalRepos = detectRepositoryMentions(task, resolvedCwd);
+            const additionalRepos = detectRepositoryMentions(missionTask, resolvedCwd);
             const repoPrompt = additionalRepos.length ? `\n\n(Hive: you also have tool access to these repositories: ${additionalRepos.join(", ")})` : "";
             const planFirstPrompt = planFirst ? `\n\nHive Plan First checkpoint (mandatory): Before editing files, running implementation commands, or spawning/delegating to any workers, investigate only enough to propose a concrete structured plan. Publish that plan with every task and phase still queued and approvalStatus \"proposed\". Then emit blocked_on_user with decision id \"plan-approval\", kind \"scope\", and question \"Approve the proposed plan before implementation begins?\" Stop the turn after emitting it. Do not begin implementation until Hive resumes you with explicit plan approval. If changes are requested, revise and republish the queued plan, emit the same plan-approval decision again, and stop.` : "";
-            const providerTask = translateSkillInvocations(task, provider, new Set(discoverSkills(resolvedCwd, provider).map((skill) => skill.name)));
-            const prompt = providerTask + templatePrompt + limits + policyPrompt + repoPrompt + planFirstPrompt;
+            const providerTask = translateSkillInvocations(missionTask, provider, new Set(discoverSkills(resolvedCwd, provider).map((skill) => skill.name)));
+            // Generated ahead of `missions.create` so pasted images can be filed
+            // under the mission's id before the mission record itself exists.
+            const missionId = randomUUID();
+            const attached = pendingAttachments.map((item) => attachments.save(missionId, { name: item.name, mediaType: item.mediaType, data: Buffer.from(item.data, "base64") }));
+            const taskWithAttachments = promptWithAttachments(providerTask, attached);
+            const prompt = taskWithAttachments + templatePrompt + limits + policyPrompt + repoPrompt + planFirstPrompt;
             const result = provider === "codex"
                 ? await codex.start({ task: prompt, cwd: resolvedCwd, name, model, mode, policy })
                 : await startOrchestrator({ task: prompt, worktree, name, cwd: resolvedCwd, mode, policy, model, addDirs: additionalRepos });
             const mission = missions.create({
+                id: missionId,
                 name,
-                objective: task,
+                objective: missionTask,
                 repository: result.cwd,
                 jobId: result.jobId,
                 sessionId: result.sessionId,
@@ -885,10 +945,24 @@ Revise the structured plan to remove that requirement and stop work that was nee
                 text: task,
                 createdAt: Date.now(),
                 jobId: result.jobId,
+                ...(attached.length ? { attachments: attached } : {}),
             });
+            // The opening turn is the loop's first pass, so the schedule starts one
+            // interval out — exactly what `loops.create` does.
+            const loop = start.loop ? loops.create({ missionId: mission.id, ...start.loop }) : undefined;
+            if (loop) {
+                messages.add({
+                    id: `${result.jobId}:loop`,
+                    missionId: mission.id,
+                    role: "assistant",
+                    text: `Looping every ${formatInterval(loop.intervalMs)}: ${loop.prompt}\n\nThis first pass is running now; the next is at ${new Date(loop.nextRunAt).toLocaleTimeString()}. Stop it with \`/loop stop ${loop.id}\`, or from the Tasks panel.`,
+                    createdAt: Date.now() + 1,
+                    jobId: result.jobId,
+                });
+            }
             if (template)
                 plans.replace(mission.id, { phases: [{ id: "template", title: template.name, description: template.description, status: "queued", acceptanceCriteria: template.gates.map((gate) => gate.label), dependsOn: [], tasks: template.stages.map((stage, index) => ({ id: stage.id, title: stage.title, role: stage.role, status: "queued", weight: 1, dependsOn: stage.dependsOn ?? (index ? [template.stages[index - 1].id] : []), evidence: [] })) }], gates: template.gates.map((gate) => ({ ...gate, source: "template" })) });
-            return { ...result, missionId: mission.id };
+            return { ...result, missionId: mission.id, ...(loop ? { loopId: loop.id } : {}) };
         }
         catch (err) {
             reply.code(400);
@@ -1016,6 +1090,22 @@ Revise the structured plan to remove that requirement and stop work that was nee
         directories: req.body?.input?.trim() ? suggestDirectories(req.body.input) : recentRepositories(),
     }));
     app.post("/api/paths/inspect", async (req) => inspectWorkingDirectory(req.body?.input));
+    // Live "@path" completion in a composer: files and directories under a
+    // mission's own working directory, matching what's typed after the `@`.
+    app.post("/api/paths/suggest-entries", async (req, reply) => {
+        try {
+            const cwd = requireWorkingDirectory(req.body?.cwd);
+            return { entries: suggestPathEntries(cwd, req.body?.query ?? "") };
+        }
+        catch (err) {
+            reply.code(400);
+            return { error: err.message };
+        }
+    });
+    // Live "#repo" completion: sibling and recently used repositories matching what's typed after the `#`.
+    app.post("/api/repositories/suggest", async (req) => ({
+        repositories: suggestRepositories(req.body?.cwd, req.body?.query ?? ""),
+    }));
     app.post("/api/session/:pid/message", async (req, reply) => {
         const pid = Number(req.params.pid);
         const session = sessionsWatcher.getAll().get(pid);
@@ -1033,9 +1123,8 @@ Revise the structured plan to remove that requirement and stop work that was nee
         // Messaging a session that belongs to a mission is the same fork as
         // messaging the mission, through a second door. Only a session Hive does
         // not manage as a mission is resumed without quiescing.
-        if (missions.get(missionId))
-            await quiesceMission(missionId, session.jobId);
-        const result = await sendMessage(session.sessionId, req.body.text);
+        const quiesced = missions.get(missionId) ? await quiesceMission(missionId, session.jobId) : [];
+        const result = await resumeClaude(quiesced.includes(session.jobId ?? "") ? undefined : session.jobId, session.sessionId, req.body.text);
         missions.linkJob(missionId, result.jobId, result.sessionId);
         messages.add({
             id: `${result.jobId}:user`,
@@ -1208,14 +1297,14 @@ Revise the structured plan to remove that requirement and stop work that was nee
             try {
                 // Ends the parked turn, and any other manager still live on the
                 // mission with it — the verdict below resumes one conversation.
-                await quiesceMission(req.params.missionId, jobId);
+                const quiesced = await quiesceMission(req.params.missionId, jobId);
                 const summary = missions.summaryFor(req.params.missionId);
                 const policy = summary.policy ?? policies.get();
                 const grant = approved ? permissionGrant(job.needs) : undefined;
                 const text = approved
                     ? `Your permission request (${askLabel}) is approved and now pre-allowed. Re-run it and continue where you left off.`
                     : `Your permission request (${askLabel}) was denied${/^deny$/i.test(answer) ? "" : ` — ${answer}`}. Continue without it or propose an alternative.`;
-                const result = await sendMessage(sessionId, text, grant ? { ...policy, allowedTools: [...policy.allowedTools, grant] } : policy);
+                const result = await resumeClaude(quiesced.includes(jobId) ? undefined : jobId, sessionId, text, grant ? { ...policy, allowedTools: [...policy.allowedTools, grant] } : policy);
                 missions.linkJob(req.params.missionId, result.jobId, result.sessionId);
                 messages.add({ id: `${result.jobId}:user`, missionId: req.params.missionId, role: "user", text, createdAt: Date.now(), jobId: result.jobId });
                 events.add({ ts: Date.now(), sessionId, jobId: result.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: answer, decisionId: req.params.decisionId });

package/packages/server/dist/control/missionQuiesce.js

@@ -64,3 +64,7 @@ export function jobsToQuiesce(input) {
     }
     return stop;
 }
+/** The old Claude background job is replaced, not continued, by `--resume --bg`. */
+export function replacedManagerAfterResume(previousJobId, nextJobId) {
+    return previousJobId && previousJobId !== nextJobId ? previousJobId : undefined;
+}

package/packages/server/dist/loops/loopCommand.js

@@ -54,3 +54,23 @@ export function parseLoopCommand(text) {
     }
     return { kind: "start", intervalMs, prompt };
 }
+/**
+ * `/loop …` typed where a mission is *started* rather than into one that is
+ * already running.
+ *
+ * The mission runs the loop's own prompt — its opening turn is the first pass
+ * — and Hive keeps the schedule around it. Listing or stopping needs a mission
+ * to act on, so those are refused here rather than silently starting one whose
+ * objective is the word "list".
+ */
+export function parseMissionStartLoop(task) {
+    const command = parseLoopCommand(task);
+    if (!command)
+        return { prompt: task };
+    if (command.kind === "error")
+        return { error: command.message };
+    if (command.kind !== "start") {
+        return { error: "A loop can only be listed or stopped from a mission that is already running — its conversation, or the Tasks panel." };
+    }
+    return { prompt: command.prompt, loop: { intervalMs: command.intervalMs, prompt: command.prompt } };
+}

package/packages/server/dist/messages/messagesStore.js

@@ -95,13 +95,37 @@ export class MessagesStore {
             ...(input.kind ? { kind: input.kind } : {}),
             ...(input.attachments?.length ? { attachments: input.attachments } : {}),
         };
-        // Callers key on the job (`<jobId>:user`), so a retried turn can collide
-        // with a message already on screen. Append rather than rewrite it, and
-        // report the id the text actually landed under.
-        const id = this.appendSynced({ ...message, missionId: input.missionId, jobId: input.jobId || "" });
+        // The job watcher can observe a newly launched turn before its request
+        // route returns. In that window syncJobs inserts the provider's enriched
+        // intent (policy, repository grants, etc.) under `<jobId>:user`. The route
+        // write is authoritative for what the person actually typed, so replace
+        // that internal prompt instead of appending a second user bubble.
+        const canonicalUserId = input.id === `${input.jobId}:user` && input.role === "user";
+        const id = canonicalUserId
+            ? this.replaceCanonicalUserMessage({ ...message, missionId: input.missionId, jobId: input.jobId || "" })
+            : this.appendSynced({ ...message, missionId: input.missionId, jobId: input.jobId || "" });
         this.notify();
         return { ...message, id };
     }
+    replaceCanonicalUserMessage(message) {
+        this.db.transaction(() => {
+            // Older builds could already have appended the authoritative text under
+            // a content-suffixed id. Collapse any such race artifacts for this turn.
+            this.db.prepare("DELETE FROM mission_messages WHERE id LIKE ? AND id <> ?").run(`${message.id}:%`, message.id);
+            this.db.prepare(`
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind, attachments, noop)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind, @attachments, @noop)
+        ON CONFLICT(id) DO UPDATE SET
+          mission_id = excluded.mission_id,
+          role = excluded.role,
+          text = excluded.text,
+          job_id = excluded.job_id,
+          kind = excluded.kind,
+          attachments = excluded.attachments
+      `).run({ ...message, kind: message.kind ?? null, attachments: message.attachments?.length ? JSON.stringify(message.attachments) : null, noop: message.noop ? 1 : null });
+        })();
+        return message.id;
+    }
     page(missionId, options = {}) {
         const limit = Math.min(Math.max(options.limit ?? DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE);
         const rows = this.db

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

@@ -74,7 +74,7 @@ export class MissionsStore {
         return groups.length;
     }
     create(input) {
-        const id = randomUUID();
+        const id = input.id ?? randomUUID();
         const now = Date.now();
         const mission = {
             id,

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

@@ -18,3 +18,10 @@ export function isWorkEvent(event) {
 export function reopensOnWork(status) {
     return status === "ready_for_review";
 }
+/** A completed follow-up returns work to the review state it came from. */
+export function returnsToReviewOnStop(mission, hasPendingDecision) {
+    return mission.lifecycleStatus === "active"
+        && mission.mode === "orchestrated"
+        && mission.currentState === "Working again after a follow-up"
+        && !hasPendingDecision;
+}

package/packages/server/dist/paths/pathResolver.js

@@ -67,6 +67,101 @@ export function suggestDirectories(input) {
 function stripWorktree(value) {
     return value.split(`${path.sep}.claude${path.sep}worktrees${path.sep}`)[0];
 }
+/** Directory entries at `base` matching `prefix`, formatted by the caller and capped for a completion list. */
+function listMatchingEntries(base, prefix, format) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true })
+            .filter((entry) => !entry.name.startsWith(".") && entry.name.toLowerCase().startsWith(prefix))
+            .map((entry) => ({ path: format(entry.name, path.join(base, entry.name)), isDirectory: entry.isDirectory() }));
+    }
+    catch { /* an incomplete path simply has no suggestions yet */ }
+    return entries.sort((a, b) => Number(b.isDirectory) - Number(a.isDirectory) || a.path.localeCompare(b.path)).slice(0, 20);
+}
+/** "src/App.t" style — resolved under the mission's own cwd, and never escapes it. */
+function suggestRelativePathEntries(cwd, trimmed) {
+    const slash = trimmed.lastIndexOf("/");
+    const dirPart = slash === -1 ? "" : trimmed.slice(0, slash);
+    const prefix = (slash === -1 ? trimmed : trimmed.slice(slash + 1)).toLowerCase();
+    const root = path.resolve(cwd);
+    const base = path.resolve(root, dirPart);
+    if (base !== root && !base.startsWith(`${root}${path.sep}`))
+        return [];
+    return listMatchingEntries(base, prefix, (name) => (dirPart ? `${dirPart}/${name}` : name));
+}
+/** "~/Development/other-repo/" or "/abs/path" style — browses anywhere on disk, spelled back the way it was typed. */
+function suggestRootedPathEntries(trimmed) {
+    const expanded = resolveWorkingDirectory(trimmed);
+    const listChildren = trimmed.endsWith("/") || trimmed === "~";
+    const base = listChildren ? expanded : path.dirname(expanded);
+    const prefix = listChildren ? "" : path.basename(expanded).toLowerCase();
+    const home = os.homedir();
+    return listMatchingEntries(base, prefix, (_name, full) => (trimmed.startsWith("~") && (full === home || full.startsWith(`${home}${path.sep}`))
+        ? `~/${path.relative(home, full)}`
+        : full).split(path.sep).join("/"));
+}
+/**
+ * Files and directories matching `query` — the data behind live "@path"
+ * completion in a composer. A plain query ("packages/web/s") is resolved
+ * under the mission's own `cwd` and cannot escape it; a query that already
+ * names a home- or filesystem-rooted path ("~/Development/other-repo/",
+ * "/abs/path") browses from there instead, so `@` can also reach a sibling
+ * repository directly rather than only what `#` already covers by name.
+ */
+export function suggestPathEntries(cwd, query) {
+    const trimmed = query.replace(/^\.\//, "");
+    return trimmed.startsWith("~") || trimmed.startsWith("/")
+        ? suggestRootedPathEntries(trimmed)
+        : suggestRelativePathEntries(cwd, trimmed);
+}
+/** Every git repository under `roots`, unranked — a name search must see all of them, not just the recently touched ones. */
+function discoverRepositories(roots) {
+    const candidates = new Set();
+    for (const root of roots) {
+        try {
+            const topLevel = git(root, "rev-parse", "--show-toplevel");
+            if (topLevel)
+                candidates.add(topLevel);
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith("."))
+                    continue;
+                const candidate = path.join(root, entry.name);
+                if (fs.existsSync(path.join(candidate, ".git")))
+                    candidates.add(candidate);
+            }
+        }
+        catch { /* unavailable discovery root */ }
+    }
+    return [...candidates];
+}
+/** Every repository name Hive can resolve, mapped to its absolute path — siblings first, then recently used ones. */
+function repositoryRegistry(baseRepository) {
+    const registry = new Map();
+    for (const repo of knownRepositories(baseRepository))
+        registry.set(repo.name, repo.path);
+    for (const resolvedPath of discoverRepositories([defaultWorkingDirectory(), path.join(os.homedir(), "Development")])) {
+        const name = path.basename(resolvedPath).toLowerCase();
+        if (!registry.has(name))
+            registry.set(name, resolvedPath);
+    }
+    return registry;
+}
+/**
+ * Repository names starting with `query`, for live "#repo" completion. The
+ * mission's own repository is included rather than hidden — a message can
+ * legitimately name it too (e.g. describing work that spans several repos)
+ * — but flagged as `isCurrent` so the composer can mark it and a reader
+ * isn't left assuming a mention always points somewhere else.
+ */
+export function suggestRepositories(cwd, query) {
+    const lower = query.trim().toLowerCase();
+    const own = cwd ? path.basename(stripWorktree(cwd)).toLowerCase() : undefined;
+    return [...repositoryRegistry(cwd)]
+        .filter(([name]) => name.startsWith(lower))
+        .sort(([a], [b]) => a.localeCompare(b))
+        .slice(0, 10)
+        .map(([name, repoPath]) => ({ name, path: repoPath, isCurrent: name === own }));
+}
 /** Git repositories that sit beside the mission's repo (and the Hive default). */
 export function knownRepositories(baseRepository) {
     const roots = new Set();
@@ -92,13 +187,24 @@ export function knownRepositories(baseRepository) {
  * Repositories a message refers to by name ("add this to monorepo"), so a
  * mission can be granted cross-repo access without any explicit form field.
  * The mission's own repository never counts as a mention.
+ *
+ * An explicit "#name" mention (the composer's own autocomplete syntax) is
+ * resolved against the full repository registry — siblings and recently
+ * used repositories both — while the implicit bare-word heuristic stays
+ * scoped to siblings only, exactly as it always has, so existing behavior
+ * is unaffected by adding the explicit form alongside it.
  */
 export function detectRepositoryMentions(text, ownRepository) {
     const own = ownRepository ? path.basename(stripWorktree(ownRepository)).toLowerCase() : undefined;
     const lower = text.toLowerCase();
-    return knownRepositories(ownRepository)
+    const implicit = knownRepositories(ownRepository)
         .filter(({ name }) => name !== own && new RegExp(`(?<![\\w-])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`).test(lower))
         .map((repo) => repo.path);
+    const explicitNames = new Set([...text.matchAll(/#([\w.-]+)/g)].map((match) => match[1].toLowerCase()));
+    const explicit = explicitNames.size
+        ? [...repositoryRegistry(ownRepository)].filter(([name]) => name !== own && explicitNames.has(name)).map(([, repoPath]) => repoPath)
+        : [];
+    return [...new Set([...implicit, ...explicit])];
 }
 /**
  * The known repository containing filePath, excluding the mission's own repo
@@ -144,24 +250,13 @@ export function inspectWorkingDirectory(input) {
 }
 export function recentRepositories(limit = 8) {
     const roots = [defaultWorkingDirectory(), path.join(os.homedir(), "Development")];
-    const candidates = new Set();
-    for (const root of roots) {
-        try {
-            if (git(root, "rev-parse", "--show-toplevel"))
-                candidates.add(git(root, "rev-parse", "--show-toplevel"));
-            for (const entry of fs.readdirSync(root, { withFileTypes: true }))
-                if (entry.isDirectory() && !entry.name.startsWith(".")) {
-                    const candidate = path.join(root, entry.name);
-                    if (fs.existsSync(path.join(candidate, ".git")))
-                        candidates.add(candidate);
-                }
-        }
-        catch { /* unavailable discovery root */ }
-    }
-    return [...candidates].sort((a, b) => { try {
+    return discoverRepositories(roots)
+        .sort((a, b) => { try {
         return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
     }
     catch {
         return 0;
-    } }).slice(0, limit).map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
+    } })
+        .slice(0, limit)
+        .map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
 }