@tt-a1i/hive 1.7.0 → 2.0.2

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

@@ -0,0 +1,127 @@
+const tableExists = (db, table) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const firstUnicodeTerm = (value) => {
+    if (!value)
+        return null;
+    const token = value.trim().split(/\s+/).find(Boolean);
+    if (!token)
+        return null;
+    return token;
+};
+const firstTrigramTerm = (value) => {
+    const token = firstUnicodeTerm(value);
+    if (!token)
+        return null;
+    return [...token].slice(0, Math.max(1, Math.min(3, [...token].length))).join('');
+};
+const ftsHasSampleHit = (db, table, term) => db
+    .prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${table} MATCH ?`)
+    .get(quoteFtsToken(term)).count > 0;
+const shouldRebuildMessageIndexes = (db) => {
+    const sample = db
+        .prepare(`SELECT text
+       FROM messages
+       ORDER BY sequence ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.text);
+    const trigramTerm = firstTrigramTerm(sample.text);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'messages_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm
+        ? ftsHasSampleHit(db, 'messages_fts_trigram', trigramTerm)
+        : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+const shouldRebuildDispatchIndexes = (db) => {
+    const sample = db
+        .prepare(`SELECT text, report_text
+       FROM dispatches
+       ORDER BY sequence ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.text) ?? firstUnicodeTerm(sample.report_text);
+    const trigramTerm = firstTrigramTerm(sample.text) ?? firstTrigramTerm(sample.report_text);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'dispatches_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm
+        ? ftsHasSampleHit(db, 'dispatches_fts_trigram', trigramTerm)
+        : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+export const applySchemaVersion25 = (db) => {
+    const messagesFtsExists = tableExists(db, 'messages_fts');
+    const messagesFtsTrigramExists = tableExists(db, 'messages_fts_trigram');
+    const dispatchesFtsExists = tableExists(db, 'dispatches_fts');
+    const dispatchesFtsTrigramExists = tableExists(db, 'dispatches_fts_trigram');
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts
+      USING fts5(text, content='messages', content_rowid='sequence', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts_trigram
+      USING fts5(text, content='messages', content_rowid='sequence', tokenize='trigram');
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS dispatches_fts
+      USING fts5(text, report_text, content='dispatches', content_rowid='sequence', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS dispatches_fts_trigram
+      USING fts5(text, report_text, content='dispatches', content_rowid='sequence', tokenize='trigram');
+
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, text) VALUES (new.sequence, new.text);
+      INSERT INTO messages_fts_trigram(rowid, text) VALUES (new.sequence, new.text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text) VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts_trigram(messages_fts_trigram, rowid, text)
+        VALUES('delete', old.sequence, old.text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_fts_au AFTER UPDATE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text) VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts(rowid, text) VALUES (new.sequence, new.text);
+      INSERT INTO messages_fts_trigram(messages_fts_trigram, rowid, text)
+        VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts_trigram(rowid, text) VALUES (new.sequence, new.text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_ai AFTER INSERT ON dispatches BEGIN
+      INSERT INTO dispatches_fts(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+      INSERT INTO dispatches_fts_trigram(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_ad AFTER DELETE ON dispatches BEGIN
+      INSERT INTO dispatches_fts(dispatches_fts, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_au AFTER UPDATE ON dispatches BEGIN
+      INSERT INTO dispatches_fts(dispatches_fts, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts_trigram(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+    END;
+  `);
+    if (!messagesFtsExists ||
+        !messagesFtsTrigramExists ||
+        !dispatchesFtsExists ||
+        !dispatchesFtsTrigramExists ||
+        shouldRebuildMessageIndexes(db) ||
+        shouldRebuildDispatchIndexes(db)) {
+        db.exec(`
+      INSERT INTO messages_fts(messages_fts) VALUES('rebuild');
+      INSERT INTO messages_fts_trigram(messages_fts_trigram) VALUES('rebuild');
+      INSERT INTO dispatches_fts(dispatches_fts) VALUES('rebuild');
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram) VALUES('rebuild');
+    `);
+    }
+};

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

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

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

@@ -0,0 +1,56 @@
+export const applySchemaVersion26 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT,
+      scope TEXT NOT NULL DEFAULT 'workspace',
+      fts_rowid INTEGER UNIQUE,
+      kind TEXT NOT NULL,
+      body TEXT NOT NULL,
+      tags TEXT,
+      status TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'manual',
+      confidence REAL,
+      pinned INTEGER NOT NULL DEFAULT 0,
+      disabled INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      archived_at INTEGER,
+      last_injected_at INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_entries_ws_status
+      ON memory_entries(workspace_id, status);
+    CREATE INDEX IF NOT EXISTS idx_memory_entries_ws_updated
+      ON memory_entries(workspace_id, updated_at);
+
+    CREATE TABLE IF NOT EXISTS memory_sources (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL REFERENCES memory_entries(id) ON DELETE CASCADE,
+      source_type TEXT NOT NULL,
+      source_id TEXT,
+      source_sequence INTEGER,
+      excerpt TEXT,
+      text_hash TEXT,
+      actor_agent_id_snapshot TEXT,
+      actor_name_snapshot TEXT,
+      actor_role_snapshot TEXT,
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_sources_memory
+      ON memory_sources(memory_id);
+
+    CREATE TABLE IF NOT EXISTS memory_injections (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL REFERENCES memory_entries(id) ON DELETE CASCADE,
+      workspace_id TEXT,
+      target_agent_id_snapshot TEXT,
+      context_type TEXT NOT NULL,
+      dispatch_id TEXT,
+      injected_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_injections_ws
+      ON memory_injections(workspace_id, injected_at);
+    CREATE INDEX IF NOT EXISTS idx_memory_injections_memory
+      ON memory_injections(memory_id, injected_at);
+  `);
+};

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

@@ -0,0 +1,6 @@
+import type { Database } from 'better-sqlite3';
+interface ApplySchemaVersion27Options {
+    rebuild?: boolean;
+}
+export declare const applySchemaVersion27: (db: Database, options?: ApplySchemaVersion27Options) => void;
+export {};

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

@@ -0,0 +1,92 @@
+const tableExists = (db, table) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+const ensureFtsRowidColumn = (db) => {
+    const columns = new Set(db.prepare('PRAGMA table_info(memory_entries)').all().map((column) => column.name));
+    if (!columns.has('fts_rowid')) {
+        db.exec('ALTER TABLE memory_entries ADD COLUMN fts_rowid INTEGER');
+    }
+    db.exec(`
+    UPDATE memory_entries
+    SET fts_rowid = rowid
+    WHERE fts_rowid IS NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_entries_fts_rowid
+      ON memory_entries(fts_rowid)
+      WHERE fts_rowid IS NOT NULL;
+  `);
+};
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const firstUnicodeTerm = (value) => {
+    if (!value)
+        return null;
+    const token = value.trim().split(/\s+/).find(Boolean);
+    if (!token)
+        return null;
+    return token;
+};
+const firstTrigramTerm = (value) => {
+    const token = firstUnicodeTerm(value);
+    if (!token)
+        return null;
+    return [...token].slice(0, Math.max(1, Math.min(3, [...token].length))).join('');
+};
+const ftsHasSampleHit = (db, table, term) => db
+    .prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${table} MATCH ?`)
+    .get(quoteFtsToken(term)).count > 0;
+const shouldRebuildExistingIndex = (db) => {
+    const sample = db
+        .prepare(`SELECT body, tags
+       FROM memory_entries
+       WHERE scope = 'workspace'
+       ORDER BY created_at ASC, id ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.body) ?? firstUnicodeTerm(sample.tags);
+    const trigramTerm = firstTrigramTerm(sample.body) ?? firstTrigramTerm(sample.tags);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'memory_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm ? ftsHasSampleHit(db, 'memory_fts_trigram', trigramTerm) : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+export const applySchemaVersion27 = (db, options = {}) => {
+    ensureFtsRowidColumn(db);
+    const memoryFtsExists = tableExists(db, 'memory_fts');
+    const memoryFtsTrigramExists = tableExists(db, 'memory_fts_trigram');
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts
+      USING fts5(body, tags, content='memory_entries', content_rowid='fts_rowid', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts_trigram
+      USING fts5(body, tags, content='memory_entries', content_rowid='fts_rowid', tokenize='trigram');
+
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ai AFTER INSERT ON memory_entries BEGIN
+      INSERT INTO memory_fts(rowid, body, tags) VALUES (new.fts_rowid, new.body, new.tags);
+      INSERT INTO memory_fts_trigram(rowid, body, tags)
+        VALUES (new.fts_rowid, new.body, new.tags);
+    END;
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ad AFTER DELETE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts_trigram(memory_fts_trigram, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+    END;
+    CREATE TRIGGER IF NOT EXISTS memory_fts_au AFTER UPDATE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts(rowid, body, tags) VALUES (new.fts_rowid, new.body, new.tags);
+      INSERT INTO memory_fts_trigram(memory_fts_trigram, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts_trigram(rowid, body, tags)
+        VALUES (new.fts_rowid, new.body, new.tags);
+    END;
+  `);
+    if (options.rebuild === true ||
+        !memoryFtsExists ||
+        !memoryFtsTrigramExists ||
+        shouldRebuildExistingIndex(db)) {
+        db.exec(`
+      INSERT INTO memory_fts(memory_fts) VALUES('rebuild');
+      INSERT INTO memory_fts_trigram(memory_fts_trigram) VALUES('rebuild');
+    `);
+    }
+};

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

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

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

@@ -0,0 +1,19 @@
+export const applySchemaVersion28 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS dream_runs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      trigger TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      input_seq_from INTEGER,
+      input_seq_to INTEGER,
+      report TEXT,
+      revert_blob TEXT,
+      error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_dream_runs_ws
+      ON dream_runs(workspace_id, started_at);
+  `);
+};

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

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

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

@@ -0,0 +1,27 @@
+const QWEN_SESSION_ID_CAPTURE = {
+    pattern: '~/.qwen/sessions/**/*.json',
+    source: 'qwen_session_json_dir',
+};
+const QWEN_YOLO_ARGS = ['--approval-mode', 'yolo'];
+export const applySchemaVersion29 = (db) => {
+    const hasCommandPresets = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!hasCommandPresets)
+        return;
+    const now = Date.now();
+    db.prepare(`INSERT INTO command_presets (
+       id, display_name, command, args, env, resume_args_template, session_id_capture,
+       yolo_args_template, is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       display_name = excluded.display_name,
+       command = excluded.command,
+       args = excluded.args,
+       env = excluded.env,
+       resume_args_template = excluded.resume_args_template,
+       session_id_capture = excluded.session_id_capture,
+       yolo_args_template = excluded.yolo_args_template,
+       updated_at = excluded.updated_at
+    WHERE command_presets.is_builtin = 1`).run('qwen', 'Qwen Code', 'qwen', '[]', '{}', '--resume {session_id}', JSON.stringify(QWEN_SESSION_ID_CAPTURE), JSON.stringify(QWEN_YOLO_ARGS), now, now);
+};

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

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

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

@@ -0,0 +1,27 @@
+const AGY_SESSION_ID_CAPTURE = {
+    pattern: String.raw `(?:^|\s)(?:\S*[\\/])?agy(?:\.(?:cmd|exe))?\s+--conversation\s+([0-9a-fA-F-]{36})\b`,
+    source: 'stdout_regex',
+};
+const AGY_YOLO_ARGS = ['--dangerously-skip-permissions'];
+export const applySchemaVersion30 = (db) => {
+    const hasCommandPresets = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!hasCommandPresets)
+        return;
+    const now = Date.now();
+    db.prepare(`INSERT INTO command_presets (
+       id, display_name, command, args, env, resume_args_template, session_id_capture,
+       yolo_args_template, is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       display_name = excluded.display_name,
+       command = excluded.command,
+       args = excluded.args,
+       env = excluded.env,
+       resume_args_template = excluded.resume_args_template,
+       session_id_capture = excluded.session_id_capture,
+       yolo_args_template = excluded.yolo_args_template,
+       updated_at = excluded.updated_at
+    WHERE command_presets.is_builtin = 1`).run('agy', 'Antigravity CLI', 'agy', '[]', '{}', '--conversation {session_id}', JSON.stringify(AGY_SESSION_ID_CAPTURE), JSON.stringify(AGY_YOLO_ARGS), now, now);
+};

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

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

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

@@ -0,0 +1,30 @@
+import { getBuiltinCommandPreset } from './command-preset-defaults.js';
+const upsertBuiltinCommandPreset = (db, id, now) => {
+    const preset = getBuiltinCommandPreset(id);
+    if (!preset)
+        return;
+    db.prepare(`INSERT INTO command_presets (
+       id, display_name, command, args, env, resume_args_template, session_id_capture,
+       yolo_args_template, is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       display_name = excluded.display_name,
+       command = excluded.command,
+       args = excluded.args,
+       env = excluded.env,
+       resume_args_template = excluded.resume_args_template,
+       session_id_capture = excluded.session_id_capture,
+       yolo_args_template = excluded.yolo_args_template,
+       updated_at = excluded.updated_at
+    WHERE command_presets.is_builtin = 1`).run(preset.id, preset.displayName, preset.command, '[]', '{}', preset.resumeArgsTemplate, preset.sessionIdCapture ? JSON.stringify(preset.sessionIdCapture) : null, preset.yoloArgsTemplate ? JSON.stringify(preset.yoloArgsTemplate) : null, now, now);
+};
+export const applySchemaVersion31 = (db) => {
+    const hasCommandPresets = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!hasCommandPresets)
+        return;
+    const now = Date.now();
+    upsertBuiltinCommandPreset(db, 'cursor', now);
+    upsertBuiltinCommandPreset(db, 'grok', now);
+};

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

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

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

@@ -15,7 +15,16 @@ 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';
-export const CURRENT_SCHEMA_VERSION = 22;
+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';
+import { applySchemaVersion29 } from './sqlite-schema-v29.js';
+import { applySchemaVersion30 } from './sqlite-schema-v30.js';
+import { applySchemaVersion31 } from './sqlite-schema-v31.js';
+export const CURRENT_SCHEMA_VERSION = 31;
 // 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.
@@ -317,4 +326,43 @@ export const initializeRuntimeDatabase = (db) => {
         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());
+    }
+    applySchemaVersion29(db);
+    if (!appliedVersions.has(29)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(29, Date.now());
+    }
+    applySchemaVersion30(db);
+    if (!appliedVersions.has(30)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(30, Date.now());
+    }
+    applySchemaVersion31(db);
+    if (!appliedVersions.has(31)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(31, Date.now());
+    }
 };

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

@@ -2,7 +2,11 @@ import { basename } from 'node:path';
 const getEnvValue = (env, key, platform = process.platform) => {
     if (platform !== 'win32')
         return env[key];
-    const matchedKey = Object.keys(env).find((item) => item.toLowerCase() === key.toLowerCase());
+    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) => {

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

@@ -27,6 +27,8 @@ import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
  */
 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>;

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

@@ -7,7 +7,8 @@ import { ensureProtocolFile, ensureTasksFile, getTasksFilePath, TASKS_FILE_NAME,
 const DEBOUNCE_MS = 100;
 const WATCHER_RETRY_MS = 5000;
 const WATCHER_CLOSE_TIMEOUT_MS = 2000;
-const WATCHER_READY_TIMEOUT_MS = 15000;
+const DEFAULT_WATCHER_READY_TIMEOUT_MS = 15000;
+const WINDOWS_WATCHER_READY_TIMEOUT_MS = 60000;
 /**
  * Watcher configuration. The atomic-save option matters on Windows: VS
  * Code, Cursor, Notepad++, and the editor inside Hive itself all save
@@ -43,6 +44,9 @@ export const buildTasksWatcherOptions = (workspacePath, platform = process.platf
         ? { interval: 500, usePolling: true }
         : {}),
 });
+export const getTasksWatcherReadyTimeoutMs = (workspacePath, platform = process.platform) => platform === 'win32' || isWindowsUncPath(workspacePath, platform)
+    ? WINDOWS_WATCHER_READY_TIMEOUT_MS
+    : DEFAULT_WATCHER_READY_TIMEOUT_MS;
 const closeWatcherWithTimeout = async (watcher) => {
     if (!watcher)
         return;
@@ -61,10 +65,14 @@ const closeWatcherWithTimeout = async (watcher) => {
             clearTimeout(timer);
     }
 };
-const isTasksFileEvent = (tasksPath, changedPath) => {
+export const isTasksFileEvent = (tasksPath, changedPath, platform = process.platform) => {
     if (!changedPath)
         return true;
     const text = Buffer.isBuffer(changedPath) ? changedPath.toString() : changedPath;
+    if (platform === 'win32') {
+        return (normalize(text).toLowerCase() === normalize(tasksPath).toLowerCase() ||
+            basename(text).toLowerCase() === TASKS_FILE_NAME);
+    }
     return normalize(text) === normalize(tasksPath) || basename(text) === TASKS_FILE_NAME;
 };
 export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }) => {
@@ -120,7 +128,7 @@ export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, g
         timer.unref?.();
         retryTimers.set(workspaceId, timer);
     };
-    const waitForReady = async (watcher) => await new Promise((resolve, reject) => {
+    const waitForReady = async (watcher, timeoutMs) => await new Promise((resolve, reject) => {
         const cleanup = () => {
             watcher.off('ready', handleReady);
             watcher.off('error', handleError);
@@ -136,8 +144,8 @@ export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, g
         };
         const timeout = setTimeout(() => {
             cleanup();
-            reject(new Error(`Timed out waiting for tasks watcher ready after ${WATCHER_READY_TIMEOUT_MS}ms`));
-        }, WATCHER_READY_TIMEOUT_MS);
+            reject(new Error(`Timed out waiting for tasks watcher ready after ${timeoutMs}ms`));
+        }, timeoutMs);
         timeout.unref?.();
         watcher.once('ready', handleReady);
         watcher.once('error', handleError);
@@ -149,6 +157,7 @@ export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, g
         ensureProtocolFile(workspacePath, getWorkflowCliPolicy?.(), getFlags?.() ?? FEATURE_FLAGS_ALL_OFF);
         const tasksPath = getTasksFilePath(workspacePath);
         const watcher = chokidar.watch(dirname(tasksPath), buildTasksWatcherOptions(workspacePath));
+        const readyTimeoutMs = getTasksWatcherReadyTimeoutMs(workspacePath);
         const scheduleEmit = (changedPath) => {
             if (!isTasksFileEvent(tasksPath, changedPath))
                 return;
@@ -169,7 +178,7 @@ export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, g
         });
         watchers.set(workspaceId, watcher);
         try {
-            await waitForReady(watcher);
+            await waitForReady(watcher, readyTimeoutMs);
         }
         catch (error) {
             watchers.delete(workspaceId);

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

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { buildProtocolDoc } from './hive-team-guidance.js';
 export const HIVE_DIR_NAME = '.hive';
@@ -32,6 +33,30 @@ const runRetryableTasksFileOperation = (operation) => {
 const ensureTasksDir = (workspacePath) => {
     runRetryableTasksFileOperation(() => mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true }));
 };
+const writeUtf8FileAtomically = (targetPath, content) => {
+    const tempPath = join(dirname(targetPath), `.${basename(targetPath)}.${randomUUID()}.tmp`);
+    let committed = false;
+    let fd = null;
+    try {
+        try {
+            fd = openSync(tempPath, 'w');
+            writeFileSync(fd, content, 'utf8');
+            fsyncSync(fd);
+        }
+        finally {
+            if (fd !== null) {
+                closeSync(fd);
+                fd = null;
+            }
+        }
+        renameSync(tempPath, targetPath);
+        committed = true;
+    }
+    finally {
+        if (!committed && existsSync(tempPath))
+            rmSync(tempPath, { force: true });
+    }
+};
 export const ensureTasksFile = (workspacePath) => {
     ensureTasksDir(workspacePath);
     const tasksFilePath = getTasksFilePath(workspacePath);
@@ -42,7 +67,7 @@ export const ensureTasksFile = (workspacePath) => {
     const content = existsSync(legacyTasksFilePath)
         ? runRetryableTasksFileOperation(() => readFileSync(legacyTasksFilePath, 'utf8'))
         : '';
-    runRetryableTasksFileOperation(() => writeFileSync(tasksFilePath, content, 'utf8'));
+    runRetryableTasksFileOperation(() => writeUtf8FileAtomically(tasksFilePath, content));
     return content;
 };
 /**
@@ -60,7 +85,7 @@ export const ensureProtocolFile = (workspacePath, cliPolicy, flags = FEATURE_FLA
         : null;
     if (current === desired)
         return desired;
-    runRetryableTasksFileOperation(() => writeFileSync(protocolFilePath, desired, 'utf8'));
+    runRetryableTasksFileOperation(() => writeUtf8FileAtomically(protocolFilePath, desired));
     return desired;
 };
 export const createTasksFileService = () => {
@@ -70,7 +95,7 @@ export const createTasksFileService = () => {
         },
         writeTasks(workspacePath, content) {
             ensureTasksDir(workspacePath);
-            runRetryableTasksFileOperation(() => writeFileSync(getTasksFilePath(workspacePath), content, 'utf8'));
+            runRetryableTasksFileOperation(() => writeUtf8FileAtomically(getTasksFilePath(workspacePath), content));
         },
     };
 };

package/dist/src/server/tasks-websocket-server.js

@@ -12,6 +12,10 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
     attachWebSocketServerErrorHandler(wss, 'tasks');
     const socketsByWorkspaceId = new Map();
     const validateUpgradeSession = (request) => {
+        // Tunnel-originated upgrades carry the per-boot secret (invariant 2); a
+        // request with no secret header falls through to the unchanged cookie path.
+        if (store.authorizeRemoteTunnelRequest(request))
+            return true;
         const cookieHeader = Array.isArray(request.headers.cookie)
             ? request.headers.cookie.join('; ')
             : request.headers.cookie;