@tt-a1i/hive 1.7.0 → 2.0.2

package/dist/src/server/runtime-store-workflows.js

@@ -1,3 +1,4 @@
+import { resolveCommandPresetLaunchConfig } from './agent-launch-resolver.js';
 import { readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY } from './workflow-cli-policy.js';
 import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
 import { createWorkflowRunner } from './workflow-runner.js';
@@ -14,6 +15,7 @@ export const createRuntimeStoreWorkflowRuntime = (services, store) => {
             append: (runId, message, ts) => services.workflowRunLogStore.append(runId, message, ts),
         },
         getWorkflowCliPolicy: () => readWorkflowCliPolicy(services.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null),
+        resolveCliLaunchConfig: (cli) => resolveCommandPresetLaunchConfig(services.settings, cli),
         roleTemplateResolver: {
             findByName: (name) => {
                 const t = services.settings.findRoleTemplateByName(name);

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

@@ -1,4 +1,7 @@
+import { createRuntimeStoreDreamMethods } from './runtime-store-dream.js';
 import { createRuntimeStoreLifecycle, createRuntimeStoreServices, logTasksFileWatchStartError, } from './runtime-store-helpers.js';
+import { createRuntimeStoreMemoryMethods } from './runtime-store-memory.js';
+import { createRuntimeStoreRemoteMethods } from './runtime-store-remote.js';
 import { createRuntimeStoreWorkflowRuntime } from './runtime-store-workflows.js';
 import { persistWorkflowSchedule } from './workflow-schedule-create.js';
 export const createRuntimeStore = (options = {}) => {
@@ -20,6 +23,7 @@ export const createRuntimeStore = (options = {}) => {
     const store = {
         close: async () => {
             workflowRuntime?.scheduler.close();
+            await services.teamMemoryDreamScheduler.close();
             await lifecycle.close();
         },
         createWorkspace: (path, name) => {
@@ -40,8 +44,11 @@ export const createRuntimeStore = (options = {}) => {
                 services.agentRuntime.deleteAgentLaunchConfig(workspaceId, agent.id);
             }
             await services.tasksFileWatcher.stop(workspaceId);
+            services.teamMemoryExport.cancel(workspaceId);
             runDataMutation(() => {
                 services.dispatchLedgerStore.deleteWorkspaceDispatches(workspaceId);
+                services.teamMemoryStore.deleteWorkspaceMemories(workspaceId);
+                services.teamMemoryDreamStore.deleteWorkspaceDreamRuns(workspaceId);
                 services.workspaceStore.deleteWorkspace(workspaceId);
             });
             if (services.settings.getAppState('active_workspace_id')?.value === workspaceId) {
@@ -80,13 +87,13 @@ export const createRuntimeStore = (options = {}) => {
         renameWorker: (workspaceId, workerId, name) => services.workspaceStore.renameWorker(workspaceId, workerId, name),
         deleteWorker: (workspaceId, workerId) => {
             const activeRun = services.agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
-            if (activeRun)
-                services.agentRuntime.stopAgentRun(activeRun.runId);
-            services.agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
             runDataMutation(() => {
                 services.dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
                 services.workspaceStore.deleteWorker(workspaceId, workerId);
             });
+            services.agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
+            if (activeRun)
+                services.agentRuntime.stopAgentRun(activeRun.runId);
         },
         recordUserInput: services.teamOps.recordUserInput,
         cancelTask: services.teamOps.cancelTask,
@@ -115,6 +122,9 @@ export const createRuntimeStore = (options = {}) => {
         registerTasksListener: lifecycle.registerTasksListener,
         listAgentRuns: (agentId) => services.agentRuntime.listAgentRuns(agentId),
         listMessagesForRecovery: (workspaceId, sinceMs) => services.messageLogStore.listMessagesForRecovery(workspaceId, sinceMs),
+        recallMessages: (workspaceId, query, options) => services.teamRecallStore.recallMessages(workspaceId, query, options),
+        ...createRuntimeStoreMemoryMethods(services),
+        ...createRuntimeStoreDreamMethods(services),
         peekAgentToken: (agentId) => services.agentRuntime.peekAgentToken(agentId),
         pauseTerminalRun: lifecycle.pauseTerminalRun,
         resizeAgentRun: lifecycle.resizeTerminalRun,
@@ -125,6 +135,7 @@ export const createRuntimeStore = (options = {}) => {
         stopAgentRun: lifecycle.stopTerminalRun,
         validateAgentToken: (agentId, token) => services.agentRuntime.validateAgentToken(agentId, token),
         validateUiToken: (token) => services.uiAuth.validate(token),
+        ...createRuntimeStoreRemoteMethods(services),
         getWorkflowDispatchAwaiter: () => services.workflowDispatchAwaiter,
         runWorkflow: (input) => getWorkflowRuntime().runner.runWorkflow(input),
         startWorkflow: (input) => getWorkflowRuntime().runner.startWorkflow(input),

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

@@ -1,4 +1,4 @@
-export declare const getClaudeProjectsRoot: (pattern?: string) => string;
+export declare const getClaudeProjectsRoot: (pattern?: string, platform?: NodeJS.Platform) => string;
 /**
  * Match the directory-name encoding Claude Code itself uses for its project
  * metadata under `~/.claude/projects/`. Empirically (probed via `claude

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

@@ -2,9 +2,10 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { captureSessionIdWithCoordinator, resetSessionCaptureCoordinatorForTests, } from './claude-session-coordinator.js';
+import { arePathsEqual, expandHomePath } from './platform-path.js';
 const SESSION_FILE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.jsonl$/i;
 const getDefaultProjectsRoot = () => process.env.HIVE_CLAUDE_PROJECTS_DIR ?? join(homedir(), '.claude/projects');
-export const getClaudeProjectsRoot = (pattern) => {
+export const getClaudeProjectsRoot = (pattern, platform = process.platform) => {
     if (!pattern)
         return getDefaultProjectsRoot();
     const markerIndex = pattern.indexOf('{encoded_cwd}');
@@ -13,10 +14,12 @@ export const getClaudeProjectsRoot = (pattern) => {
     const root = pattern.slice(0, markerIndex).replace(/[\\/]+$/, '');
     if (!root)
         return getDefaultProjectsRoot();
-    if (root === '~' || root.startsWith('~/')) {
-        return process.env.HIVE_CLAUDE_PROJECTS_DIR ?? join(homedir(), '.claude', 'projects');
+    const builtInProjectsRoot = join(homedir(), '.claude', 'projects');
+    const expandedRoot = expandHomePath(root);
+    if (root === '~' || arePathsEqual(expandedRoot, builtInProjectsRoot, platform)) {
+        return getDefaultProjectsRoot();
     }
-    return root;
+    return expandedRoot;
 };
 /**
  * Match the directory-name encoding Claude Code itself uses for its project

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

@@ -2,23 +2,22 @@ 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';
+import { arePathsEqual, expandHomePath, 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, platform = process.platform) => {
     if (!pattern)
         return getDefaultCodexHome();
     const markerIndex = indexOfPathMarker(pattern, CODEX_SESSIONS_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultCodexHome();
-    const rawRoot = pattern.slice(0, markerIndex);
-    if (arePathsEqual(rawRoot, '~/.codex', platform) || arePathsEqual(rawRoot, '~/.codex/', platform))
+    const rawRoot = pattern.slice(0, markerIndex).replace(/[\\/]+$/u, '');
+    const root = expandHomePath(rawRoot);
+    if (arePathsEqual(root, join(homedir(), '.codex'), platform))
         return getDefaultCodexHome();
-    const root = expandHome(rawRoot);
     return root || getDefaultCodexHome();
 };
 const walkSessionFiles = (dir) => {

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

@@ -2,21 +2,20 @@ 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';
+import { arePathsEqual, expandHomePath, 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, platform = process.platform) => {
     if (!pattern)
         return getDefaultGeminiHome();
     const markerIndex = indexOfPathMarker(pattern, GEMINI_TMP_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultGeminiHome();
-    const rawRoot = pattern.slice(0, markerIndex);
-    if (rawRoot === '~/.gemini' || rawRoot === '~/.gemini/')
+    const rawRoot = pattern.slice(0, markerIndex).replace(/[\\/]+$/u, '');
+    const root = expandHomePath(rawRoot);
+    if (arePathsEqual(root, join(homedir(), '.gemini'), platform))
         return getDefaultGeminiHome();
-    const root = expandHome(rawRoot);
     return root || getDefaultGeminiHome();
 };
 const readProjectRoot = (projectDir) => {

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

@@ -16,7 +16,7 @@
  * needing to mock the underlying SQLite open.
  */
 export declare const getDefaultOpenCodeDbPath: (platform?: NodeJS.Platform) => string;
-export declare const getOpenCodeDbPath: (pattern?: string) => string;
-export declare const hasOpenCodeSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
-export declare const snapshotOpenCodeSessionIds: (cwd: string, dbPath?: string) => Set<string>;
-export declare const captureOpenCodeSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, dbPath?: string) => Promise<void>;
+export declare const getOpenCodeDbPath: (pattern?: string, platform?: NodeJS.Platform) => string;
+export declare const hasOpenCodeSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, dbPath?: string) => boolean;
+export declare const snapshotOpenCodeSessionIds: (cwd: string, dbPath?: string, platform?: NodeJS.Platform) => Set<string>;
+export declare const captureOpenCodeSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, dbPath?: string, platform?: NodeJS.Platform) => Promise<void>;

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

@@ -3,7 +3,7 @@ import { homedir } from 'node:os';
 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;
+import { arePathsEqual, expandHomePath } from './platform-path.js';
 /**
  * Resolve the path OpenCode upstream writes `opencode.db` to. Branches
  * by platform because XDG_DATA_HOME is not a Windows convention — the
@@ -31,20 +31,28 @@ export const getDefaultOpenCodeDbPath = (platform = process.platform) => {
     }
     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);
-const listSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath()) => {
+export const getOpenCodeDbPath = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultOpenCodeDbPath(platform);
+    const expanded = expandHomePath(pattern);
+    if (arePathsEqual(expanded, join(homedir(), '.local', 'share', 'opencode', 'opencode.db'), platform)) {
+        return getDefaultOpenCodeDbPath(platform);
+    }
+    return expanded;
+};
+const listSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => {
     if (!existsSync(dbPath))
         return [];
     let db;
     try {
         db = new Database(dbPath, { fileMustExist: true, readonly: true });
         return db
-            .prepare(`SELECT id FROM session
-           WHERE directory = ? AND time_archived IS NULL
+            .prepare(`SELECT id, directory FROM session
+           WHERE time_archived IS NULL
            ORDER BY rowid ASC`)
-            .all(cwd).map((row) => row.id);
+            .all()
+            .filter((row) => arePathsEqual(row.directory, cwd, platform))
+            .map((row) => row.id);
     }
     catch {
         return [];
@@ -53,13 +61,13 @@ const listSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath()) => {
         db?.close();
     }
 };
-export const hasOpenCodeSession = (cwd, sessionId, pattern) => listSessionIds(cwd, getOpenCodeDbPath(pattern)).includes(sessionId);
-export const snapshotOpenCodeSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath()) => new Set(listSessionIds(cwd, dbPath));
-export const captureOpenCodeSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, dbPath = getDefaultOpenCodeDbPath()) => {
+export const hasOpenCodeSession = (cwd, sessionId, pattern, platform = process.platform, dbPath = getOpenCodeDbPath(pattern, platform)) => listSessionIds(cwd, dbPath, platform).includes(sessionId);
+export const snapshotOpenCodeSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => new Set(listSessionIds(cwd, dbPath, platform));
+export const captureOpenCodeSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => {
     await captureSessionIdWithCoordinator({
         intervalMs,
         knownSessionIds,
-        listSessionIds: () => listSessionIds(cwd, dbPath),
+        listSessionIds: () => listSessionIds(cwd, dbPath, platform),
         onCapture,
         projectKey: `${dbPath}:${cwd}`,
         timeoutMs,

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

@@ -0,0 +1,5 @@
+export declare const getQwenHome: (pattern?: string, platform?: NodeJS.Platform) => string;
+export declare const hasQwenSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, qwenHome?: string) => boolean;
+export declare const snapshotQwenSessionIds: (cwd: string, qwenHome?: string, platform?: NodeJS.Platform) => Set<string>;
+export declare const captureQwenSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, qwenHome?: string) => Promise<void>;
+export declare const qwenSessionStoreExists: (qwenHome?: string) => boolean;

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

@@ -0,0 +1,104 @@
+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, expandHomePath, indexOfPathMarker } from './platform-path.js';
+const QWEN_SESSION_FILE = /\.json$/i;
+const QWEN_SESSIONS_MARKER = '/sessions/';
+const QWEN_HEADER_READ_CHUNK_BYTES = 4096;
+const QWEN_HEADER_MAX_BYTES = 256 * 1024;
+const getDefaultQwenHome = () => process.env.HIVE_QWEN_HOME ?? join(homedir(), '.qwen');
+export const getQwenHome = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultQwenHome();
+    const markerIndex = indexOfPathMarker(pattern, QWEN_SESSIONS_MARKER, platform);
+    if (markerIndex === -1)
+        return getDefaultQwenHome();
+    const rawRoot = pattern.slice(0, markerIndex).replace(/[\\/]+$/u, '');
+    const root = expandHomePath(rawRoot);
+    if (arePathsEqual(root, join(homedir(), '.qwen'), platform))
+        return getDefaultQwenHome();
+    return root || getDefaultQwenHome();
+};
+const walkSessionFiles = (dir) => {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                return walkSessionFiles(path);
+            return entry.isFile() && QWEN_SESSION_FILE.test(entry.name) ? [path] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+};
+const readQwenSessionHeader = (filePath, maxBytes = QWEN_HEADER_MAX_BYTES) => {
+    const fd = openSync(filePath, 'r');
+    try {
+        const chunks = [];
+        let totalBytes = 0;
+        let position = 0;
+        while (totalBytes < maxBytes) {
+            const bytesToRead = Math.min(QWEN_HEADER_READ_CHUNK_BYTES, maxBytes - totalBytes);
+            const buffer = Buffer.allocUnsafe(bytesToRead);
+            const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+            if (bytesRead === 0)
+                break;
+            const slice = buffer.subarray(0, bytesRead);
+            chunks.push(slice);
+            totalBytes += bytesRead;
+            position += bytesRead;
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+const readJsonStringField = (input, key) => {
+    const regex = new RegExp(`"${key}"\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`, 'u');
+    const raw = regex.exec(input)?.[1];
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const parseQwenSession = (filePath) => {
+    const header = readQwenSessionHeader(filePath);
+    const id = readJsonStringField(header, 'sessionId');
+    const cwd = readJsonStringField(header, 'projectRoot');
+    return id && cwd ? { cwd, id } : null;
+};
+const listSessionIds = (cwd, qwenHome = getDefaultQwenHome(), platform = process.platform) => {
+    const sessionsRoot = join(qwenHome, 'sessions');
+    return walkSessionFiles(sessionsRoot)
+        .flatMap((filePath) => {
+        try {
+            const session = parseQwenSession(filePath);
+            return session && arePathsEqual(session.cwd, cwd, platform) ? [session.id] : [];
+        }
+        catch {
+            return [];
+        }
+    })
+        .sort((left, right) => left.localeCompare(right));
+};
+export const hasQwenSession = (cwd, sessionId, pattern, platform = process.platform, qwenHome = getQwenHome(pattern, platform)) => listSessionIds(cwd, qwenHome, platform).includes(sessionId);
+export const snapshotQwenSessionIds = (cwd, qwenHome = getDefaultQwenHome(), platform = process.platform) => new Set(listSessionIds(cwd, qwenHome, platform));
+export const captureQwenSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, qwenHome = getDefaultQwenHome()) => {
+    await captureSessionIdWithCoordinator({
+        intervalMs,
+        knownSessionIds,
+        listSessionIds: () => listSessionIds(cwd, qwenHome),
+        onCapture,
+        projectKey: join(qwenHome, 'sessions', cwd),
+        timeoutMs,
+    });
+};
+export const qwenSessionStoreExists = (qwenHome = getDefaultQwenHome()) => existsSync(join(qwenHome, 'sessions'));

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

@@ -10,6 +10,9 @@ export type SessionIdCaptureConfig = {
 } | {
     source: 'opencode_session_db';
     pattern: string;
+} | {
+    source: 'qwen_session_json_dir';
+    pattern: string;
 } | {
     source: 'stdout_regex';
     pattern: string;
@@ -36,6 +39,7 @@ export declare const snapshotSessionIdsForCapture: (cwd: string, capture: Sessio
         CODEX_HOME?: never;
         HIVE_GEMINI_HOME?: never;
         HIVE_OPENCODE_DB_PATH?: never;
+        HIVE_QWEN_HOME?: never;
     };
     knownSessionIds: Set<string>;
     root: string;
@@ -45,6 +49,7 @@ export declare const snapshotSessionIdsForCapture: (cwd: string, capture: Sessio
         HIVE_CLAUDE_PROJECTS_DIR?: never;
         HIVE_GEMINI_HOME?: never;
         HIVE_OPENCODE_DB_PATH?: never;
+        HIVE_QWEN_HOME?: never;
     };
     knownSessionIds: Set<string>;
     root: string;
@@ -54,6 +59,7 @@ export declare const snapshotSessionIdsForCapture: (cwd: string, capture: Sessio
         HIVE_CLAUDE_PROJECTS_DIR?: never;
         CODEX_HOME?: never;
         HIVE_OPENCODE_DB_PATH?: never;
+        HIVE_QWEN_HOME?: never;
     };
     knownSessionIds: Set<string>;
     root: string;
@@ -63,6 +69,17 @@ export declare const snapshotSessionIdsForCapture: (cwd: string, capture: Sessio
         HIVE_CLAUDE_PROJECTS_DIR?: never;
         CODEX_HOME?: never;
         HIVE_GEMINI_HOME?: never;
+        HIVE_QWEN_HOME?: never;
+    };
+    knownSessionIds: Set<string>;
+    root: string;
+} | {
+    env: {
+        HIVE_QWEN_HOME: string;
+        HIVE_CLAUDE_PROJECTS_DIR?: never;
+        CODEX_HOME?: never;
+        HIVE_GEMINI_HOME?: never;
+        HIVE_OPENCODE_DB_PATH?: never;
     };
     knownSessionIds: Set<string>;
     root: string;

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

@@ -2,6 +2,7 @@ import { captureClaudeSessionId, getClaudeProjectsRoot, hasClaudeSessionFile, sn
 import { captureCodexSessionId, getCodexHome, hasCodexSession, snapshotCodexSessionIds, } from './session-capture-codex.js';
 import { captureGeminiSessionId, getGeminiHome, hasGeminiSession, snapshotGeminiSessionIds, } from './session-capture-gemini.js';
 import { captureOpenCodeSessionId, getOpenCodeDbPath, hasOpenCodeSession, snapshotOpenCodeSessionIds, } from './session-capture-opencode.js';
+import { captureQwenSessionId, getQwenHome, hasQwenSession, snapshotQwenSessionIds, } from './session-capture-qwen.js';
 const hasSource = (value) => Boolean(value && typeof value === 'object' && 'source' in value);
 export const parseSessionIdCapture = (value) => {
     if (!hasSource(value))
@@ -13,6 +14,7 @@ export const parseSessionIdCapture = (value) => {
         value.source === 'codex_session_jsonl_dir' ||
         value.source === 'gemini_session_json_dir' ||
         value.source === 'opencode_session_db' ||
+        value.source === 'qwen_session_json_dir' ||
         value.source === 'stdout_regex') {
         return typeof pattern === 'string' ? { pattern, source: value.source } : null;
     }
@@ -57,6 +59,14 @@ export const snapshotSessionIdsForCapture = (cwd, capture, discriminator) => {
             root: dbPath,
         };
     }
+    if (capture.source === 'qwen_session_json_dir') {
+        const qwenHome = getQwenHome(capture.pattern);
+        return {
+            env: { HIVE_QWEN_HOME: qwenHome },
+            knownSessionIds: snapshotQwenSessionIds(cwd, qwenHome),
+            root: qwenHome,
+        };
+    }
     if (capture.source === 'stdout_regex') {
         return {
             knownSessionIds: new Set(),
@@ -78,6 +88,9 @@ export const captureSessionIdForCapture = async (cwd, capture, snapshot, onCaptu
     if (capture.source === 'opencode_session_db') {
         await captureOpenCodeSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
     }
+    if (capture.source === 'qwen_session_json_dir') {
+        await captureQwenSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
+    }
     if (capture.source === 'stdout_regex') {
         await captureStdoutRegexSessionId(capture.pattern, snapshot.getOutput, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs);
     }
@@ -95,6 +108,9 @@ export const doesCapturedSessionExist = (cwd, capture, sessionId, discriminator)
     if (capture.source === 'opencode_session_db') {
         return hasOpenCodeSession(cwd, sessionId, capture.pattern);
     }
+    if (capture.source === 'qwen_session_json_dir') {
+        return hasQwenSession(cwd, sessionId, capture.pattern);
+    }
     return false;
 };
 const compileCaptureRegex = (pattern) => {

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

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

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

@@ -0,0 +1,43 @@
+// v23 — remote-access (mobile) audit trail. The tunnel/bridge layer is the
+// SINGLE collection point for every remote HTTP request + WS-input event
+// (see the plan's 审计规格): one place to record so no per-route handler has
+// to know about remote at all. Rows are append-only and written async off the
+// forwarding path (remote-audit-store.ts), so a slow disk never stalls a frame.
+//
+// Schema notes:
+//   - remote_device_id is the M1 session's device id; it's an audit/revocation
+//     tag, NEVER a permission branch (Authority Model: paired device == local).
+//   - action is a coarse category, not a full URL ('http' for bridged API
+//     requests, 'ws_input' for terminal/tasks stdin, plus lifecycle/control
+//     actions like 'session_open' / 'revoke' / 'reject'). endpoint holds the
+//     whitelisted path ('/api/...' '/ws/...') when there is one.
+//   - result is 'ok' | 'rejected' | 'error'. reject_reason is set ONLY on a
+//     rejection (off-whitelist path, revoked device, forged secret, …) so the
+//     security tests can assert the reason text, not just that a row exists.
+//   - WS input is summarised: byte_count + a short truncated preview. We NEVER
+//     persist full stdin (that's the user typing into a YOLO terminal). The
+//     preview is bounded by the store before it reaches here.
+//
+// Index covers the Settings audit-stream view: newest-first, optionally scoped
+// to one device.
+export const applySchemaVersion23 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS remote_audit (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      remote_device_id TEXT,
+      ts INTEGER NOT NULL,
+      workspace_id TEXT,
+      action TEXT NOT NULL,
+      endpoint TEXT,
+      result TEXT NOT NULL,
+      reject_reason TEXT,
+      byte_count INTEGER,
+      preview TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_remote_audit_recent
+      ON remote_audit (id DESC);
+    CREATE INDEX IF NOT EXISTS idx_remote_audit_device
+      ON remote_audit (remote_device_id, id DESC);
+  `);
+};

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

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

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

@@ -0,0 +1,34 @@
+// v24 — paired remote devices. A row exists ONLY after a human confirmed the pairing at the desktop
+// (Authority Model trust root): the pending handshake lives in memory in remote-pairing.ts and is
+// INSERTed here on confirm, NEVER before.
+//
+// key_d2p/key_p2d are the M3 DeviceSession.keys — M6.1 reinterprets these as the directional ROOT keys:
+// the bridge derives a fresh per-connection AEAD key from them on every connect (deriveConnectionKeys)
+// and never seals/opens under the stored bytes directly. The at-rest format is byte-identical — no
+// schema change, no version bump; v24 rows are forward-compatible (their stored material IS the root).
+// They are a stored secret in the sense that they decrypt all of that device's E2E traffic, but the
+// protection here is
+// exactly the same filesystem-local posture as remote_daemon_token (plaintext in app_state, see
+// remote-config-keys.ts): the runtime.sqlite file lives next to the daemon on 127.0.0.1. This is NOT
+// encryption-at-rest. If at-rest encryption is later wanted it should cover daemon_token + these keys
+// together as a single hardening item, not be implied here.
+//
+// revoked_at != NULL = dead device: the persistent provider returns null for it at once (live streams
+// drop on the next frame). Rows are kept (soft tombstone) so the device list / audit can still show a
+// revoked device.
+export const applySchemaVersion24 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS remote_devices (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL,
+      key_d2p       TEXT NOT NULL,   -- base64url(32) daemon->phone (daemon SEALS)
+      key_p2d       TEXT NOT NULL,   -- base64url(32) phone->daemon (daemon OPENS)
+      device_pubkey TEXT NOT NULL,   -- base64url(32); audit/debug, not secret
+      created_at    INTEGER NOT NULL,
+      last_active   INTEGER,
+      revoked_at    INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_remote_devices_active
+      ON remote_devices (revoked_at, created_at DESC);
+  `);
+};

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

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