hivehq 2.0.0

package/dist/src/server/sqlite-schema.js

@@ -0,0 +1,353 @@
+import { applySchemaVersion5 } from './sqlite-schema-v5.js';
+import { applySchemaVersion7 } from './sqlite-schema-v7.js';
+import { applySchemaVersion8 } from './sqlite-schema-v8.js';
+import { applySchemaVersion9 } from './sqlite-schema-v9.js';
+import { applySchemaVersion10 } from './sqlite-schema-v10.js';
+import { applySchemaVersion11 } from './sqlite-schema-v11.js';
+import { applySchemaVersion12 } from './sqlite-schema-v12.js';
+import { applySchemaVersion13 } from './sqlite-schema-v13.js';
+import { applySchemaVersion14 } from './sqlite-schema-v14.js';
+import { applySchemaVersion15 } from './sqlite-schema-v15.js';
+import { applySchemaVersion16 } from './sqlite-schema-v16.js';
+import { applySchemaVersion17 } from './sqlite-schema-v17.js';
+import { applySchemaVersion18 } from './sqlite-schema-v18.js';
+import { applySchemaVersion19 } from './sqlite-schema-v19.js';
+import { applySchemaVersion20 } from './sqlite-schema-v20.js';
+import { applySchemaVersion21 } from './sqlite-schema-v21.js';
+import { applySchemaVersion22 } from './sqlite-schema-v22.js';
+import { applySchemaVersion23 } from './sqlite-schema-v23.js';
+import { applySchemaVersion24 } from './sqlite-schema-v24.js';
+import { applySchemaVersion25 } from './sqlite-schema-v25.js';
+import { applySchemaVersion26 } from './sqlite-schema-v26.js';
+import { applySchemaVersion27 } from './sqlite-schema-v27.js';
+import { applySchemaVersion28 } from './sqlite-schema-v28.js';
+export const CURRENT_SCHEMA_VERSION = 28;
+// Idempotent column-add helper. SQLite doesn't have `ALTER TABLE … ADD COLUMN
+// IF NOT EXISTS`, so PRAGMA-check first. Safe to call on every init; required
+// for foreign-built DBs where the version-gated migration is skipped.
+const ensureColumn = (db, table, column, definition) => {
+    const present = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name));
+    if (!present.has(column)) {
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    }
+};
+export const initializeRuntimeDatabase = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS workers (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      last_session_id TEXT,
+      role TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      worker_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      from_agent_id TEXT,
+      to_agent_id TEXT,
+      text TEXT,
+      status TEXT,
+      artifacts TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_launch_configs (
+      workspace_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      command TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      command_preset_id TEXT,
+      interactive_command TEXT,
+      preset_augmentation_disabled INTEGER NOT NULL DEFAULT 0,
+      resume_args_template TEXT,
+      session_id_capture_json TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (workspace_id, agent_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_runs (
+      run_id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      pid INTEGER,
+      status TEXT NOT NULL,
+      exit_code INTEGER,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      agent_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL,
+      last_session_id TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (workspace_id, agent_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS dispatches (
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
+      workspace_id TEXT NOT NULL,
+      from_agent_id TEXT,
+      to_agent_id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      delivered_at INTEGER,
+      submitted_at INTEGER,
+      reported_at INTEGER,
+      report_text TEXT,
+      artifacts TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_dispatches_workspace_created_at
+      ON dispatches (workspace_id, sequence);
+
+    CREATE INDEX IF NOT EXISTS idx_dispatches_open_by_worker
+      ON dispatches (workspace_id, to_agent_id, status, sequence);
+
+    CREATE TABLE IF NOT EXISTS report_outbox (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      target_agent_id TEXT NOT NULL,
+      dispatch_id TEXT NOT NULL UNIQUE,
+      payload TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      delivered_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_report_outbox_pending
+      ON report_outbox (workspace_id, target_agent_id, delivered_at, created_at);
+
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      script_hash TEXT,
+      name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      phase TEXT,
+      args TEXT,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      error TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_workspace
+      ON workflow_runs (workspace_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      cron TEXT NOT NULL,
+      args TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at INTEGER,
+      next_run_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_due
+      ON workflow_schedules (enabled, next_run_at);
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_workspace
+      ON workflow_schedules (workspace_id, created_at);
+  `);
+    // Idempotent column additions — run on every init regardless of
+    // schema_version. The v19 migration adds these columns but is gated on
+    // !appliedVersions.has(19); a foreign-built DB whose v19 was a DIFFERENT
+    // migration leaves these absent. PRAGMA + ALTER here makes the writes safe.
+    ensureColumn(db, 'workers', 'ephemeral', 'INTEGER NOT NULL DEFAULT 0');
+    ensureColumn(db, 'workers', 'spawned_by', 'TEXT');
+    ensureColumn(db, 'dispatches', 'workflow_run_id', 'TEXT');
+    ensureColumn(db, 'dispatches', 'step_index', 'INTEGER');
+    // M9 — phase + label on dispatches so the workflow UI can render the
+    // phase tree + agent fleet view (mirrors Claude Code's /workflows view).
+    ensureColumn(db, 'dispatches', 'phase', 'TEXT');
+    ensureColumn(db, 'dispatches', 'label', 'TEXT');
+    // M10: capture the workflow script's `return` value so the UI can render
+    // a single canonical "Result" panel and the orchestrator notification can
+    // include it.
+    ensureColumn(db, 'workflow_runs', 'result', 'TEXT');
+    // TIER 2 #5: parent_run_id lets the Drawer render nested workflow() calls
+    // as a tree (child runs indented under their parent). Without it,
+    // nested runs were flat and the user couldn't tell which child
+    // belonged to which parent. Null on top-level runs.
+    ensureColumn(db, 'workflow_runs', 'parent_run_id', 'TEXT');
+    // TIER 2 #3: log() narrator pipeline. Authors call `log('Discovered 47
+    // endpoints')` from a workflow script; rows live here and stream to
+    // the Drawer's narrator lane + the last few lines are appended to
+    // the orchestrator's completion notification.
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_run_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      message TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_run_logs_run
+      ON workflow_run_logs (run_id, id);
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_dispatches_workflow ON dispatches (workflow_run_id, step_index)');
+    const versions = db
+        .prepare('SELECT version FROM schema_version ORDER BY version ASC')
+        .all();
+    const appliedVersions = new Set(versions.map((row) => row.version));
+    if (!appliedVersions.has(1)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(1, Date.now());
+        appliedVersions.add(1);
+    }
+    if (!appliedVersions.has(2)) {
+        const workerColumns = new Set(db.prepare('PRAGMA table_info(workers)').all().map((column) => column.name));
+        if (workerColumns.size > 0 && !workerColumns.has('description')) {
+            db.exec('ALTER TABLE workers ADD COLUMN description TEXT');
+        }
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(2, Date.now());
+    }
+    if (!appliedVersions.has(3)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(3, Date.now());
+        appliedVersions.add(3);
+    }
+    if (!appliedVersions.has(4)) {
+        const messageColumns = new Set(db.prepare('PRAGMA table_info(messages)').all().map((column) => column.name));
+        if (messageColumns.size > 0 && !messageColumns.has('artifacts')) {
+            db.exec('ALTER TABLE messages ADD COLUMN artifacts TEXT');
+        }
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(4, Date.now());
+    }
+    if (!appliedVersions.has(5)) {
+        applySchemaVersion5(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(5, Date.now());
+    }
+    if (!appliedVersions.has(6)) {
+        const launchConfigColumns = new Set(db.prepare('PRAGMA table_info(agent_launch_configs)').all().map((column) => column.name));
+        if (!launchConfigColumns.has('resume_args_template')) {
+            db.exec('ALTER TABLE agent_launch_configs ADD COLUMN resume_args_template TEXT');
+        }
+        if (!launchConfigColumns.has('session_id_capture_json')) {
+            db.exec('ALTER TABLE agent_launch_configs ADD COLUMN session_id_capture_json TEXT');
+        }
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_sessions (
+        agent_id TEXT NOT NULL,
+        workspace_id TEXT NOT NULL,
+        last_session_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (workspace_id, agent_id)
+      );
+    `);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(6, Date.now());
+    }
+    if (!appliedVersions.has(7)) {
+        applySchemaVersion7(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(7, Date.now());
+    }
+    if (!appliedVersions.has(8)) {
+        applySchemaVersion8(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(8, Date.now());
+    }
+    if (!appliedVersions.has(9)) {
+        applySchemaVersion9(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(9, Date.now());
+    }
+    if (!appliedVersions.has(10)) {
+        applySchemaVersion10(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(10, Date.now());
+    }
+    if (!appliedVersions.has(11)) {
+        applySchemaVersion11(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(11, Date.now());
+    }
+    if (!appliedVersions.has(12)) {
+        applySchemaVersion12(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(12, Date.now());
+    }
+    if (!appliedVersions.has(13)) {
+        applySchemaVersion13(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(13, Date.now());
+    }
+    if (!appliedVersions.has(14)) {
+        applySchemaVersion14(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(14, Date.now());
+    }
+    if (!appliedVersions.has(15)) {
+        applySchemaVersion15(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(15, Date.now());
+    }
+    if (!appliedVersions.has(16)) {
+        applySchemaVersion16(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(16, Date.now());
+    }
+    if (!appliedVersions.has(17)) {
+        applySchemaVersion17(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(17, Date.now());
+    }
+    if (!appliedVersions.has(18)) {
+        applySchemaVersion18(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(18, Date.now());
+    }
+    if (!appliedVersions.has(19)) {
+        applySchemaVersion19(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(19, Date.now());
+    }
+    if (!appliedVersions.has(20)) {
+        applySchemaVersion20(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(20, Date.now());
+    }
+    if (!appliedVersions.has(21)) {
+        applySchemaVersion21(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(21, Date.now());
+    }
+    if (!appliedVersions.has(22)) {
+        applySchemaVersion22(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(22, Date.now());
+    }
+    if (!appliedVersions.has(23)) {
+        applySchemaVersion23(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(23, Date.now());
+    }
+    if (!appliedVersions.has(24)) {
+        applySchemaVersion24(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(24, Date.now());
+    }
+    applySchemaVersion25(db);
+    if (!appliedVersions.has(25)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(25, Date.now());
+    }
+    applySchemaVersion26(db);
+    if (!appliedVersions.has(26)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(26, Date.now());
+    }
+    if (!appliedVersions.has(27)) {
+        applySchemaVersion27(db, { rebuild: true });
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(27, Date.now());
+    }
+    else {
+        applySchemaVersion27(db, { rebuild: false });
+    }
+    applySchemaVersion28(db);
+    if (!appliedVersions.has(28)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(28, Date.now());
+    }
+};

package/dist/src/server/startup-command-parser.d.ts

@@ -0,0 +1,20 @@
+export declare const createStartupCommandLaunch: (startupCommand: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => {
+    args: string[];
+    command: string;
+};
+export declare const getStartupCommandExecutable: (startupCommand: string) => string | null;
+/**
+ * Reduce an executable token to its canonical brand id for preset lookup
+ * and CLI-behavior dispatch. Splits on both '\\' and '/' so Windows paths
+ * normalize even when the host runs `node:path.posix` (macOS test runners,
+ * mixed-slash paths from npm-installed shims).
+ *
+ * Examples (return value in parens):
+ *   'claude'                                  → 'claude'
+ *   'claude.CMD'                              → 'claude'
+ *   'C:\\Program Files\\nodejs\\claude.cmd'   → 'claude'
+ *   '/usr/local/bin/codex'                    → 'codex'
+ *   'C:/Users/me/opencode.CMD'                → 'opencode'
+ *   'my-custom-runner.bat'                    → 'my-custom-runner'
+ */
+export declare const normalizeExecutableToken: (token: string | null | undefined) => string | null;

package/dist/src/server/startup-command-parser.js

@@ -0,0 +1,72 @@
+import { basename } from 'node:path';
+const getEnvValue = (env, key, platform = process.platform) => {
+    if (platform !== 'win32')
+        return env[key];
+    if (Object.hasOwn(env, key))
+        return env[key];
+    const matchedKey = Object.keys(env)
+        .filter((item) => item.toLowerCase() === key.toLowerCase())
+        .at(-1);
+    return matchedKey ? env[matchedKey] : undefined;
+};
+const createPosixShellArgs = (shell, command) => {
+    const shellName = basename(shell).toLowerCase();
+    if (shellName.includes('bash') || shellName.includes('zsh') || shellName.includes('ksh')) {
+        return ['-lic', command];
+    }
+    if (shellName.includes('fish'))
+        return ['-ic', command];
+    return ['-ic', command];
+};
+export const createStartupCommandLaunch = (startupCommand, env = process.env, platform = process.platform) => {
+    const command = startupCommand.trim();
+    if (platform === 'win32') {
+        return {
+            args: ['/d', '/s', '/c', command],
+            command: getEnvValue(env, 'ComSpec', platform) ?? 'cmd.exe',
+        };
+    }
+    const shell = env.SHELL || '/bin/sh';
+    return {
+        args: createPosixShellArgs(shell, command),
+        command: shell,
+    };
+};
+export const getStartupCommandExecutable = (startupCommand) => {
+    const command = startupCommand.trim();
+    if (!command)
+        return null;
+    // Match alternates, in order:
+    //   1. Double-quoted token (may contain spaces, backslashes, slashes)
+    //   2. Single-quoted token
+    //   3. Bare token: no whitespace, no embedded quotes
+    // An unbalanced opening quote falls through all three and returns null.
+    // The previous regex used `[^'"\s]+` for the captured run, which forbade
+    // spaces and therefore returned null for `"C:\Program Files\…claude.cmd"`
+    // — the standard Windows install layout. See the parser tests for the
+    // contract; brand identification belongs in agent-launch-resolver.
+    const match = /^"([^"]+)"|^'([^']+)'|^([^\s'"]+)/.exec(command);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+};
+/**
+ * Reduce an executable token to its canonical brand id for preset lookup
+ * and CLI-behavior dispatch. Splits on both '\\' and '/' so Windows paths
+ * normalize even when the host runs `node:path.posix` (macOS test runners,
+ * mixed-slash paths from npm-installed shims).
+ *
+ * Examples (return value in parens):
+ *   'claude'                                  → 'claude'
+ *   'claude.CMD'                              → 'claude'
+ *   'C:\\Program Files\\nodejs\\claude.cmd'   → 'claude'
+ *   '/usr/local/bin/codex'                    → 'codex'
+ *   'C:/Users/me/opencode.CMD'                → 'opencode'
+ *   'my-custom-runner.bat'                    → 'my-custom-runner'
+ */
+export const normalizeExecutableToken = (token) => {
+    if (!token)
+        return null;
+    const lastSegment = token.replace(/^.*[\\/]/, '');
+    if (!lastSegment)
+        return null;
+    return lastSegment.toLowerCase().replace(/\.(cmd|bat|exe|ps1)$/u, '');
+};

package/dist/src/server/system-message.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a system-injected message body in an out-of-band XML envelope so the
+ * agent attends to it as system content rather than mistaking it for user
+ * input or its own output. `<hive-system-reminder>` is reserved for the short
+ * re-anchoring action menu appended at a message tail; this `<hive-system-message>`
+ * tag carries larger injected bodies (crash-recovery / restart env-sync).
+ */
+export declare const wrapSystemMessage: (content: string) => string;

package/dist/src/server/system-message.js

@@ -0,0 +1,8 @@
+/**
+ * Wraps a system-injected message body in an out-of-band XML envelope so the
+ * agent attends to it as system content rather than mistaking it for user
+ * input or its own output. `<hive-system-reminder>` is reserved for the short
+ * re-anchoring action menu appended at a message tail; this `<hive-system-message>`
+ * tag carries larger injected bodies (crash-recovery / restart env-sync).
+ */
+export const wrapSystemMessage = (content) => `<hive-system-message>\n${content}\n</hive-system-message>`;

package/dist/src/server/task-deps.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Optional, read-only task-dependency support for `.hive/tasks.md`.
+ *
+ * A task line may carry a trailing `[needs: #2, #5]` annotation declaring that
+ * it depends on other tasks (referenced by their 1-based position among the
+ * GFM task-list items). `team next` uses this to surface the tasks that are
+ * currently runnable — not done, and with every dependency already checked off.
+ *
+ * Deliberately scoped: parsing happens here on the server only and is purely a
+ * READ — Hive never auto-dispatches a runnable task and never writes the
+ * annotation back into tasks.md (that file stays a human/orchestrator-edited,
+ * git-mergeable artifact). The web task renderer is intentionally left
+ * untouched, so the annotation just shows as literal text in the UI.
+ */
+export interface ParsedTaskLine {
+    /** 1-based position among task-list items — the `#n` that `[needs:]` uses. */
+    index: number;
+    done: boolean;
+    text: string;
+    needs: number[];
+}
+export interface RunnableTask {
+    index: number;
+    text: string;
+}
+export declare const parseTasksWithDeps: (markdown: string) => ParsedTaskLine[];
+/**
+ * Tasks that can be worked right now: not yet done, and every `[needs:]`
+ * dependency is a task that exists AND is checked off. A dependency on a
+ * non-existent `#n`, or on a task that isn't done, withholds the task.
+ */
+export declare const computeRunnableTasks: (markdown: string) => RunnableTask[];

package/dist/src/server/task-deps.js

@@ -0,0 +1,40 @@
+const TASK_LINE = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/;
+const NEEDS = /\[needs:\s*([#\d,\s]+)\]\s*$/i;
+export const parseTasksWithDeps = (markdown) => {
+    const tasks = [];
+    let index = 0;
+    for (const line of markdown.split('\n')) {
+        const match = TASK_LINE.exec(line);
+        if (!match)
+            continue;
+        index += 1;
+        const done = (match[1] ?? ' ').toLowerCase() === 'x';
+        let text = (match[2] ?? '').trim();
+        const needs = [];
+        const needsMatch = NEEDS.exec(text);
+        if (needsMatch) {
+            for (const token of (needsMatch[1] ?? '').split(',')) {
+                const parsed = Number.parseInt(token.replace('#', '').trim(), 10);
+                if (Number.isInteger(parsed) && parsed > 0)
+                    needs.push(parsed);
+            }
+            // Drop the trailing annotation from the human-readable text.
+            text = text.slice(0, needsMatch.index).trim();
+        }
+        tasks.push({ index, done, text, needs });
+    }
+    return tasks;
+};
+/**
+ * Tasks that can be worked right now: not yet done, and every `[needs:]`
+ * dependency is a task that exists AND is checked off. A dependency on a
+ * non-existent `#n`, or on a task that isn't done, withholds the task.
+ */
+export const computeRunnableTasks = (markdown) => {
+    const tasks = parseTasksWithDeps(markdown);
+    const doneByIndex = new Map(tasks.map((task) => [task.index, task.done]));
+    return tasks
+        .filter((task) => !task.done)
+        .filter((task) => task.needs.every((dep) => doneByIndex.get(dep) === true))
+        .map((task) => ({ index: task.index, text: task.text }));
+};

package/dist/src/server/tasks-file-watcher.d.ts

@@ -0,0 +1,47 @@
+import { type ChokidarOptions } from 'chokidar';
+import { type FeatureFlags } from './feature-flags.js';
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
+/**
+ * Watcher configuration. The atomic-save option matters on Windows: VS
+ * Code, Cursor, Notepad++, and the editor inside Hive itself all save
+ * by writing a temp file and renaming it over the target. On
+ * ReadDirectoryChangesW (Windows' native fs-event backend) that rename
+ * invalidates the file-handle the chokidar watcher held for the
+ * single-file path, and subsequent edits would emit no events at all.
+ *
+ * `atomic: 100` tells chokidar to correlate an unlink+add pair within
+ * a 100ms window as a single `change` event — collapsing the rename
+ * into one logical "the file was modified" notification and rebinding
+ * the underlying watch handle. Without it the tasks panel goes deaf
+ * to changes the user makes outside the app after the first save.
+ *
+ * We intentionally do NOT set `awaitWriteFinish` here. It would help
+ * even more on Windows (waits for the file size to stabilise before
+ * emitting), but it also throttles every emission by `stabilityThreshold`
+ * — clashing with continuous-write workflows (a worker streaming
+ * updates into tasks.md every 100ms would never see an emit). The
+ * `atomic` option alone covers atomic-save; if a future workspace
+ * needs stronger settling behaviour we can promote it then.
+ *
+ * Exported so the configuration is testable in isolation.
+ */
+export declare const TASKS_WATCHER_OPTIONS: ChokidarOptions;
+export declare const buildTasksWatcherOptions: (workspacePath: string, platform?: NodeJS.Platform) => ChokidarOptions;
+export declare const getTasksWatcherReadyTimeoutMs: (workspacePath: string, platform?: NodeJS.Platform) => number;
+export declare const isTasksFileEvent: (tasksPath: string, changedPath: string | Buffer | undefined, platform?: NodeJS.Platform) => boolean;
+export interface TasksFileWatcher {
+    close: () => Promise<void>;
+    start: (workspaceId: string, workspacePath: string) => Promise<void>;
+    stop: (workspaceId: string) => Promise<void>;
+}
+export declare const createTasksFileWatcher: ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }: {
+    onTasksUpdated: (workspaceId: string, content: string) => void;
+    /** Lets the freshly-written `.hive/PROTOCOL.md` state the workspace's
+     *  workflow CLI default + allowlist. Optional: omitted → the doc renders
+     *  the unrestricted default. */
+    getWorkflowCliPolicy?: () => WorkflowCliPolicy;
+    /** Resolves the live experimental flags. PROTOCOL.md omits the workflow DSL
+     *  + `team workflow` commands when `workflowsEnabled` is off, and the
+     *  team-sizing rule when `autostaffEnabled` is off. Omitted → all off. */
+    getFlags?: () => FeatureFlags;
+}) => TasksFileWatcher;