@shanesaravia/hive 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 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.

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.

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

@@ -76,6 +76,17 @@ 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";
@@ -84,6 +95,13 @@ export interface MissionMessage {
     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;
@@ -184,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;
@@ -197,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[];
@@ -322,7 +483,7 @@ export interface HiveEvent {
      */
     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;

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shanesaravia/hive",
   "private": false,
-  "version": "0.3.0",
+  "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));
+}