@shanesaravia/hive 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 All notable changes to Hive will be documented in this file.
 
+## 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.
+
+### Added
+
+- Images pasted or dropped into a mission conversation. They upload as you type rather than on send, render as thumbnails in the message, and reach the agent as a path on disk to read — the one route that behaves the same in a repository, a worktree, or anywhere else.
+- `@agent` completion in the composer, from the `.claude/agents` definitions, by the name each declares rather than its filename, with a project definition shadowing a user one exactly as the CLI resolves them.
+- Loops Hive owns: `/loop 10m …` registers a recurring prompt Hive re-sends, kept in the database so it survives a restart instead of dying quietly while it still looks like it is running. `/loop list`, `/loop stop [id]` and `/tasks` in any conversation; a "N running" pill in the header, drawn only when something is, opening a panel that lists every loop and background monitor across the fleet with a stop on each.
+- Consecutive loop passes that find nothing fold into one row in the transcript, so a poller that finds nothing overnight cannot bury the two runs that mattered. The row expands to the individual passes.
+
+### Fixed
+
+- A message could appear and then be replaced by a different one. A turn's reply row was rewritten on every poll as the turn progressed, progress notes were keyed by list position so a filtered entry slid every following one onto other text, and timestamps were rewritten, moving already-read messages. Text now only ever grows in place; anything genuinely different is appended.
+- New messages no longer pull the viewport to the bottom. Scrolled up, you keep your place and are offered the way back.
+- A decision no longer replaces the conversation it refers to. It is drawn inline where it was raised, with one line above the transcript that flags an unaddressed decision and walks between them when there are several.
+- A turn that ends by asking you something — rather than through a structured prompt — is now an answerable decision instead of a mission that looks finished while it waits.
+- A mission whose workers were running reported "Idle": a manager's session reads idle between its own turns while the subagents it dispatched keep working.
+- Skill and agent discovery no longer fail outright when a mission's recorded repository is gone, which is every mission whose worktree has been reclaimed. Your own skills and agents apply regardless of where a mission runs. This also made such a mission impossible to message at all, because the send path discovered skills before falling back to a live repository.
+- The composer takes focus when a mission opens.
+
+## 0.3.0 — 2026-08-29
+
+Turns a mission's full page into a dashboard, carries the keyboard into it, and settles a run of places where two parts of the board disagreed about one fact.
+
+### Added
+
+- A mission's full page is a dashboard rather than five tabs: the objective and its acceptance criteria, the conversation, and what is happening now sit in three columns that cannot hide each other, with the plan full width beneath them and diagnostics folded away at the foot.
+- Progress measures that say how far along a mission is — phase and gate progress and the files that actually changed — replacing elapsed time, a worker count and the same worker count again.
+- Keyboard control of a mission's own page: `a` and `d` do what the mission is asking, `r` reaches the composer, `p` pauses, `g c` / `g w` / `g p` / `g d` / `g g` jump around the page, `h` and `l` walk the missions still yours to do, and `⇧H` / `⇧L` walk only the ones asking for you.
+- Bulk **Complete** and **Delete**, with `⇧C`, `⇧P`, `⇧A` and `⇧⌫` on the selection bar and `⏎` to commit a confirmation. Archive and Delete arm a confirmation rather than firing, so nothing irreversible happens on a keystroke.
+- Click-to-copy on a mission's repository path, branch and id, and a note on returning to a mission of what arrived while you were away.
+- A **Settings** menu for sound, notifications, workspace policy and templates.
+
+### Changed
+
+- One page width for the board, the office and both mission presentations, which had grown three between them.
+- The Needs you rail leads the board and reads as the most important thing on it; running work now sits above work awaiting acceptance, which the rail directly above it already lists.
+- Bulk Accept and Complete became one **Complete**, over running work and work awaiting acceptance alike, and every bulk control appears only when it applies to the selection.
+- Filters survive a reload, as the sort beside them already did, and the board's shortcuts keep working in the office.
+- **Request changes** asks what should change instead of quietly reopening the mission, and a mission awaiting acceptance reopens when it starts working again rather than because you spoke to it.
+
+### Fixed
+
+- Background sessions launch in `auto`. `bypassPermissions` now requires a one-time interactive disclaimer that a server cannot give on the user's behalf, so every mission launch was failing; a launch that is refused now reports the CLI's own words in about a second instead of a thirty-second timeout.
+- One owner for Escape. Ten independent listeners each guessed whether the key was theirs, so two open slide-overs closed together on one press.
+- Clicking a worker opens that worker beside the board, instead of promoting the whole board to a full page and dropping the worker on the way.
+- The office counts the missions the board says need you. Its floor badges and its avatars each used a different rule, and neither counted a pending decision or an unapproved plan.
+- A card no longer asks you to approve a plan whose work has already run, and a reopened mission stops reporting that it awaits an acceptance.
+- The activity line's tense follows the evidence — `Ran` for a finished command, `Running` only while one is open — and it names a worker's own events rather than labelling them "Worker activity".
+- A stale mission is called stale in the rail, as it already was in its pill and in the filter.
+- Cards keep one shape whatever state they are in, rows end level, and a card's standing summary clamps to the two lines it was always meant to.
+
 ## 0.2.1 — 2026-08-25
 
 ### Added

package/README.md

@@ -179,12 +179,14 @@ The selected working directory matters. The provider CLI is launched from that d
 
 ## Continue a conversation
 
-Open a mission card and send a follow-up from the Conversation panel. Both providers preserve their native conversation/thread identity while Hive records each turn under the same durable mission.
+Open a mission card and send a follow-up from the Conversation panel. Both providers preserve their native conversation/thread identity while Hive records each turn under the same durable mission. Conversation defaults to a quiet narrative that interleaves messages with plan, task, worker, verification, gate, and review milestones; switch to **Messages only** when you want an unaugmented transcript. Historical missions are not given synthetic milestones—stored events are shown as recorded, and future transitions are enriched durably.
 
 Type `/` in either the new-mission prompt or an existing conversation to search the skills available to that provider in the selected working directory. Hive reads Claude skills for Claude missions and Codex skills for Codex missions; slash-form Codex selections are translated to the provider's native invocation form behind the scenes. Recognized skills are highlighted and sent as ordinary prompt text, leaving the provider CLI responsible for execution and permissions. Hive discovers skill metadata only; it does not preload entire skill bodies into mission context.
 
 If a provider or deliberately interactive skill asks a structured question, Hive surfaces it in **Needs you** and the mission conversation. Answering there resumes the same mission; skill prompts are not silently bypassed.
 
+**Needs you** also supports focused `j`/`k` triage, snoozing, and deferral until an item materially changes. Awaiting-acceptance missions expose a review packet with observed files, verification, gates, outputs, risks, source-control context, freshness protection, and actions to request changes, add or waive gates, rerun verification, or accept. Pin up to four missions into the persistent workspace with `Shift+Enter` or the command palette; `Cmd/Ctrl+1…4` focuses panes, and pane order, density, and split are retained locally.
+
 ## Navigate the fleet
 
 The fleet is organized around attention rather than process creation time:
@@ -284,6 +286,19 @@ Health alerts explain the condition, supporting evidence, and a suggested recove
 
 Mission and task controls include pause/resume, graceful or confirmed force stop, manager replacement, retry, cancellation, worker replacement/reassignment, priority changes, plan revision, fresh review, verification pass, completion, reopening, archive, and permanent deletion. Control actions are recorded in the activity timeline.
 
+### Conversation and Terminal
+
+Conversation is the primary structured mission interface. Terminal provides chronological provider output as a debugging and migration fallback. Claude manager sources currently send clearly labelled provider follow-ups; supported Codex manager sources can start an interactive app-server turn. Worker, completed, unsupported, busy, and disconnected sources stay readable but do not present a writable prompt.
+
+Terminal input uses Enter to send and Shift+Enter for a new line. Large pastes require confirmation, control sequences are sanitized from transcript rendering, and interrupting a turn is distinct from pausing or stopping its mission. Search, plain-text copy, source selection, scroll position, and drafts work independently per mission source.
+
+Recovery order is: return to Conversation, refresh the durable transcript, reload Hive to reconnect, interrupt the current interactive turn, then use the mission Pause/Stop controls if necessary. Writable modes can be disabled independently without disabling transcript viewing:
+
+- `HIVE_TERMINAL_CODEX_INPUT=0` disables Codex interactive Terminal input.
+- `HIVE_TERMINAL_CLAUDE_FOLLOW_UP=0` disables Claude follow-ups from Terminal; Conversation remains available.
+
+Hive records local, privacy-safe Terminal audit metadata and aggregate counters—provider, mission/source identity, character count, outcome, reconnects, failures, and cleanup. It never adds raw Terminal input, credentials, or environment values to those records. Current local status is available at `GET /api/terminal/status`.
+
 ## Reports and GitHub
 
 The Technical view exports a mission report as Markdown or JSON. Reports include the request, plan, decisions, workers, changed files, verification, outputs, resource use, conversation, and remaining risks. With a locally authenticated `gh` CLI, Hive can post a report to a GitHub issue or pull request after explicit confirmation; it does not publish automatically.
@@ -428,6 +443,8 @@ Project planning is split by scope:
 - [`docs/IMPROVEMENTS.md`](docs/IMPROVEMENTS.md) — core product roadmap and completion checklist
 - [`docs/VISUAL_OFFICE_PLAN.md`](docs/VISUAL_OFFICE_PLAN.md) — completed visual-office foundation
 - [`docs/VISUAL_OFFICE_FEEL_ALIVE_PLAN.md`](docs/VISUAL_OFFICE_FEEL_ALIVE_PLAN.md) — current and upcoming atmosphere, interaction, and polish phases
+- [`docs/AGENT_SYNC_AND_OFFICE_STATE_PLAN.md`](docs/AGENT_SYNC_AND_OFFICE_STATE_PLAN.md) — audit and phased plan for 1:1 terminal-agent sync, canonical worker identity, and checkpointed office animation state
+- [`docs/OFFICE_STABILITY_AUDIT.md`](docs/OFFICE_STABILITY_AUDIT.md) — replay-driven audit of the backend → office pipeline, with the tiered plan for a dependable roster and animation scene
 
 ## Troubleshooting
 

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

@@ -4,4 +4,10 @@ import type { OrchestratorNode } from "./types.js";
  * Bulk cleanup must never accept gates or dismiss a mission that still needs
  * work or user attention.
  */
+/**
+ * A direct agent has finished when its turn is over and nothing is pending:
+ * its desk goes green with the check, and it stays seated until the user
+ * marks it complete — leaving at once would take its reply with it.
+ */
+export declare function isDirectMissionFinished(node: OrchestratorNode): boolean;
 export declare function canClearDirectStudioMission(node: OrchestratorNode): boolean;

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

@@ -4,6 +4,18 @@ const CLEARABLE_ACTIVITY = new Set(["idle", "done", "offline"]);
  * Bulk cleanup must never accept gates or dismiss a mission that still needs
  * work or user attention.
  */
+/**
+ * A direct agent has finished when its turn is over and nothing is pending:
+ * its desk goes green with the check, and it stays seated until the user
+ * marks it complete — leaving at once would take its reply with it.
+ */
+export function isDirectMissionFinished(node) {
+    if (node.mission.mode !== "direct" || node.lifecycleStatus !== "active" || !node.turnCompleted)
+        return false;
+    if (!["idle", "done"].includes(node.activityStatus) || node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return false;
+    return node.alerts.every((alert) => alert.severity !== "critical");
+}
 export function canClearDirectStudioMission(node) {
     if (node.mission.mode !== "direct" || node.lifecycleStatus !== "active")
         return false;

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

@@ -1,3 +1,5 @@
 export * from "./types.js";
 export * from "./status.js";
+export * from "./workers.js";
 export * from "./directStudio.js";
+export * from "./reviewHall.js";

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

@@ -1,3 +1,5 @@
 export * from "./types.js";
 export * from "./status.js";
+export * from "./workers.js";
 export * from "./directStudio.js";
+export * from "./reviewHall.js";

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

@@ -0,0 +1,15 @@
+import type { OrchestratorNode } from "./types.js";
+/**
+ * Whether a mission awaiting acceptance can be accepted without a human
+ * reading it first.
+ *
+ * Acceptance is the human sign-off that `ready_for_review` exists to require,
+ * so a bulk action must only ever cover missions where there is demonstrably
+ * nothing to judge: every required gate is satisfied or explicitly waived,
+ * nothing is asking a question, no alert is open, and no work is still moving.
+ * Anything else keeps its seat and has to be accepted individually — a bulk
+ * button must never turn the review step into a rubber stamp.
+ */
+export declare function canAcceptReviewMission(node: OrchestratorNode, hasPendingDecision?: boolean): boolean;
+/** Why a seated mission was left for the user to accept themselves. */
+export declare function reviewAcceptanceBlocker(node: OrchestratorNode, hasPendingDecision?: boolean): string | undefined;

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

@@ -0,0 +1,49 @@
+/**
+ * Whether a mission awaiting acceptance can be accepted without a human
+ * reading it first.
+ *
+ * Acceptance is the human sign-off that `ready_for_review` exists to require,
+ * so a bulk action must only ever cover missions where there is demonstrably
+ * nothing to judge: every required gate is satisfied or explicitly waived,
+ * nothing is asking a question, no alert is open, and no work is still moving.
+ * Anything else keeps its seat and has to be accepted individually — a bulk
+ * button must never turn the review step into a rubber stamp.
+ */
+export function canAcceptReviewMission(node, hasPendingDecision = false) {
+    if (node.lifecycleStatus !== "ready_for_review")
+        return false;
+    if (hasPendingDecision)
+        return false;
+    if (node.activityStatus === "waiting_on_you" || node.activityStatus === "error" || node.activityStatus === "stalled")
+        return false;
+    if (node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return false;
+    if (node.workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")))
+        return false;
+    if (node.alerts.length > 0)
+        return false;
+    return !(node.plan?.gates ?? []).some((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
+}
+/** Why a seated mission was left for the user to accept themselves. */
+export function reviewAcceptanceBlocker(node, hasPendingDecision = false) {
+    if (node.lifecycleStatus !== "ready_for_review")
+        return "not awaiting acceptance";
+    if (hasPendingDecision)
+        return "waiting on your answer";
+    if (node.activityStatus === "waiting_on_you")
+        return "waiting on you";
+    if (node.activityStatus === "error")
+        return "runtime error";
+    if (node.activityStatus === "stalled")
+        return "work stalled";
+    if (node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return "work still in flight";
+    if (node.workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")))
+        return "a worker is still running";
+    if (node.alerts.length > 0)
+        return node.alerts.length === 1 ? "1 open alert" : `${node.alerts.length} open alerts`;
+    const unmet = (node.plan?.gates ?? []).filter((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
+    if (unmet.length)
+        return unmet.length === 1 ? `unmet gate: ${unmet[0].label}` : `${unmet.length} unmet gates`;
+    return undefined;
+}

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

@@ -57,6 +57,15 @@ export function deriveStatus(session, job, recentEvents = [], now = Date.now())
     if (blockedEventIsCurrent) {
         return { status: "waiting_on_you", stale: false };
     }
+    // A job the runtime still calls working is working, even while its own
+    // session record reads idle. A manager sits quiet between turns while the
+    // subagents it dispatched keep running, and that gap was presenting as an
+    // idle mission on a board where workers were visibly reporting progress.
+    // A job left "working" by a dead process ages out into stalled upstream,
+    // where the elapsed time is known.
+    if (STALE_JOB_STATES.has(job?.state ?? "")) {
+        return { status: "working", stale: false };
+    }
     if (job?.state === "done") {
         return { status: "done", stale: false };
     }

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

@@ -57,6 +57,8 @@ export interface ClaudeJob {
      * needs/detail — the full conversational reply lives in the timeline.
      */
     lastText?: string;
+    /** Hive-augmented: what the model said between tool calls this turn, oldest first. */
+    progressTexts?: string[];
     children: JobChild[];
     intent?: string;
     name?: string;
@@ -74,12 +76,32 @@ export interface ClaudeJob {
     backend?: string;
     template?: string;
 }
+/** An image pasted into a mission conversation and written to disk for the agent to read. */
+export interface MessageAttachment {
+    id: string;
+    name: string;
+    mediaType: string;
+    bytes: number;
+    /** Absolute path on the Hive host — what the agent is told to open. */
+    path: string;
+    /** Server route the web UI renders the thumbnail from. */
+    url: string;
+}
 export interface MissionMessage {
     id: string;
     role: "user" | "assistant";
     text: string;
     createdAt: number;
     jobId: string;
+    /** `update`: something the agent said on the way to its reply, shown compactly. */
+    kind?: "reply" | "update";
+    attachments?: MessageAttachment[];
+    /**
+     * A scheduled loop pass that found nothing to do. Consecutive quiet runs
+     * collapse into one row in the transcript so they cannot bury the runs that
+     * mattered — the messages themselves are still kept, and still readable.
+     */
+    noop?: boolean;
 }
 /** @deprecated Use MissionMessage. */
 export type ThreadMessage = MissionMessage;
@@ -87,6 +109,22 @@ export interface WorkerActivity extends JobFanEntry {
     jobId: string;
     jobState: string;
     jobUpdatedAt?: number;
+    /** Other provider ids and delegation labels that refer to this same worker. */
+    aliases?: string[];
+    /** Plan task ids delegated to this worker. */
+    taskIds?: string[];
+}
+/**
+ * Structured worker attribution for a hook firing. Replaces overloading one
+ * string with an agent id, an agent *type*, and a human label: only `agentId`
+ * may create a worker identity, and `parentAgentId` marks a nested agent whose
+ * activity belongs to its parent.
+ */
+export interface WorkerRef {
+    agentId?: string;
+    agentType?: string;
+    label?: string;
+    parentAgentId?: string;
 }
 export interface MissionSummary {
     id: string;
@@ -164,6 +202,64 @@ export interface ClaudeSkillSummary {
     argumentHint?: string;
     source: "project" | "user" | "plugin" | "built-in" | "claude";
 }
+/**
+ * A subagent persona the conversation can address by name with `@qa-engineer`.
+ *
+ * These are the `.md` files under `.claude/agents`, the same ones the CLI
+ * offers — Hive discovers them so the composer can complete them, and passes
+ * the mention through untouched for the session's own agent loader to resolve.
+ */
+export interface ClaudeAgentSummary {
+    name: string;
+    description?: string;
+    source: "project" | "user";
+}
+/**
+ * A recurring prompt Hive re-sends to a mission on an interval.
+ *
+ * Hive owns the schedule rather than delegating to the agent's own `/loop`:
+ * that one lives inside a session's runtime with nothing on disk, so it can be
+ * neither listed nor stopped from outside. A loop you cannot turn off is worse
+ * than no loop at all.
+ */
+export interface MissionLoop {
+    id: string;
+    missionId: string;
+    missionName?: string;
+    prompt: string;
+    intervalMs: number;
+    status: "active" | "stopped";
+    createdAt: number;
+    /** Absent until the loop has fired at least once. */
+    lastRunAt?: number;
+    nextRunAt: number;
+    runCount: number;
+    /** Why it stopped, when it stopped itself rather than being stopped. */
+    stoppedReason?: string;
+}
+/**
+ * One background watcher a mission's agent started and has not finished.
+ *
+ * Named, because "3 monitors running" tells you nothing about whether the one
+ * you care about is among them. The runtime records each in the job's fan with
+ * its own id and the label the agent gave it.
+ */
+export interface MissionMonitor {
+    missionId: string;
+    missionName: string;
+    /** The turn that owns it — the only thing that can actually be stopped. */
+    jobId: string;
+    /** The runtime's id for this watcher. */
+    id: string;
+    label: string;
+    startedAt: number;
+    /** The owning turn's latest note, for context. */
+    detail?: string;
+}
+export interface ActiveTasks {
+    loops: MissionLoop[];
+    monitors: MissionMonitor[];
+}
 export interface NativeCommand {
     name: string;
     description: string;
@@ -177,6 +273,91 @@ export interface NativeCommand {
  * Only commands verified to print a text report in headless mode belong here.
  */
 export declare const NATIVE_COMMANDS: NativeCommand[];
+/**
+ * Skills compiled into the Claude CLI itself, rather than installed under
+ * `.claude/skills` or a plugin cache.
+ *
+ * Skill discovery walks the filesystem, so it can only ever find skills that
+ * exist as files — a built-in has no `SKILL.md` anywhere on disk and is
+ * therefore invisible to it. Offering them means naming them.
+ *
+ * Unlike `NATIVE_COMMANDS` these are *not* intercepted: they are ordinary
+ * prompts that the session's own skill loader handles, so they go down the
+ * normal send path with their arguments intact. `matchNativeCommand` only ever
+ * claims a bare `/name` that appears in `NATIVE_COMMANDS`, so nothing here is
+ * at risk of being run out-of-band by mistake.
+ */
+export declare const BUILTIN_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. */
+    mode: "interactive" | "follow_up" | "read_only";
+    connected: boolean;
+    acceptsInterrupt: boolean;
+    acceptsResize: boolean;
+    provider?: MissionProvider;
+    providerVersion?: string;
+    /** Detected locally but not yet promoted to Hive's production input path. */
+    detectedInteractiveTransport?: "codex_app_server" | "claude_stream_json";
+    /** Human-readable explanation for a non-interactive mode. */
+    reason?: string;
+}
+export interface TerminalStreamEvent {
+    streamId: string;
+    sequence: number;
+    missionId: string;
+    source: string;
+    ts: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface TerminalInputReceipt {
+    clientInputId: string;
+    status: "accepted" | "duplicate";
+    streamId: string;
+    sequence: number;
+    turnId?: string;
+}
+export interface TranscriptSource {
+    /** `orchestrator`, or the worker's native agent id. */
+    id: string;
+    label: string;
+    kind: "orchestrator" | "worker";
+    sessionId: string;
+    /** The subagent's declared type, when the provider recorded one. */
+    agentType?: string;
+    updatedAt?: number;
+    bytes?: number;
+    terminal?: TerminalCapability;
+}
+export type TranscriptEntryKind = 
+/** Something a person (or the orchestrator) actually asked for. */
+"prompt"
+/** Instructions the runtime injected into the turn: a skill, a reminder. */
+ | "injected" | "assistant" | "thinking" | "tool_use" | "tool_result";
+/** One line of the transcript, shaped the way a terminal prints it. */
+export interface TranscriptEntry {
+    kind: TranscriptEntryKind;
+    ts?: number;
+    /** Prose, for every kind but a tool call and its result. */
+    text?: string;
+    /** Tool name, for `tool_use`. */
+    tool?: string;
+    /** `Bash(npm test)` — the tool plus the one field that says what it is doing. */
+    invocation?: string;
+    /** The tool call's full input, pretty-printed, for the expanded view. */
+    input?: string;
+    /** The tool result's body, for `tool_result`. */
+    output?: string;
+    /** Lines in the untruncated output, so the UI can say what it collapsed. */
+    lines?: number;
+    isError?: boolean;
+    /** Pairs a result with the call it answers. */
+    toolUseId?: string;
+    /** The skill the runtime attributed this entry to, when it recorded one. */
+    skill?: string;
+    truncated?: boolean;
+}
 export type MissionLifecycleStatus = "active" | "ready_for_review" | "paused" | "completed" | "failed" | "archived";
 export interface MissionMessagesPage {
     messages: MissionMessage[];
@@ -295,10 +476,19 @@ export interface HiveEvent {
     command?: string;
     artifactPath?: string;
     outcome?: "success" | "failure";
+    /**
+     * The tool call left work running in the background. The provider ends the
+     * agent's turn and wakes it when that work finishes, so a worker with an
+     * outstanding backgrounded command has not finished — it is waiting.
+     */
+    backgrounded?: boolean;
     /** For source: 'custom' — one of the orchestrator lifecycle phases. */
-    phase?: "delegating" | "worker_started" | "worker_reported" | "reviewing" | "blocked_on_user" | "ready_for_review" | "plan_updated" | "decision_resolved" | "resuming" | "custom";
+    phase?: "delegating" | "worker_started" | "worker_reported" | "reviewing" | "blocked_on_user" | "ready_for_review" | "plan_updated" | "phase_started" | "phase_completed" | "task_started" | "task_completed" | "gate_satisfied" | "gate_failed" | "gate_waived" | "decision_resolved" | "resuming" | "custom";
     detail: string;
+    /** Best-effort display name for the attributed worker. */
     targetWorker?: string;
+    /** Structured attribution; `workerRef.agentId` is the only identity source. */
+    workerRef?: WorkerRef;
     targetTask?: string;
     decisionId?: string;
     decisionKind?: DecisionKind;

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

@@ -12,3 +12,30 @@ export const NATIVE_COMMANDS = [
     { name: "cost", description: "Show the cost and duration breakdown for Claude usage", scope: "account" },
     { name: "context", description: "Show this mission session's context window usage", scope: "session" },
 ];
+/**
+ * Skills compiled into the Claude CLI itself, rather than installed under
+ * `.claude/skills` or a plugin cache.
+ *
+ * Skill discovery walks the filesystem, so it can only ever find skills that
+ * exist as files — a built-in has no `SKILL.md` anywhere on disk and is
+ * therefore invisible to it. Offering them means naming them.
+ *
+ * Unlike `NATIVE_COMMANDS` these are *not* intercepted: they are ordinary
+ * prompts that the session's own skill loader handles, so they go down the
+ * normal send path with their arguments intact. `matchNativeCommand` only ever
+ * claims a bare `/name` that appears in `NATIVE_COMMANDS`, so nothing here is
+ * at risk of being run out-of-band by mistake.
+ */
+export const BUILTIN_SKILLS = [
+    {
+        name: "loop",
+        description: "Re-send a prompt to this mission on a schedule Hive owns, so it can be listed and stopped",
+        argumentHint: "[interval] <prompt> · list · stop [id]",
+        source: "built-in",
+    },
+    {
+        name: "tasks",
+        description: "Show every loop and background monitor running, here and across the fleet",
+        source: "built-in",
+    },
+];

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

@@ -0,0 +1,14 @@
+import type { WorkerActivity } from "./types.js";
+/** The manager's own agent name. Never a worker on the floor. */
+export declare const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
+/** Every string that refers to one canonical worker. */
+export declare function workerRefs(worker: Pick<WorkerActivity, "id" | "label" | "aliases" | "taskIds">): string[];
+/**
+ * The single worker-identity comparison for the whole app.
+ *
+ * The server resolves every provider name, delegation label, and plan task id
+ * for a worker into one canonical identity and publishes the rest as aliases,
+ * so consumers can compare exactly. Prefix and substring matching used to
+ * stand in for this and could silently merge two workers or split one.
+ */
+export declare function matchesWorker(target: string | undefined, worker: Pick<WorkerActivity, "id" | "label" | "aliases" | "taskIds">): boolean;

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

@@ -0,0 +1,22 @@
+/** The manager's own agent name. Never a worker on the floor. */
+export const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
+/** Every string that refers to one canonical worker. */
+export function workerRefs(worker) {
+    return [worker.id, worker.label, ...(worker.aliases ?? []), ...(worker.taskIds ?? [])]
+        .map((value) => value?.trim())
+        .filter((value) => Boolean(value));
+}
+/**
+ * The single worker-identity comparison for the whole app.
+ *
+ * The server resolves every provider name, delegation label, and plan task id
+ * for a worker into one canonical identity and publishes the rest as aliases,
+ * so consumers can compare exactly. Prefix and substring matching used to
+ * stand in for this and could silently merge two workers or split one.
+ */
+export function matchesWorker(target, worker) {
+    const wanted = target?.trim().toLowerCase();
+    if (!wanted)
+        return false;
+    return workerRefs(worker).some((ref) => ref.toLowerCase() === wanted);
+}

package/package.json

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

package/packages/server/dist/agents/agentDiscovery.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { requireWorkingDirectory } from "../paths/pathResolver.js";
+/**
+ * An agent declares its own name in frontmatter; the filename is only a
+ * fallback, because the two are allowed to disagree and the CLI resolves a
+ * mention against the declared name.
+ */
+function metadata(file, fallback) {
+    let text = "";
+    try {
+        text = fs.readFileSync(file, "utf8").slice(0, 8192);
+    }
+    catch {
+        return { name: fallback };
+    }
+    const frontmatter = text.match(/^---\s*\n([\s\S]*?)\n---/);
+    const field = (name) => frontmatter?.[1].match(new RegExp(`^${name}:\\s*(.+)$`, "m"))?.[1]?.trim().replace(/^['"]|['"]$/g, "");
+    return { name: field("name") || fallback, description: field("description") };
+}
+function collect(root, source) {
+    if (!fs.existsSync(root))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries.flatMap((entry) => {
+        if (entry.name.startsWith(".") || !entry.isFile() || !entry.name.endsWith(".md"))
+            return [];
+        return [{ ...metadata(path.join(root, entry.name), path.basename(entry.name, ".md")), source }];
+    });
+}
+/**
+ * Project agents shadow user agents of the same name, matching how the CLI
+ * resolves them — the more specific definition is the one a mention will hit,
+ * so it is the one the composer should offer.
+ *
+ * A missing or unusable working directory is not an error here. A mission
+ * whose worktree has been reclaimed still resolves `@reviewer` against the
+ * user's own agents, and failing the whole lookup left the composer with
+ * nothing to complete at all — while `/` kept working, because its list has
+ * built-in entries that never depended on discovery.
+ */
+export function discoverAgents(cwd) {
+    const claudeConfig = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+    let projectAgents = [];
+    try {
+        projectAgents = collect(path.join(requireWorkingDirectory(cwd), ".claude", "agents"), "project");
+    }
+    catch { /* no usable project directory; the user's own agents still apply */ }
+    const all = [
+        ...collect(path.join(claudeConfig, "agents"), "user"),
+        ...projectAgents,
+    ];
+    const unique = new Map();
+    for (const agent of all)
+        unique.set(agent.name, agent);
+    return [...unique.values()].sort((a, b) => a.name.localeCompare(b.name));
+}