@shanesaravia/hive 0.1.1 → 0.2.1

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

@@ -1,20 +1,24 @@
 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";
 import { buildFleetSnapshot } from "../roster/rosterBuilder.js";
-import { toHiveEvent } from "../hooks/hookIngest.js";
+import { skillPromptEvents, toHiveEvent } from "../hooks/hookIngest.js";
 import { startOrchestrator } from "../control/launcher.js";
 import { matchNativeCommand, runNativeCommand } from "../control/nativeCommands.js";
 import { sendMessage } from "../control/messaging.js";
 import { parsePermissionAsk, permissionGrant } from "../control/permissionPark.js";
 import { forceStopSession, stopSession } from "../control/killer.js";
 import { discoverSkills } from "../skills/skillDiscovery.js";
+import { translateSkillInvocations } from "../skills/skillInvocation.js";
 import { detectRepositoryMentions, foreignRepositoryForPath, inspectWorkingDirectory, recentRepositories, requireWorkingDirectory, suggestDirectories } 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";
 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();
@@ -25,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);
@@ -45,27 +90,64 @@ export function registerRest(app, deps) {
                 throw new Error("mission not found");
             const summary = missions.summaryFor(missionId);
             const policy = summary.policy ?? policies.get();
+            const provider = summary.provider ?? "claude";
+            const providerText = translateSkillInvocations(text, provider, new Set(discoverSkills(summary.repository, provider).map((skill) => skill.name)));
             // "add this to monorepo" should just work: repos mentioned by name get
             // --add-dir access, persisted so every later turn keeps the grant.
-            const mentioned = detectRepositoryMentions(text, summary.repository);
+            const mentioned = detectRepositoryMentions(providerText, summary.repository);
             const additionalRepos = [...new Set([...(summary.additionalRepositories ?? []), ...mentioned])];
             if (mentioned.length)
                 missions.addRepositories(missionId, mentioned);
-            const prompt = additionalRepos.length ? `${text}\n\n(Hive: you also have tool access to these repositories: ${additionalRepos.join(", ")})` : text;
-            const result = summary.provider === "codex"
-                ? await codex.start({ task: prompt, cwd: summary.repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
-                : await sendMessage(target.sessionId, prompt, policy, additionalRepos);
+            const prompt = additionalRepos.length ? `${providerText}\n\n(Hive: you also have tool access to these repositories: ${additionalRepos.join(", ")})` : providerText;
+            // Move the manager out of the shared review hall before asking the
+            // provider to resume. Fast subagents can start and finish while the CLI
+            // launch call is still pending; reopening afterward leaves their FIFO
+            // stories assigned to a room with no worker desks.
+            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: repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
+                    : await sendMessage(target.sessionId, prompt, policy, additionalRepos);
+            }
+            catch (error) {
+                if (reopening)
+                    missions.setLifecycleStatus(missionId, summary.lifecycleStatus);
+                throw error;
+            }
             missions.linkJob(missionId, result.jobId, result.sessionId);
             messages.add({ id: `${result.jobId}:user`, missionId, role: "user", text, createdAt: Date.now(), jobId: result.jobId });
             // A follow-up to a closed mission is an implicit reopen — work resumed.
-            if (["completed", "archived", "failed", "paused"].includes(summary.lifecycleStatus)) {
-                missions.setLifecycleStatus(missionId, "active");
+            if (reopening) {
                 events.add({ ts: Date.now(), sessionId: result.sessionId ?? target.sessionId, jobId: result.jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission reopened from ${summary.lifecycleStatus} by a new message` });
             }
             return result;
         });
     }
     app.get("/api/fleet", async () => buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans));
+    app.post("/api/direct-studio/clear-completed", async () => {
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
+        const eligible = snapshot.orchestrators.filter(canClearDirectStudioMission);
+        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 };
+    });
     app.get("/api/policies", async () => ({ policy: policies.get() }));
     app.get("/api/providers/models", async () => ({ providers: detectProviderModels() }));
     app.put("/api/policies", async (req, reply) => {
@@ -172,6 +254,8 @@ export function registerRest(app, deps) {
         const jobId = sessionForId(sessionsWatcher, payload.session_id)?.jobId;
         const event = toHiveEvent(payload, jobId);
         events.add(event);
+        for (const promptEvent of skillPromptEvents(payload, jobId))
+            events.add(promptEvent);
         // 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) {
@@ -303,6 +387,70 @@ export function registerRest(app, deps) {
             return { error: err.message };
         }
     });
+    app.post("/api/mission/:missionId/gate", async (req, reply) => {
+        if (!missions.get(req.params.missionId)) {
+            reply.code(404);
+            return { error: "mission not found" };
+        }
+        try {
+            const plan = plans.addUserGate(req.params.missionId, req.body);
+            const gate = plan.gates.find((item) => item.source === "user" && item.label === req.body.label && item.type === req.body.type);
+            let notified = true;
+            try {
+                await sendToMission(req.params.missionId, `[Hive completion gate update]
+A ${gate.required ? "required" : "optional"} ${gate.type.replaceAll("_", " ")} gate was added by the user: “${gate.label}”.
+Update the structured plan to include this durable requirement. Continue or delegate any work needed to satisfy it, publish concrete evidence when complete, and do not remove or weaken this user-created gate.`);
+            }
+            catch {
+                notified = false;
+            }
+            return { plan, notified };
+        }
+        catch (err) {
+            reply.code(400);
+            return { error: err.message };
+        }
+    });
+    app.put("/api/mission/:missionId/gate/:gateId", async (req, reply) => {
+        try {
+            const plan = plans.updateUserGate(req.params.missionId, req.params.gateId, req.body);
+            const gate = plan.gates.find((item) => item.id === req.params.gateId);
+            let notified = true;
+            try {
+                await sendToMission(req.params.missionId, `[Hive completion gate update]
+The user changed a durable completion gate. It is now a ${gate.required ? "required" : "optional"} ${gate.type.replaceAll("_", " ")} gate: “${gate.label}”.
+Revise the structured plan immediately, reconcile existing work against this requirement, and continue or delegate the work needed to satisfy it with concrete evidence.`);
+            }
+            catch {
+                notified = false;
+            }
+            return { plan, notified };
+        }
+        catch (err) {
+            reply.code(400);
+            return { error: err.message };
+        }
+    });
+    app.delete("/api/mission/:missionId/gate/:gateId", async (req, reply) => {
+        try {
+            const previous = plans.get(req.params.missionId)?.gates.find((item) => item.id === req.params.gateId);
+            const plan = plans.removeUserGate(req.params.missionId, req.params.gateId);
+            let notified = true;
+            try {
+                await sendToMission(req.params.missionId, `[Hive completion gate update]
+The user removed the completion gate “${previous?.label ?? req.params.gateId}”.
+Revise the structured plan to remove that requirement and stop work that was needed only for that gate. Preserve all other user-created gates.`);
+            }
+            catch {
+                notified = false;
+            }
+            return { plan, notified };
+        }
+        catch (err) {
+            reply.code(400);
+            return { error: err.message };
+        }
+    });
     app.post("/api/mission/:missionId/plan/approval", async (req, reply) => {
         if (req.body?.status !== "approved" && req.body?.status !== "rejected") {
             reply.code(400);
@@ -313,9 +461,20 @@ export function registerRest(app, deps) {
             const target = latestMissionTarget(req.params.missionId);
             if (target)
                 events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "decision", detail: req.body.status === "approved" ? `Plan revision ${plan.revision - 1} approved` : `Plan rejected: ${plan.approvalReason}` });
-            if (req.body.status === "rejected") {
+            if (req.body.status === "approved") {
+                try {
+                    const result = await sendToMission(req.params.missionId, `The proposed plan is approved. Begin implementation now, following the approved plan. You may spawn and delegate to workers as appropriate. Keep the structured plan current and attach concrete evidence as work completes.`);
+                    const missionEvents = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === req.params.missionId).flatMap(([, job]) => [job.sessionId, job.resumeSessionId].filter((value) => Boolean(value))).flatMap((sessionId) => events.recentFor(sessionId, 200));
+                    const resolved = new Set(missionEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
+                    for (const pending of missionEvents.filter((event) => event.phase === "blocked_on_user" && event.decisionId && !resolved.has(event.decisionId) && (event.decisionId === "plan-approval" || /approve the proposed plan/i.test(event.detail)))) {
+                        events.add({ ts: Date.now(), sessionId: result.sessionId ?? pending.sessionId, jobId: result.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: "Plan approved", decisionId: pending.decisionId });
+                    }
+                }
+                catch { /* approval remains recorded even when no live job can resume */ }
+            }
+            else {
                 try {
-                    await sendToMission(req.params.missionId, `The current plan was rejected. Revise it before continuing. Feedback: ${plan.approvalReason}`);
+                    await sendToMission(req.params.missionId, `The current plan was rejected. Do not begin implementation. Revise and republish the plan with every task still queued, then stop again for approval. Feedback: ${plan.approvalReason}`);
                 }
                 catch { /* rejection remains recorded even when no live job can resume */ }
             }
@@ -360,9 +519,12 @@ export function registerRest(app, deps) {
             const policyPrompt = `\n\nHive permission policy: ${JSON.stringify(policy)}. These are hard boundaries where enforced by CLI tool restrictions. Before any action outside the policy, stop and emit blocked_on_user with the exact access needed; do not attempt to bypass the restriction.`;
             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 repoPrompt = additionalRepos.length ? `\n\n(Hive: you also have tool access to these repositories: ${additionalRepos.join(", ")})` : "";
-            const prompt = task + templatePrompt + limits + policyPrompt + repoPrompt;
+            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 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 });
@@ -378,6 +540,7 @@ export function registerRest(app, deps) {
                 policy,
                 provider,
                 model,
+                planFirst,
                 additionalRepositories: additionalRepos,
             });
             messages.add({
@@ -389,7 +552,7 @@ export function registerRest(app, deps) {
                 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 });
+                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 };
         }
         catch (err) {
@@ -399,7 +562,7 @@ export function registerRest(app, deps) {
     });
     app.post("/api/skills/discover", async (req, reply) => {
         try {
-            return { skills: discoverSkills(req.body?.cwd) };
+            return { skills: discoverSkills(req.body?.cwd, req.body?.provider === "codex" ? "codex" : "claude") };
         }
         catch (err) {
             reply.code(400);
@@ -507,6 +670,22 @@ export function registerRest(app, deps) {
             reply.code(404);
             return { error: "mission not found" };
         }
+        if (req.params.decisionId === "plan-approval") {
+            const approved = /^(approve|approved|begin|proceed|yes)/i.test(answer);
+            try {
+                plans.setApproval(req.params.missionId, approved ? "approved" : "rejected", approved ? undefined : answer);
+                const result = await sendToMission(req.params.missionId, approved
+                    ? "The proposed plan is approved. Begin implementation now, delegate to workers as appropriate, and keep the structured plan current with concrete evidence."
+                    : `The proposed plan is not approved. Do not begin implementation. Revise and republish it with all work still queued, then stop again for approval. Feedback: ${answer}`);
+                if (approved)
+                    events.add({ ts: Date.now(), sessionId: result.sessionId ?? latestMissionTarget(req.params.missionId)?.sessionId ?? "plan-approval", jobId: result.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: "Plan approved", decisionId: req.params.decisionId });
+                return { ok: true };
+            }
+            catch (err) {
+                reply.code(409);
+                return { error: err.message };
+            }
+        }
         // Parked permission prompts (decision id perm:<jobId>): a background
         // session cannot answer its own prompt, so end the parked turn and
         // resume the conversation with the verdict — pre-allowing the asked
@@ -545,6 +724,23 @@ export function registerRest(app, deps) {
                 return { error: err.message };
             }
         }
+        if (req.params.decisionId.startsWith("prompt:")) {
+            const jobId = req.params.decisionId.slice(7);
+            const job = jobsWatcher.getAll().get(jobId);
+            if (!job || job.tempo !== "blocked" || !job.needs) {
+                reply.code(409);
+                return { error: "provider prompt is no longer pending" };
+            }
+            try {
+                const result = await sendToMission(req.params.missionId, `Answer to the skill's pending question (${job.needs}): ${answer}\n\nContinue the skill from the point where it requested this input.`);
+                events.add({ ts: Date.now(), sessionId: result.sessionId ?? job.sessionId ?? jobId, jobId: result.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: answer, decisionId: req.params.decisionId });
+                return { ok: true };
+            }
+            catch (err) {
+                reply.code(500);
+                return { error: err.message };
+            }
+        }
         const nodeEvents = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === req.params.missionId).flatMap(([, job]) => [job.sessionId, job.resumeSessionId].filter((value) => Boolean(value))).flatMap((sessionId) => events.recentFor(sessionId, 200));
         const pending = nodeEvents.find((event) => event.phase === "blocked_on_user" && event.decisionId === req.params.decisionId);
         const alreadyResolved = nodeEvents.some((event) => event.phase === "decision_resolved" && event.decisionId === req.params.decisionId);
@@ -553,7 +749,17 @@ export function registerRest(app, deps) {
             return { error: "decision is no longer pending" };
         }
         try {
-            const result = await sendToMission(req.params.missionId, `Answer to your pending question: ${answer}`);
+            const skillPrefix = req.params.decisionId.startsWith("skill-prompt:") ? req.params.decisionId.slice(0, req.params.decisionId.lastIndexOf(":")) : undefined;
+            const siblings = skillPrefix ? nodeEvents.filter((event) => event.phase === "blocked_on_user" && event.decisionId?.startsWith(`${skillPrefix}:`)) : [pending];
+            const resolvedAnswers = new Map(nodeEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => [event.decisionId, event.detail]));
+            resolvedAnswers.set(req.params.decisionId, answer);
+            const remaining = siblings.filter((event) => event.decisionId && !resolvedAnswers.has(event.decisionId));
+            if (remaining.length) {
+                events.add({ ts: Date.now(), sessionId: pending.sessionId, jobId: pending.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: answer, decisionId: req.params.decisionId });
+                return { ok: true };
+            }
+            const combined = siblings.map((event) => `${event.detail}\nAnswer: ${resolvedAnswers.get(event.decisionId)}`).join("\n\n");
+            const result = await sendToMission(req.params.missionId, skillPrefix ? `Answers to the skill's pending questions:\n\n${combined}\n\nContinue the skill from the point where it requested this input.` : `Answer to your pending question: ${answer}`);
             events.add({ ts: Date.now(), sessionId: result.sessionId ?? pending.sessionId, jobId: result.jobId, source: "custom", phase: "decision_resolved", activityKind: "decision", detail: answer, decisionId: req.params.decisionId });
             return { ok: true };
         }
@@ -665,6 +871,11 @@ export function registerRest(app, deps) {
         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) => {
@@ -749,6 +960,9 @@ export function registerRest(app, deps) {
     });
     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)) {
@@ -757,6 +971,7 @@ export function registerRest(app, deps) {
         }
         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/control/codexRuntime.js

@@ -7,6 +7,22 @@ import { config } from "../config.js";
 import { enforceWorkingDirectory } from "../policies/policiesStore.js";
 import { requireWorkingDirectory } from "../paths/pathResolver.js";
 const HIVE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../..");
+export function parseCodexSkillPrompt(message) {
+    if (!message)
+        return undefined;
+    const match = message.match(/\[HIVE_USER_PROMPT\]\s*(\{[^\n]+\})/);
+    if (!match)
+        return undefined;
+    try {
+        const value = JSON.parse(match[1]);
+        if (typeof value.question !== "string" || !value.question.trim())
+            return undefined;
+        return { question: value.question.trim(), choices: Array.isArray(value.choices) ? value.choices.slice(0, 8).map(String) : [], cleanMessage: message.replace(match[0], "").trim() };
+    }
+    catch {
+        return undefined;
+    }
+}
 export class CodexRuntime {
     monitor;
     init() { fs.mkdirSync(config.codexJobsDir, { recursive: true }); fs.mkdirSync(config.codexSessionsDir, { recursive: true }); this.reconcile(); this.monitor = setInterval(() => this.reconcile(), 1_000); this.monitor.unref(); }
@@ -74,7 +90,7 @@ export class CodexRuntime {
                 manager = "You are the manager for a Hive mission. Delegate independent work to subagents when useful, keep a structured plan current, and synthesize their evidence.\n\n";
             }
         }
-        return `${manager}${options.task}\n\nHive policy: ${JSON.stringify(options.policy)}. Work only inside the selected repository and workspace sandbox. Do not commit, push, open PRs, release, publish, use network access, or perform destructive actions when the corresponding policy value is false. If access or budget expansion is needed, stop and clearly ask the user for approval.`;
+        return `${manager}${options.task}\n\nHive policy: ${JSON.stringify(options.policy)}. Work only inside the selected repository and workspace sandbox. Do not commit, push, open PRs, release, publish, use network access, or perform destructive actions when the corresponding policy value is false. If access or budget expansion is needed, stop and clearly ask the user for approval. If an invoked skill explicitly requires user input, do not guess or skip it. End the turn with exactly one single-line marker [HIVE_USER_PROMPT]{"question":"the question to surface","choices":["choice 1","choice 2"]}; use an empty choices array for free text. Hive will resume this same mission with the user's answer.`;
     }
     complete(jobId, pid, sessionId, code) {
         const job = this.readJob(jobId);
@@ -82,10 +98,14 @@ export class CodexRuntime {
             return;
         const events = readJsonLines(path.join(config.codexJobsDir, jobId, "timeline.jsonl"));
         const message = events.filter((event) => event.type === "item.completed" && object(event.item)?.type === "agent_message").map((event) => String(object(event.item)?.text ?? "")).filter(Boolean).at(-1);
+        const skillPrompt = parseCodexSkillPrompt(message);
         const usage = object([...events].reverse().find((event) => event.type === "turn.completed")?.usage);
-        job.state = code === 0 ? "done" : "error";
-        job.detail = code === 0 ? "Codex turn completed" : `Codex exited with code ${code}`;
-        job.output = message;
+        job.state = skillPrompt ? "blocked" : code === 0 ? "done" : "error";
+        job.tempo = skillPrompt ? "blocked" : job.tempo;
+        job.needs = skillPrompt?.question;
+        job.promptChoices = skillPrompt?.choices;
+        job.detail = skillPrompt ? "Skill is waiting for user input" : code === 0 ? "Codex turn completed" : `Codex exited with code ${code}`;
+        job.output = skillPrompt?.cleanMessage || message;
         job.tokens = Number(usage?.input_tokens ?? 0) + Number(usage?.output_tokens ?? 0);
         job.sessionId = sessionId;
         job.updatedAt = new Date().toISOString();

package/packages/server/dist/hooks/hookIngest.js

@@ -21,12 +21,55 @@ function stringField(input, ...keys) {
             return input[key];
     return undefined;
 }
+function stablePromptKey(payload) {
+    const explicit = stringField(record(payload), "tool_use_id", "toolUseId", "prompt_id", "promptId");
+    if (explicit)
+        return explicit.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 80);
+    const source = `${payload.session_id}:${JSON.stringify(payload.tool_input ?? {})}`;
+    let hash = 2166136261;
+    for (let index = 0; index < source.length; index += 1)
+        hash = Math.imul(hash ^ source.charCodeAt(index), 16777619);
+    return (hash >>> 0).toString(36);
+}
+/** Turns native Claude skill questions into Hive's durable decision model. */
+export function skillPromptEvents(payload, jobId) {
+    if (payload.hook_event_name !== "PreToolUse" || payload.tool_name !== "AskUserQuestion")
+        return [];
+    const questions = record(payload.tool_input).questions;
+    if (!Array.isArray(questions))
+        return [];
+    const group = stablePromptKey(payload);
+    return questions.slice(0, 8).flatMap((value, index) => {
+        const question = record(value);
+        const text = stringField(question, "question")?.trim();
+        if (!text)
+            return [];
+        const options = Array.isArray(question.options) ? question.options.slice(0, 8).map(record) : [];
+        const choices = options.map((option) => stringField(option, "label")?.trim()).filter((label) => Boolean(label));
+        const descriptions = options.flatMap((option) => { const label = stringField(option, "label")?.trim(); const description = stringField(option, "description")?.trim(); return label && description ? [`${label}: ${description}`] : []; });
+        const header = stringField(question, "header")?.trim();
+        return [{
+                ts: typeof payload._hive_spooled_at === "number" ? payload._hive_spooled_at : Date.now(), sessionId: payload.session_id, jobId, source: "hook",
+                hookEventName: payload.hook_event_name, toolName: payload.tool_name, phase: "blocked_on_user", activityKind: "decision",
+                detail: text, decisionId: `skill-prompt:${group}:${index}`, decisionKind: "question", choices,
+                context: [header ? `Skill prompt · ${header}` : "Skill prompt", ...descriptions].join("\n"),
+                targetWorker: stringField(record(payload), "agent_id", "subagent_id", "agent_name", "agent_type", "teammate_name"),
+            }];
+    });
+}
 function evidence(payload) {
     const input = record(payload.tool_input);
     const tool = payload.tool_name ?? "";
     const command = stringField(input, "command");
     const filePath = stringField(input, "file_path", "path", "notebook_path");
-    const targetWorker = stringField(payload, "agent_id", "subagent_id", "agent_name", "agent_type", "teammate_name");
+    let targetWorker = stringField(payload, "agent_id", "subagent_id", "agent_name", "agent_type", "teammate_name");
+    // Agent launches are emitted by the manager, so the payload's top-level
+    // agent_type is `hive-orchestrator`. Claude returns the durable worker id in
+    // tool_response.agentId. Attribute the launch to that id immediately; this
+    // prevents the fan-file race from creating an empty/duplicate entrance.
+    if (payload.hook_event_name === "PostToolUse" && tool === "Agent") {
+        targetWorker = stringField(record(payload.tool_response), "agentId", "agent_id") ?? targetWorker;
+    }
     if (["TaskCreated", "TaskCompleted", "TeammateIdle"].includes(payload.hook_event_name))
         return { activityKind: "agent", targetWorker };
     if (["PermissionRequest", "PermissionDenied", "Elicitation", "ElicitationResult", "Notification"].includes(payload.hook_event_name))

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

@@ -89,6 +89,7 @@ export class MissionsStore {
             policy: input.policy,
             provider: input.provider ?? "claude",
             model: input.model?.trim() || undefined,
+            planFirst: input.planFirst || undefined,
             additionalRepositories: input.additionalRepositories?.length ? [...new Set(input.additionalRepositories)] : undefined,
             createdAt: now,
             updatedAt: now,
@@ -149,6 +150,7 @@ export class MissionsStore {
             ...(mission?.policy ? { policy: mission.policy } : {}),
             provider: mission?.provider ?? "claude",
             ...(mission?.model ? { model: mission.model } : {}),
+            ...(mission?.planFirst ? { planFirst: true } : {}),
             ...(mission?.additionalRepositories?.length ? { additionalRepositories: mission.additionalRepositories } : {}),
         };
     }
@@ -188,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/plans/plansStore.js

@@ -85,10 +85,13 @@ export class PlansStore {
       CREATE INDEX IF NOT EXISTS idx_plan_revisions ON mission_plan_revisions (mission_id, revision DESC);
     `);
     }
-    replace(missionId, input) {
+    replace(missionId, input, preserveUserGates = true) {
         const phases = normalize(input);
         const current = this.get(missionId);
-        const gates = input.gates === undefined ? current?.gates ?? [] : normalizeGates(input.gates);
+        const incoming = input.gates === undefined ? current?.gates ?? [] : normalizeGates(input.gates);
+        const protectedUserGates = preserveUserGates ? (current?.gates ?? []).filter((gate) => gate.source === "user") : [];
+        const protectedIds = new Set(protectedUserGates.map((gate) => gate.id));
+        const gates = [...incoming.filter((gate) => !protectedIds.has(gate.id)), ...protectedUserGates];
         const plan = { missionId, revision: (current?.revision ?? 0) + 1, updatedAt: Date.now(), phases, gates, layout: input.tasks ? "flat" : "phased", approvalStatus: input.approvalStatus ?? "proposed", approvalReason: input.approvalReason?.trim() || undefined, progress: calculateProgress(phases) };
         const json = JSON.stringify(plan);
         this.db.transaction(() => {
@@ -177,7 +180,35 @@ export class PlansStore {
             throw new Error("completion gate not found");
         if (!reason.trim())
             throw new Error("waiver reason is required");
-        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: (plan.gates ?? []).map((item) => item.id === gateId ? { ...item, status: "waived", waiver: { reason: reason.trim(), waivedAt: Date.now() } } : item), approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: (plan.gates ?? []).map((item) => item.id === gateId ? { ...item, status: "waived", waiver: { reason: reason.trim(), waivedAt: Date.now() } } : item), approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason }, false);
+    }
+    addUserGate(missionId, input) {
+        const plan = this.get(missionId);
+        const id = `user-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+        const gate = { id, label: input.label, type: input.type, required: input.required, status: "pending", evidence: [], source: "user" };
+        return this.replace(missionId, { ...(plan?.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan?.phases ?? [] }), gates: [...(plan?.gates ?? []), gate], approvalStatus: plan?.approvalStatus ?? "approved", approvalReason: plan?.approvalReason }, false);
+    }
+    updateUserGate(missionId, gateId, input) {
+        const plan = this.get(missionId);
+        if (!plan)
+            throw new Error("mission plan not found");
+        const gate = plan.gates.find((item) => item.id === gateId);
+        if (!gate)
+            throw new Error("completion gate not found");
+        if (gate.source !== "user")
+            throw new Error("only user-created gates can be edited manually");
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: plan.gates.map((item) => item.id === gateId ? { ...item, ...input } : item), approvalStatus: plan.approvalStatus, approvalReason: plan.approvalReason }, false);
+    }
+    removeUserGate(missionId, gateId) {
+        const plan = this.get(missionId);
+        if (!plan)
+            throw new Error("mission plan not found");
+        const gate = plan.gates.find((item) => item.id === gateId);
+        if (!gate)
+            throw new Error("completion gate not found");
+        if (gate.source !== "user")
+            throw new Error("only user-created gates can be removed manually");
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: plan.gates.filter((item) => item.id !== gateId), approvalStatus: plan.approvalStatus, approvalReason: plan.approvalReason }, false);
     }
     unresolvedRequiredGates(missionId) {
         return (this.get(missionId)?.gates ?? []).filter((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
@@ -194,7 +225,7 @@ export class PlansStore {
             gates: (plan.gates ?? []).map((gate) => gate.type === "user_approval" && gate.status !== "satisfied" && gate.status !== "waived" ? { ...gate, status: "satisfied", evidence: [...gate.evidence, "Mission accepted by user"] } : gate),
             approvalStatus: plan.approvalStatus ?? "proposed",
             approvalReason: plan.approvalReason,
-        });
+        }, false);
     }
     setApproval(missionId, status, reason) {
         const plan = this.get(missionId);