@tt-a1i/hive 1.4.3 → 1.5.0

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

@@ -4,8 +4,33 @@ import { join } from 'node:path';
 import Database from 'better-sqlite3';
 import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
 const expandHome = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-const getDefaultOpenCodeDbPath = () => process.env.HIVE_OPENCODE_DB_PATH ??
-    join(process.env.XDG_DATA_HOME ?? join(homedir(), '.local', 'share'), 'opencode', 'opencode.db');
+/**
+ * Resolve the path OpenCode upstream writes `opencode.db` to. Branches
+ * by platform because XDG_DATA_HOME is not a Windows convention — the
+ * previous unconditional ~/.local/share/opencode/opencode.db default
+ * pointed at a path that never exists on Windows, silently breaking
+ * Layer A native session resume for OpenCode workers there.
+ *
+ * Resolution order:
+ *   1. HIVE_OPENCODE_DB_PATH override (any platform, for tests/users).
+ *   2. Windows: %LOCALAPPDATA%\opencode\opencode.db (with a homedir
+ *      fallback when LOCALAPPDATA is missing — some shells strip env).
+ *   3. POSIX: $XDG_DATA_HOME/opencode/opencode.db, falling back to
+ *      ~/.local/share/opencode/opencode.db.
+ *
+ * Exported so the path-resolution rules can be unit-tested without
+ * needing to mock the underlying SQLite open.
+ */
+export const getDefaultOpenCodeDbPath = (platform = process.platform) => {
+    const override = process.env.HIVE_OPENCODE_DB_PATH;
+    if (override)
+        return override;
+    if (platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local');
+        return join(localAppData, 'opencode', 'opencode.db');
+    }
+    return join(process.env.XDG_DATA_HOME ?? join(homedir(), '.local', 'share'), 'opencode', 'opencode.db');
+};
 export const getOpenCodeDbPath = (pattern) => pattern === '~/.local/share/opencode/opencode.db' || !pattern
     ? getDefaultOpenCodeDbPath()
     : expandHome(pattern);

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,79 @@ 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 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 +287,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/startup-command-parser.d.ts

@@ -3,3 +3,18 @@ export declare const createStartupCommandLaunch: (startupCommand: string, env?:
     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

@@ -32,6 +32,37 @@ export const getStartupCommandExecutable = (startupCommand) => {
     const command = startupCommand.trim();
     if (!command)
         return null;
-    const match = /^(['"]?)([^'"\s]+)\1/.exec(command);
-    return match?.[2] ?? 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

@@ -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/tasks-file-watcher.d.ts

@@ -1,8 +1,46 @@
+import { type ChokidarOptions } from 'chokidar';
+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 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, getWorkflowsEnabled, getAutostaffEnabled, }: {
     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;
+    /** Whether the experimental workflow feature is on. Off → PROTOCOL.md omits
+     *  the workflow DSL + `team workflow` commands entirely. Defaults to off. */
+    getWorkflowsEnabled?: () => boolean;
+    /** Whether the experimental auto-staff feature is on (default on). Off →
+     *  PROTOCOL.md omits the team-sizing rule. */
+    getAutostaffEnabled?: () => boolean;
 }) => TasksFileWatcher;

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

@@ -1,11 +1,79 @@
 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 { ensureProtocolFile, ensureTasksFile, getTasksFilePath, TASKS_FILE_NAME, } from './tasks-file.js';
 const DEBOUNCE_MS = 100;
-export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
+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
+ * 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 const TASKS_WATCHER_OPTIONS = {
+    atomic: 100,
+    ignoreInitial: true,
+};
+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, getWorkflowsEnabled, getAutostaffEnabled, }) => {
     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)
@@ -13,6 +81,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 {
@@ -20,41 +95,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?.(), getWorkflowsEnabled?.() ?? false, getAutostaffEnabled?.() ?? false);
+        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), {
-                ignoreInitial: true,
-            });
-            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,
     };
 };

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

@@ -1,3 +1,4 @@
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 interface TasksFileService {
     readTasks: (workspacePath: string) => string;
     writeTasks: (workspacePath: string, content: string) => void;
@@ -16,6 +17,6 @@ export declare const ensureTasksFile: (workspacePath: string) => string;
  * on every workspace open means a Hive version bump that changes the rules
  * propagates without manual intervention.
  */
-export declare const ensureProtocolFile: (workspacePath: string) => string;
+export declare const ensureProtocolFile: (workspacePath: string, cliPolicy?: WorkflowCliPolicy, workflowsEnabled?: boolean, autostaffEnabled?: boolean) => string;
 export declare const createTasksFileService: () => TasksFileService;
 export type { TasksFileService };