@shanesaravia/hive 0.2.1 → 0.4.0

package/packages/server/dist/plans/planReconcile.js

@@ -0,0 +1,114 @@
+import { matchesWorker } from "@hive/shared";
+import { allPlanTasks } from "./plansStore.js";
+const key = (value) => value?.trim().toLowerCase() || undefined;
+/**
+ * Reconciles the board against the workers that are actually running.
+ *
+ * Orchestrators reliably launch workers but often forget to republish the plan,
+ * and a worker launched without a `delegating` event carries no task id at all.
+ * Either way the board sits at "queued" while work is visibly in flight. Rather
+ * than warn about that, derive the link from evidence Hive already has: the
+ * task ids bound to the worker's identity, or an exact match between the Agent
+ * description and a task's title or deliverable.
+ *
+ * Deliberately one-directional. A running worker is proof work started, so
+ * queued/blocked tasks may advance to working. A worker *stopping* is not proof
+ * the task succeeded, so completion still requires the orchestrator's report or
+ * a gate — this never marks anything done.
+ */
+export function reconcilePlanWorkers(plan, workers) {
+    if (!plan)
+        return [];
+    const tasks = plan.phases.flatMap((phase) => allPlanTasks(phase.tasks));
+    if (!tasks.length)
+        return [];
+    const open = (task) => task.status !== "completed" && task.status !== "cancelled";
+    const bindings = [];
+    // A task already claimed by another worker is never re-pointed here.
+    const claimedTasks = new Set(tasks.filter((task) => task.workerId || task.owner).map((task) => task.id));
+    for (const worker of workers) {
+        const explicit = (worker.taskIds ?? []).filter((id) => tasks.some((task) => task.id === id && open(task)));
+        if (explicit.length) {
+            for (const taskId of explicit)
+                bindings.push({ taskId, canonicalWorker: worker.id, label: worker.label, inferred: false });
+            continue;
+        }
+        // No `--task` was ever emitted for this worker. Fall back to an exact,
+        // unambiguous text match: orchestrators normally pass the task's title or
+        // its deliverable as the Agent description.
+        const name = key(worker.label);
+        if (!name)
+            continue;
+        const candidates = tasks.filter((task) => open(task) && !claimedTasks.has(task.id)
+            && (key(task.title) === name || key(task.assignment) === name || key(task.description) === name));
+        if (candidates.length !== 1)
+            continue;
+        claimedTasks.add(candidates[0].id);
+        bindings.push({ taskId: candidates[0].id, canonicalWorker: worker.id, label: worker.label, inferred: true });
+    }
+    // Skip anything the board already reflects.
+    return bindings.filter(({ taskId, canonicalWorker }) => {
+        const task = tasks.find((item) => item.id === taskId);
+        if (!task)
+            return false;
+        const worker = workers.find((item) => item.id === canonicalWorker);
+        const named = matchesWorker(task.workerId, worker) || matchesWorker(task.owner, worker);
+        const started = task.status === "working" || task.status === "reviewing";
+        return !named || !started;
+    });
+}
+/**
+ * Fill each task's changed files from the writes Hive already observed.
+ *
+ * `changedFiles` appears in the orchestrator's plan schema but nothing in its
+ * instructions ever asks it to be populated, so in practice it stays empty and
+ * the acceptance view has no idea what a mission touched. Hive does not need
+ * to be told: every file-write hook carries the path and the worker that made
+ * it, and workers are already bound to tasks. Deriving beats reporting here —
+ * it cannot drift from what actually happened, and it needs no cooperation
+ * from the model.
+ *
+ * Anything the orchestrator *did* report is kept and merged, never replaced:
+ * it may know about writes made before Hive was watching.
+ */
+export function deriveChangedFiles(plan, workers, events) {
+    if (!plan)
+        return plan;
+    const writes = events.filter((event) => event.activityKind === "file_write" && event.filePath);
+    if (!writes.length)
+        return plan;
+    const tasks = plan.phases.flatMap((phase) => allPlanTasks(phase.tasks));
+    const byTask = new Map();
+    const add = (taskId, filePath) => {
+        const set = byTask.get(taskId) ?? new Set();
+        set.add(filePath);
+        byTask.set(taskId, set);
+    };
+    for (const event of writes) {
+        // An explicit `--task` is the orchestrator's own attribution; trust it.
+        if (event.targetTask && tasks.some((task) => task.id === event.targetTask)) {
+            add(event.targetTask, event.filePath);
+            continue;
+        }
+        // Otherwise go through the worker, using the one identity comparison the
+        // rest of Hive uses, so an alias or a delegation label resolves the same.
+        const worker = workers.find((item) => matchesWorker(event.targetWorker, item));
+        if (!worker)
+            continue;
+        const owned = tasks.filter((task) => (worker.taskIds ?? []).includes(task.id) || matchesWorker(task.workerId, worker) || matchesWorker(task.owner, worker));
+        // A worker covering several tasks gives no evidence about which one a
+        // write belongs to, so attribute only when the answer is unambiguous.
+        if (owned.length === 1)
+            add(owned[0].id, event.filePath);
+    }
+    if (!byTask.size)
+        return plan;
+    const merge = (task) => {
+        const derived = byTask.get(task.id);
+        const subtasks = task.subtasks?.length ? task.subtasks.map(merge) : task.subtasks;
+        if (!derived)
+            return subtasks === task.subtasks ? task : { ...task, subtasks };
+        return { ...task, changedFiles: [...new Set([...(task.changedFiles ?? []), ...derived])].sort(), subtasks };
+    };
+    return { ...plan, phases: plan.phases.map((phase) => ({ ...phase, tasks: phase.tasks.map(merge) })) };
+}

package/packages/server/dist/plans/plansStore.js

@@ -124,8 +124,11 @@ export class PlansStore {
         const now = Date.now();
         const mapTasks = (tasks) => tasks.map((task) => {
             const subtasks = task.subtasks?.length ? mapTasks(task.subtasks) : task.subtasks;
+            // A worker is addressed by whichever name the orchestrator used; the plan
+            // stores the canonical identity so every consumer can compare exactly.
+            const workerNames = [input.canonicalWorker, input.targetWorker].filter((value) => Boolean(value));
             const matched = (input.targetTask !== undefined && task.id === input.targetTask)
-                || (input.targetWorker !== undefined && (task.workerId === input.targetWorker || task.owner === input.targetWorker));
+                || workerNames.some((name) => task.workerId === name || task.owner === name);
             // A parent cannot complete ahead of its subtasks (normalize rejects it).
             const blockedBySubtasks = nextStatus === "completed" && (subtasks ?? []).some((subtask) => subtask.status !== "completed" && subtask.status !== "cancelled");
             if (!matched || blockedBySubtasks || !allowedFrom[nextStatus].includes(task.status)) {
@@ -138,8 +141,8 @@ export class PlansStore {
                 status: nextStatus,
                 updatedAt: now,
                 startedAt: task.startedAt ?? now,
-                owner: task.owner ?? input.targetWorker,
-                workerId: task.workerId ?? input.targetWorker,
+                owner: task.owner ?? input.canonicalWorker ?? input.targetWorker,
+                workerId: input.canonicalWorker ?? task.workerId ?? input.targetWorker,
                 evidence: nextStatus === "completed" && input.evidence?.trim() ? [...task.evidence, input.evidence.trim().slice(0, 300)] : task.evidence,
             };
         });
@@ -157,6 +160,46 @@ export class PlansStore {
             return undefined;
         return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: phases[0]?.tasks ?? [] } : { phases }), gates: plan.gates ?? [], approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
     }
+    /**
+     * Records that a worker is running a task: stamps the canonical identity and
+     * advances a queued/blocked task to working. Forward-only and idempotent, so
+     * a repeated snapshot cannot churn revisions, and never marks work complete —
+     * a running worker proves work started, not that it succeeded.
+     */
+    attachWorker(missionId, input) {
+        const plan = this.get(missionId);
+        if (!plan)
+            return undefined;
+        let changed = false;
+        const now = Date.now();
+        const mapTasks = (tasks) => tasks.map((task) => {
+            const subtasks = task.subtasks?.length ? mapTasks(task.subtasks) : task.subtasks;
+            if (task.id !== input.taskId)
+                return subtasks === task.subtasks ? task : { ...task, subtasks };
+            const advancing = task.status === "queued" || task.status === "blocked";
+            if (task.workerId === input.canonicalWorker && !advancing)
+                return subtasks === task.subtasks ? task : { ...task, subtasks };
+            changed = true;
+            return {
+                ...task,
+                subtasks,
+                status: advancing ? "working" : task.status,
+                owner: task.owner ?? input.label ?? input.canonicalWorker,
+                workerId: input.canonicalWorker,
+                startedAt: task.startedAt ?? now,
+                updatedAt: now,
+            };
+        });
+        const phases = plan.phases.map((phase) => {
+            const tasks = mapTasks(phase.tasks);
+            const statuses = allPlanTasks(tasks).map((task) => task.status);
+            const status = (phase.status === "queued" || phase.status === "completed") && statuses.some((s) => s === "working" || s === "reviewing") ? "working" : phase.status;
+            return { ...phase, status, tasks };
+        });
+        if (!changed)
+            return undefined;
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: phases[0]?.tasks ?? [] } : { phases }), gates: plan.gates ?? [], approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
+    }
     removeMission(missionId) { this.db.transaction(() => { this.db.prepare("DELETE FROM mission_plans WHERE mission_id = ?").run(missionId); this.db.prepare("DELETE FROM mission_plan_revisions WHERE mission_id = ?").run(missionId); })(); for (const listener of this.listeners)
         listener(); }
     migrateMission(oldId, newId) { this.db.transaction(() => { const current = this.get(oldId); if (current) {

package/packages/server/dist/reviews/reviewDiff.js

@@ -0,0 +1,47 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+const MAX_PATCH = 200_000;
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 5_000, maxBuffer: 2_000_000, stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function gitDiff(cwd, args) {
+    try {
+        return git(cwd, ["diff", ...args]);
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (stdout !== undefined)
+            return String(stdout).trim();
+        throw error;
+    }
+}
+/** Read-only source-control evidence for a mission-controlled repository. */
+export function reviewDiff(cwd) {
+    if (!cwd || !fs.existsSync(cwd))
+        return { available: false, stat: "", patch: "", files: [], truncated: false, error: "Repository is unavailable." };
+    try {
+        if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true")
+            throw new Error("Not a Git worktree");
+        let base;
+        for (const candidate of ["origin/main", "main", "origin/master", "master"]) {
+            try {
+                base = git(cwd, ["merge-base", "HEAD", candidate]);
+                if (base)
+                    break;
+            }
+            catch { /* try next baseline */ }
+        }
+        const range = base ? [`${base}..HEAD`] : [];
+        const committed = gitDiff(cwd, range);
+        const working = gitDiff(cwd, ["HEAD"]);
+        const untracked = git(cwd, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+        const untrackedPatches = untracked.map((file) => gitDiff(cwd, ["--no-index", "--", "/dev/null", file]));
+        const patch = [committed, working, ...untrackedPatches].filter(Boolean).join("\n");
+        const stat = [git(cwd, ["diff", "--stat", ...range]), git(cwd, ["diff", "--stat", "HEAD"]), untracked.length ? `${untracked.length} untracked file${untracked.length === 1 ? "" : "s"}` : ""].filter(Boolean).join("\n");
+        const files = [...new Set([...git(cwd, ["diff", "--name-only", ...range]).split("\n"), ...git(cwd, ["diff", "--name-only", "HEAD"]).split("\n"), ...untracked].filter(Boolean))];
+        return { available: true, base, stat, patch: patch.slice(0, MAX_PATCH), files, truncated: patch.length > MAX_PATCH };
+    }
+    catch (error) {
+        return { available: false, stat: "", patch: "", files: [], truncated: false, error: error.message };
+    }
+}

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

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MissionsStore } from "../missions/missionsStore.js";
+import { buildFleetSnapshot } from "./rosterBuilder.js";
+import { WorkerIdentityStore } from "./workerIdentity.js";
+const fixturesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures");
+export function loadMissionFixture(name) {
+    return JSON.parse(fs.readFileSync(path.join(fixturesDir, `${name}.events.json`), "utf8"));
+}
+/**
+ * The manager's job is `done` between a Stop and the next prompt — the turn
+ * boundary that repeatedly got mistaken for the end of the mission.
+ */
+function jobStateAt(events) {
+    let state = "working";
+    for (const event of events) {
+        if (event.hookEventName === "Stop")
+            state = "done";
+        if (event.hookEventName === "UserPromptSubmit")
+            state = "working";
+    }
+    return state;
+}
+export function replayMission(fixture, options = {}) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `hive-replay-${fixture.name}-`));
+    options.cleanup?.(() => fs.rmSync(dir, { recursive: true, force: true }));
+    const missions = new MissionsStore(path.join(dir, "missions.json"), path.join(dir, "threads.json"));
+    missions.init();
+    const primaryJob = fixture.jobs[0];
+    const mission = missions.create({
+        name: fixture.name, objective: fixture.objective, jobId: primaryJob?.jobId ?? fixture.missionId,
+        sessionId: fixture.sessionId, mode: fixture.mode,
+    });
+    for (const { jobId } of fixture.jobs.slice(1))
+        missions.linkJob(mission.id, jobId);
+    const identity = new WorkerIdentityStore(path.join(dir, "hive.db"));
+    // A read-only stand-in for the plans store: the recorded revisions already
+    // contain the worker bindings production wrote, so replaying must not write
+    // new ones over them.
+    const revisions = [...(fixture.planRevisions ?? [])].sort((a, b) => a.updatedAt - b.updatedAt);
+    const plansAt = (at) => ({
+        get: () => [...revisions].reverse().find((entry) => entry.updatedAt <= at)?.plan,
+        attachWorker: () => undefined,
+    });
+    const start = fixture.events[0]?.ts ?? 0;
+    const steps = [];
+    for (let index = 1; index <= fixture.events.length; index += 1) {
+        const seen = fixture.events.slice(0, index);
+        const event = seen[seen.length - 1];
+        const now = event.ts + 1;
+        // The REST ingest moves the mission to review on this event; a replay that
+        // left it active never showed the office the moment the manager leaves
+        // for the hall while workers are still on their way out (mission test41).
+        if (event.source === "custom" && event.phase === "ready_for_review")
+            missions.setLifecycleStatus(mission.id, "ready_for_review");
+        const state = jobStateAt(seen);
+        const jobs = new Map(fixture.jobs.map(({ jobId, job }) => [jobId, {
+                ...job,
+                state,
+                // The provider's fan file is written as workers finish; before the turn
+                // ends the roster only has hook evidence to go on. A recorded fixture
+                // holds the file's *final* contents, so entries — and their doneAt — are
+                // masked until the moment they were really written. Without that the
+                // replay hands the roster a worker's completion long before it happened.
+                fan: state === "done"
+                    ? job.fan.filter((entry) => entry.startedAt <= now).map((entry) => ({ ...entry, doneAt: entry.doneAt !== undefined && entry.doneAt <= now ? entry.doneAt : undefined }))
+                    : [],
+            }]));
+        const events = {
+            recentFor: (id, limit = 50) => seen.filter((item) => item.sessionId === id || item.jobId === id).slice(-limit),
+            sessionIds: () => [...new Set(seen.map((item) => item.sessionId))],
+        };
+        steps.push({ elapsedMs: event.ts - start, event, snapshot: buildFleetSnapshot(new Map(), jobs, events, missions, undefined, plansAt(now), now, identity) });
+    }
+    return steps;
+}
+/** The mission node under replay, for the one mission a fixture contains. */
+export function replayedMission(step) {
+    return step.snapshot.orchestrators[0];
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Phrases that mark a reply as genuinely handing a choice back to the reader.
+ *
+ * Deliberately narrow. A turn ending "let me know if you need anything else"
+ * is politeness, not a decision, and surfacing those as "Needs you" would
+ * teach the reader to ignore the one signal that should never be ignored.
+ */
+const ASK_PATTERNS = [
+    /\bfor you to decide\b/i,
+    /\byour (call|decision|choice)\b/i,
+    /\bup to you\b/i,
+    /\bsay the word\b/i,
+    /\bwhich (one )?(would|do) you (prefer|want)\b/i,
+    /\b(do|would) you want me to\b/i,
+    /\bwould you like me to\b/i,
+    /\bshall I\b/i,
+    /\bshould I\b[^?]*\?/i,
+    /\bplease (confirm|advise|choose)\b/i,
+    /\blet me know (which|whether|if you want|if you'd)\b/i,
+    /\bneeds? your (input|decision|sign-?off|approval|steer)\b/i,
+    /\bwaiting (on|for) your (call|decision|answer|input)\b/i,
+];
+/** Sign-offs that look like asks but close a turn rather than pausing it. */
+const CLOSING_PATTERNS = [
+    /^\s*(anything else|any(thing)? more)\b/i,
+    /\blet me know if you (need|have|spot|want) (anything|any|something)\b/i,
+];
+const MAX_QUESTION_CHARS = 800;
+/** Strips leading markdown emphasis and list markers so the ask reads as prose. */
+function tidy(line) {
+    return line.replace(/^\s*[-*]\s+/, "").replace(/\*\*/g, "").trim();
+}
+/**
+ * Finds a decision the agent handed back in the prose of its reply.
+ *
+ * Hive's decision inbox is fed by structured signals — emitted decisions,
+ * parked permissions, provider prompts — none of which fire when an agent
+ * simply finishes its turn by asking a question. Those asks were reaching the
+ * transcript with no affordance at all: no "Needs you", nothing in the inbox,
+ * nothing to answer, and a mission that looked finished while it waited.
+ *
+ * Returns the ask from the first marker line onward, so an enumerated list of
+ * choices arrives with the question that introduced it.
+ */
+export function detectReplyAsk(reply) {
+    if (!reply?.trim())
+        return undefined;
+    const lines = reply.split("\n");
+    const at = lines.findIndex((line) => {
+        if (CLOSING_PATTERNS.some((pattern) => pattern.test(line)))
+            return false;
+        return ASK_PATTERNS.some((pattern) => pattern.test(line));
+    });
+    if (at === -1)
+        return undefined;
+    // From the marker to the end: an ask is routinely a header followed by the
+    // options it introduces, and the header alone would be unanswerable.
+    const question = lines.slice(at).map(tidy).filter(Boolean).join("\n").trim();
+    if (!question)
+        return undefined;
+    return { question: question.length > MAX_QUESTION_CHARS ? `${question.slice(0, MAX_QUESTION_CHARS).trimEnd()}…` : question };
+}