@tt-a1i/hive 1.4.4 → 1.6.0

package/dist/src/server/session-capture-codex.d.ts

@@ -1,6 +1,6 @@
-export declare const getCodexHome: (pattern?: string) => string;
+export declare const getCodexHome: (pattern?: string, platform?: NodeJS.Platform) => string;
 export declare const readCodexSessionFirstLine: (filePath: string, maxBytes?: number) => string | null;
-export declare const hasCodexSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
-export declare const snapshotCodexSessionIds: (cwd: string, codexHome?: string) => Set<string>;
+export declare const hasCodexSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, codexHome?: string) => boolean;
+export declare const snapshotCodexSessionIds: (cwd: string, codexHome?: string, platform?: NodeJS.Platform) => Set<string>;
 export declare const captureCodexSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, codexHome?: string) => Promise<void>;
 export declare const codexSessionStoreExists: (codexHome?: string) => boolean;

package/dist/src/server/session-capture-codex.js

@@ -2,19 +2,21 @@ import { closeSync, existsSync, openSync, readdirSync, readSync } from 'node:fs'
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, indexOfPathMarker } from './platform-path.js';
 const CODEX_SESSION_FILE = /^rollout-.*\.jsonl$/i;
+const CODEX_SESSIONS_MARKER = '/sessions/';
 const CODEX_HEADER_READ_CHUNK_BYTES = 4096;
 const CODEX_HEADER_MAX_BYTES = 64 * 1024;
 const getDefaultCodexHome = () => process.env.CODEX_HOME ?? join(homedir(), '.codex');
 const expandHome = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-export const getCodexHome = (pattern) => {
+export const getCodexHome = (pattern, platform = process.platform) => {
     if (!pattern)
         return getDefaultCodexHome();
-    const markerIndex = pattern.indexOf('/sessions/');
+    const markerIndex = indexOfPathMarker(pattern, CODEX_SESSIONS_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultCodexHome();
     const rawRoot = pattern.slice(0, markerIndex);
-    if (rawRoot === '~/.codex' || rawRoot === '~/.codex/')
+    if (arePathsEqual(rawRoot, '~/.codex', platform) || arePathsEqual(rawRoot, '~/.codex/', platform))
         return getDefaultCodexHome();
     const root = expandHome(rawRoot);
     return root || getDefaultCodexHome();
@@ -78,13 +80,13 @@ const parseCodexSession = (filePath) => {
     const cwd = 'cwd' in payload && typeof payload.cwd === 'string' ? payload.cwd : null;
     return id && cwd ? { cwd, id } : null;
 };
-const listSessionIds = (cwd, codexHome = getDefaultCodexHome()) => {
+const listSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => {
     const sessionsRoot = join(codexHome, 'sessions');
     return walkSessionFiles(sessionsRoot)
         .flatMap((filePath) => {
         try {
             const session = parseCodexSession(filePath);
-            return session?.cwd === cwd ? [session.id] : [];
+            return session && arePathsEqual(session.cwd, cwd, platform) ? [session.id] : [];
         }
         catch {
             return [];
@@ -92,8 +94,8 @@ const listSessionIds = (cwd, codexHome = getDefaultCodexHome()) => {
     })
         .sort((left, right) => left.localeCompare(right));
 };
-export const hasCodexSession = (cwd, sessionId, pattern) => listSessionIds(cwd, getCodexHome(pattern)).includes(sessionId);
-export const snapshotCodexSessionIds = (cwd, codexHome = getDefaultCodexHome()) => new Set(listSessionIds(cwd, codexHome));
+export const hasCodexSession = (cwd, sessionId, pattern, platform = process.platform, codexHome = getCodexHome(pattern, platform)) => listSessionIds(cwd, codexHome, platform).includes(sessionId);
+export const snapshotCodexSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => new Set(listSessionIds(cwd, codexHome, platform));
 export const captureCodexSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, codexHome = getDefaultCodexHome()) => {
     await captureSessionIdWithCoordinator({
         intervalMs,

package/dist/src/server/session-capture-gemini.d.ts

@@ -1,4 +1,4 @@
-export declare const getGeminiHome: (pattern?: string) => string;
+export declare const getGeminiHome: (pattern?: string, platform?: NodeJS.Platform) => string;
 export declare const hasGeminiSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
 export declare const snapshotGeminiSessionIds: (cwd: string, geminiHome?: string) => Set<string>;
 export declare const captureGeminiSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, geminiHome?: string) => Promise<void>;

package/dist/src/server/session-capture-gemini.js

@@ -2,13 +2,15 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, indexOfPathMarker } from './platform-path.js';
 const GEMINI_SESSION_FILE = /^session-.*\.json$/i;
+const GEMINI_TMP_MARKER = '/tmp/';
 const getDefaultGeminiHome = () => process.env.HIVE_GEMINI_HOME ?? join(homedir(), '.gemini');
 const expandHome = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-export const getGeminiHome = (pattern) => {
+export const getGeminiHome = (pattern, platform = process.platform) => {
     if (!pattern)
         return getDefaultGeminiHome();
-    const markerIndex = pattern.indexOf('/tmp/');
+    const markerIndex = indexOfPathMarker(pattern, GEMINI_TMP_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultGeminiHome();
     const rawRoot = pattern.slice(0, markerIndex);
@@ -38,7 +40,8 @@ const listSessionIds = (cwd, geminiHome = getDefaultGeminiHome()) => {
             .filter((entry) => entry.isDirectory())
             .flatMap((entry) => {
             const projectDir = join(tmpRoot, entry.name);
-            if (readProjectRoot(projectDir) !== cwd)
+            const projectRoot = readProjectRoot(projectDir);
+            if (projectRoot === null || !arePathsEqual(projectRoot, cwd))
                 return [];
             const chatsDir = join(projectDir, 'chats');
             try {

package/dist/src/server/settings-store.d.ts

@@ -7,6 +7,9 @@ export interface SettingsStore {
     createRoleTemplate: (input: RoleTemplateInput) => RoleTemplateRecord;
     deleteCommandPreset: (id: string) => void;
     deleteRoleTemplate: (id: string) => void;
+    /** TIER 2 #4 — workflow runner uses this to resolve a non-built-in
+     *  agentType against the user's curated role library. */
+    findRoleTemplateByName: (name: string) => RoleTemplateRecord | undefined;
     getAppState: (key: string) => AppStateRecord | undefined;
     getCommandPreset: (id: string) => CommandPresetRecord | undefined;
     listCommandPresets: () => CommandPresetRecord[];

package/dist/src/server/settings-store.js

@@ -10,6 +10,7 @@ export const createSettingsStore = (db) => {
         createRoleTemplate: roleTemplateStore.create,
         deleteCommandPreset: commandPresetStore.remove,
         deleteRoleTemplate: roleTemplateStore.remove,
+        findRoleTemplateByName: roleTemplateStore.findByName,
         getAppState: appStateStore.get,
         getCommandPreset: commandPresetStore.get,
         listCommandPresets: commandPresetStore.list,

package/dist/src/server/sqlite-schema-v19.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion19: (db: Database) => void;

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

@@ -0,0 +1,17 @@
+export const applySchemaVersion19 = (db) => {
+    const workerColumns = new Set(db.prepare('PRAGMA table_info(workers)').all().map((c) => c.name));
+    if (!workerColumns.has('ephemeral')) {
+        db.exec('ALTER TABLE workers ADD COLUMN ephemeral INTEGER NOT NULL DEFAULT 0');
+    }
+    if (!workerColumns.has('spawned_by')) {
+        db.exec('ALTER TABLE workers ADD COLUMN spawned_by TEXT');
+    }
+    const dispatchColumns = new Set(db.prepare('PRAGMA table_info(dispatches)').all().map((c) => c.name));
+    if (!dispatchColumns.has('workflow_run_id')) {
+        db.exec('ALTER TABLE dispatches ADD COLUMN workflow_run_id TEXT');
+    }
+    if (!dispatchColumns.has('step_index')) {
+        db.exec('ALTER TABLE dispatches ADD COLUMN step_index INTEGER');
+    }
+    db.exec('CREATE INDEX IF NOT EXISTS idx_dispatches_workflow ON dispatches (workflow_run_id, step_index)');
+};

package/dist/src/server/sqlite-schema-v20.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion20: (db: Database) => void;

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

@@ -0,0 +1,20 @@
+export const applySchemaVersion20 = (db) => {
+    db.exec(`
+    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);
+  `);
+};

package/dist/src/server/sqlite-schema-v21.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion21: (db: Database) => void;

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

@@ -0,0 +1,20 @@
+export const applySchemaVersion21 = (db) => {
+    db.exec(`
+    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);
+  `);
+};

package/dist/src/server/sqlite-schema.d.ts

@@ -1,3 +1,3 @@
 import type { Database } from 'better-sqlite3';
-export declare const CURRENT_SCHEMA_VERSION = 18;
+export declare const CURRENT_SCHEMA_VERSION = 21;
 export declare const initializeRuntimeDatabase: (db: Database) => void;

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

@@ -11,7 +11,19 @@ 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';
-export const CURRENT_SCHEMA_VERSION = 18;
+import { applySchemaVersion19 } from './sqlite-schema-v19.js';
+import { applySchemaVersion20 } from './sqlite-schema-v20.js';
+import { applySchemaVersion21 } from './sqlite-schema-v21.js';
+export const CURRENT_SCHEMA_VERSION = 21;
+// 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 (
@@ -105,7 +117,92 @@ export const initializeRuntimeDatabase = (db) => {
 
     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();
@@ -203,4 +300,16 @@ export const initializeRuntimeDatabase = (db) => {
         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());
+    }
 };

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

@@ -1 +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

@@ -1 +1,8 @@
-export const wrapSystemMessage = (content) => `[Hive 系统消息：${content}]`;
+/**
+ * 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

@@ -1,4 +1,6 @@
 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
@@ -24,11 +26,20 @@ import { type ChokidarOptions } from 'chokidar';
  * 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 interface TasksFileWatcher {
     close: () => Promise<void>;
     start: (workspaceId: string, workspacePath: string) => Promise<void>;
     stop: (workspaceId: string) => Promise<void>;
 }
-export declare const createTasksFileWatcher: ({ onTasksUpdated, }: {
+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;

package/dist/src/server/tasks-file-watcher.js

@@ -1,8 +1,13 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { basename, dirname, normalize } from 'node:path';
 import chokidar from 'chokidar';
-import { ensureProtocolFile, ensureTasksFile, getTasksFilePath } from './tasks-file.js';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { ensureProtocolFile, ensureTasksFile, getTasksFilePath, TASKS_FILE_NAME, } from './tasks-file.js';
 const DEBOUNCE_MS = 100;
+const WATCHER_RETRY_MS = 5000;
+const WATCHER_CLOSE_TIMEOUT_MS = 2000;
+const WATCHER_READY_TIMEOUT_MS = 15000;
 /**
  * Watcher configuration. The atomic-save option matters on Windows: VS
  * Code, Cursor, Notepad++, and the editor inside Hive itself all save
@@ -31,9 +36,45 @@ export const TASKS_WATCHER_OPTIONS = {
     atomic: 100,
     ignoreInitial: true,
 };
-export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
+const isWindowsUncPath = (path, platform = process.platform) => platform === 'win32' && /^[\\/]{2}[^\\/]+[\\/]+[^\\/]+/u.test(path);
+export const buildTasksWatcherOptions = (workspacePath, platform = process.platform) => ({
+    ...TASKS_WATCHER_OPTIONS,
+    ...(platform === 'win32' || isWindowsUncPath(workspacePath, platform)
+        ? { interval: 500, usePolling: true }
+        : {}),
+});
+const closeWatcherWithTimeout = async (watcher) => {
+    if (!watcher)
+        return;
+    let timer;
+    try {
+        await Promise.race([
+            watcher.close(),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, WATCHER_CLOSE_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
+const isTasksFileEvent = (tasksPath, changedPath) => {
+    if (!changedPath)
+        return true;
+    const text = Buffer.isBuffer(changedPath) ? changedPath.toString() : changedPath;
+    return normalize(text) === normalize(tasksPath) || basename(text) === TASKS_FILE_NAME;
+};
+export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }) => {
     const watchers = new Map();
     const timers = new Map();
+    const retryTimers = new Map();
+    let closed = false;
+    const logWatcherError = (workspaceId, error) => {
+        console.error(`[hive] tasks watcher error for workspace ${workspaceId}`, error);
+    };
     const clearTimer = (workspaceId) => {
         const timer = timers.get(workspaceId);
         if (!timer)
@@ -41,6 +82,13 @@ export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
         clearTimeout(timer);
         timers.delete(workspaceId);
     };
+    const clearRetryTimer = (workspaceId) => {
+        const timer = retryTimers.get(workspaceId);
+        if (!timer)
+            return;
+        clearTimeout(timer);
+        retryTimers.delete(workspaceId);
+    };
     const emitCurrentContent = async (workspaceId, workspacePath) => {
         const tasksPath = getTasksFilePath(workspacePath);
         try {
@@ -48,39 +96,96 @@ export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
             onTasksUpdated(workspaceId, content);
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
+            if (error.code !== 'ENOENT') {
+                logWatcherError(workspaceId, error);
+                return;
+            }
             onTasksUpdated(workspaceId, '');
         }
     };
     const stop = async (workspaceId) => {
         clearTimer(workspaceId);
+        clearRetryTimer(workspaceId);
         const watcher = watchers.get(workspaceId);
         watchers.delete(workspaceId);
-        await watcher?.close();
+        await closeWatcherWithTimeout(watcher);
+    };
+    const scheduleRetry = (workspaceId, workspacePath) => {
+        if (closed || retryTimers.has(workspaceId))
+            return;
+        const timer = setTimeout(() => {
+            retryTimers.delete(workspaceId);
+            void start(workspaceId, workspacePath).catch((error) => logWatcherError(workspaceId, error));
+        }, WATCHER_RETRY_MS);
+        timer.unref?.();
+        retryTimers.set(workspaceId, timer);
+    };
+    const waitForReady = async (watcher) => await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            watcher.off('ready', handleReady);
+            watcher.off('error', handleError);
+            clearTimeout(timeout);
+        };
+        const handleReady = () => {
+            cleanup();
+            resolve();
+        };
+        const handleError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`Timed out waiting for tasks watcher ready after ${WATCHER_READY_TIMEOUT_MS}ms`));
+        }, WATCHER_READY_TIMEOUT_MS);
+        timeout.unref?.();
+        watcher.once('ready', handleReady);
+        watcher.once('error', handleError);
+    });
+    const start = async (workspaceId, workspacePath) => {
+        closed = false;
+        await stop(workspaceId);
+        ensureTasksFile(workspacePath);
+        ensureProtocolFile(workspacePath, getWorkflowCliPolicy?.(), getFlags?.() ?? FEATURE_FLAGS_ALL_OFF);
+        const tasksPath = getTasksFilePath(workspacePath);
+        const watcher = chokidar.watch(dirname(tasksPath), buildTasksWatcherOptions(workspacePath));
+        const scheduleEmit = (changedPath) => {
+            if (!isTasksFileEvent(tasksPath, changedPath))
+                return;
+            clearTimer(workspaceId);
+            timers.set(workspaceId, setTimeout(() => {
+                timers.delete(workspaceId);
+                void emitCurrentContent(workspaceId, workspacePath);
+            }, DEBOUNCE_MS));
+        };
+        watcher.on('add', scheduleEmit);
+        watcher.on('change', scheduleEmit);
+        watcher.on('unlink', scheduleEmit);
+        watcher.on('error', (error) => {
+            logWatcherError(workspaceId, error);
+            void stop(workspaceId)
+                .catch((closeError) => logWatcherError(workspaceId, closeError))
+                .finally(() => scheduleRetry(workspaceId, workspacePath));
+        });
+        watchers.set(workspaceId, watcher);
+        try {
+            await waitForReady(watcher);
+        }
+        catch (error) {
+            watchers.delete(workspaceId);
+            await closeWatcherWithTimeout(watcher);
+            scheduleRetry(workspaceId, workspacePath);
+            throw error;
+        }
     };
     return {
         close: async () => {
+            closed = true;
+            for (const workspaceId of retryTimers.keys())
+                clearRetryTimer(workspaceId);
             await Promise.all(Array.from(watchers.keys(), (workspaceId) => stop(workspaceId)));
         },
-        start: async (workspaceId, workspacePath) => {
-            await stop(workspaceId);
-            ensureTasksFile(workspacePath);
-            ensureProtocolFile(workspacePath);
-            const watcher = chokidar.watch(getTasksFilePath(workspacePath), TASKS_WATCHER_OPTIONS);
-            const scheduleEmit = () => {
-                clearTimer(workspaceId);
-                timers.set(workspaceId, setTimeout(() => {
-                    timers.delete(workspaceId);
-                    void emitCurrentContent(workspaceId, workspacePath);
-                }, DEBOUNCE_MS));
-            };
-            watcher.on('add', scheduleEmit);
-            watcher.on('change', scheduleEmit);
-            watcher.on('unlink', scheduleEmit);
-            watchers.set(workspaceId, watcher);
-            await new Promise((resolve) => watcher.once('ready', () => resolve()));
-        },
+        start,
         stop,
     };
 };