@myagentroam/node 0.9.120 → 0.9.122

package/dist/connector.js

@@ -1778,14 +1778,14 @@ export class NodeConnector {
         this.hostedConversationRuntime = undefined;
         this.hostedConversationOperations = undefined;
         this.conversationHostingMaintenanceOperations = undefined;
-        void this.workspaceUploadService.shutdown();
+        const uploadDrain = this.workspaceUploadService.shutdown();
         this.workspaceFileService.dispose();
         this.workspaceWatchService.clearAll();
         this.workspaceWorkbenchService.clear();
         this.workspaceSessionService.clear();
         this.workspaceChangeService.clear();
         const runnerDrain = this.runners.stop();
-        void this.goalMcpServer.close();
+        const goalMcpDrain = this.goalMcpServer.close();
         // close() transitions metadata before awaiting process-tree termination,
         // so the lifecycle is persisted before this synchronous shutdown returns.
         const terminalDrain = this.terminalManager.shutdown();
@@ -1796,13 +1796,20 @@ export class NodeConnector {
         this.controlChannel.stop();
         const database = this.database;
         this.database = undefined;
+        const drains = Promise.allSettled([
+            marAgentDrain,
+            runnerDrain,
+            terminalDrain,
+            uploadDrain,
+            goalMcpDrain
+        ]);
         this.stopping = (async () => {
             try {
                 await conversationHostingMaintenanceDrain;
             }
             finally {
                 await hostedConversationRuntime?.dispose().catch(() => undefined);
-                await Promise.allSettled([marAgentDrain, runnerDrain, terminalDrain]);
+                await drains;
                 await this.gitExecutionService?.close();
                 database?.close();
             }

package/dist/database.js

@@ -4,16 +4,10 @@ import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
 import { mcpCatalogEntrySchema, mcpInstallationConfigurationSchema, mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
-import { assertNodeSchemaV4, NODE_SCHEMA_V4, NODE_SCHEMA_VERSION_V4 } from './migrations/v004.js';
-import { assertNodeSchemaV5, NODE_SCHEMA_MIGRATION_V5, NODE_SCHEMA_VERSION_V5 } from './migrations/v005.js';
-import { assertNodeSchemaV6, NODE_SCHEMA_MIGRATION_V6, NODE_SCHEMA_VERSION_V6 } from './migrations/v006.js';
-import { assertNodeSchemaV7, NODE_SCHEMA_MIGRATION_V7, NODE_SCHEMA_VERSION_V7 } from './migrations/v007.js';
-import { assertNodeSchemaV8, NODE_SCHEMA_MIGRATION_V8, NODE_SCHEMA_VERSION_V8 } from './migrations/v008.js';
-import { assertNodeSchemaV9, isDraftNodeSchemaV9, NODE_SCHEMA_MIGRATION_V9, NODE_SCHEMA_MIGRATION_V9_FINALIZE, NODE_SCHEMA_VERSION_V9 } from './migrations/v009.js';
-import { assertNodeSchemaV10, NODE_SCHEMA_MIGRATION_V10, NODE_SCHEMA_VERSION_V10 } from './migrations/v010.js';
-import { assertNodeSchemaV11, NODE_SCHEMA_MIGRATION_V11, NODE_SCHEMA_VERSION_V11 } from './migrations/v011.js';
-import { assertNodeSchemaV12, NODE_SCHEMA_MIGRATION_V12, NODE_SCHEMA_VERSION_V12 } from './migrations/v012.js';
-const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V12;
+import { assertNodeSchemaV13, NODE_SCHEMA_V13, NODE_SCHEMA_VERSION_V13 } from './migrations/v013.js';
+// Future released migrations must be contiguous, immutable and begin at v14; Demo is excluded.
+export const NODE_SCHEMA_MIGRATIONS = [];
+const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 export class NodeDatabase {
     now;
     raw;
@@ -28,8 +22,15 @@ export class NodeDatabase {
                 timeout: 5_000,
                 defensive: true
             });
-            this.raw.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
-            migrate(this.raw);
+            try {
+                // Refuse unsupported databases before changing the on-disk journal mode.
+                migrate(this.raw);
+                this.raw.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+            }
+            catch (error) {
+                this.raw.close();
+                throw error;
+            }
         }
         finally {
             releaseMigrationLock();
@@ -335,7 +336,10 @@ export class NodeDatabase {
         return (Number(this.raw.prepare('DELETE FROM agent_sessions WHERE id = ?').run(sessionId).changes) > 0);
     }
 }
-function migrate(database) {
+export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
+    if (catalog.some((entry, index) => entry.version !== NODE_SCHEMA_VERSION_V13 + index + 1))
+        throw new Error('NODE_DATABASE_MIGRATION_CATALOG_INVALID');
+    const latest = NODE_SCHEMA_VERSION_V13 + catalog.length;
     const existingMigrationTable = database
         .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'node_schema_migrations'")
         .get();
@@ -347,10 +351,11 @@ function migrate(database) {
             throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
         database.exec('BEGIN IMMEDIATE');
         try {
-            database.exec(NODE_SCHEMA_V4);
+            database.exec(NODE_SCHEMA_V13);
             database
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V4, Date.now());
+                .run(NODE_SCHEMA_VERSION_V13, Date.now());
+            assertNodeSchemaV13(database);
             database.exec('COMMIT');
         }
         catch (error) {
@@ -358,80 +363,24 @@ function migrate(database) {
             throw error;
         }
     }
-    const migrations = database
+    const versions = database
         .prepare('SELECT version FROM node_schema_migrations ORDER BY version')
-        .all();
-    const versions = migrations.map((row) => numberValue(row, 'version'));
-    const current = versions.at(-1);
-    if (current === undefined ||
-        current < NODE_SCHEMA_VERSION_V4 ||
-        current > NODE_SCHEMA_VERSION ||
-        !versions.includes(NODE_SCHEMA_VERSION_V4))
-        throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
-    if (versions.some((version, index) => index > 0 && version !== (versions[index - 1] ?? 0) + 1))
-        throw new Error('NODE_DATABASE_MIGRATION_HISTORY_INVALID');
-    assertNodeSchemaV4(database);
-    if (current === NODE_SCHEMA_VERSION_V4) {
-        database.exec('BEGIN IMMEDIATE');
-        try {
-            database.exec(NODE_SCHEMA_MIGRATION_V5);
-            database
-                .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V5, Date.now());
-            database.exec('COMMIT');
-        }
-        catch (error) {
-            database.exec('ROLLBACK');
-            throw error;
-        }
-    }
-    assertNodeSchemaV5(database);
-    const migrated = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    if (numberValue(migrated, 'version') === NODE_SCHEMA_VERSION_V5) {
-        database.exec('BEGIN IMMEDIATE');
-        try {
-            database.exec(NODE_SCHEMA_MIGRATION_V6);
-            database
-                .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V6, Date.now());
-            database.exec('COMMIT');
-        }
-        catch (error) {
-            database.exec('ROLLBACK');
-            throw error;
-        }
-    }
-    const migratedV6 = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    if (numberValue(migratedV6, 'version') === NODE_SCHEMA_VERSION_V6) {
-        assertNodeSchemaV6(database);
-        database.exec('BEGIN IMMEDIATE');
-        try {
-            database.exec(NODE_SCHEMA_MIGRATION_V7);
-            database
-                .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V7, Date.now());
-            database.exec('COMMIT');
-        }
-        catch (error) {
-            database.exec('ROLLBACK');
-            throw error;
-        }
-    }
-    assertNodeSchemaV7(database);
-    const migratedV7 = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    if (numberValue(migratedV7, 'version') === NODE_SCHEMA_VERSION_V7) {
+        .all().map((row) => numberValue(row, 'version'));
+    const firstLegacyVersion = versions[0];
+    if (firstLegacyVersion !== undefined &&
+        firstLegacyVersion >= 1 &&
+        firstLegacyVersion <= 4 &&
+        versions.length === LEGACY_NODE_SCHEMA_V12 - firstLegacyVersion + 1 &&
+        versions.every((version, index) => version === firstLegacyVersion + index)) {
+        // v13 is a history-compaction baseline. The final v12 schema is still the v13 schema;
+        // validate it before atomically replacing only the migration ledger.
+        assertNodeSchemaV13(database);
         database.exec('BEGIN IMMEDIATE');
         try {
-            database.exec(NODE_SCHEMA_MIGRATION_V8);
+            database.prepare('DELETE FROM node_schema_migrations').run();
             database
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V8, Date.now());
+                .run(NODE_SCHEMA_VERSION_V13, Date.now());
             database.exec('COMMIT');
         }
         catch (error) {
@@ -439,37 +388,28 @@ function migrate(database) {
             throw error;
         }
     }
-    assertNodeSchemaV8(database);
-    const migratedV8 = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    const migratedV8Version = numberValue(migratedV8, 'version');
-    if (migratedV8Version <= NODE_SCHEMA_VERSION_V9) {
-        if (migratedV8Version === NODE_SCHEMA_VERSION_V8)
-            applyNodeSchemaV9Migration(database, NODE_SCHEMA_MIGRATION_V9, true);
-        else if (isDraftNodeSchemaV9(database))
-            applyNodeSchemaV9Migration(database, NODE_SCHEMA_MIGRATION_V9_FINALIZE, false);
-        assertNodeSchemaV9(database);
-        applyNodeSchemaV10Migration(database);
-    }
-    assertNodeSchemaV10(database);
-    const migratedV10 = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    if (numberValue(migratedV10, 'version') === NODE_SCHEMA_VERSION_V10)
-        applyNodeSchemaV11Migration(database);
-    assertNodeSchemaV11(database);
-    const migratedV11 = database
-        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
-        .get();
-    if (numberValue(migratedV11, 'version') === NODE_SCHEMA_VERSION_V11) {
+    const migratedVersions = database
+        .prepare('SELECT version FROM node_schema_migrations ORDER BY version')
+        .all().map((row) => numberValue(row, 'version'));
+    const current = migratedVersions.at(-1);
+    if (current === undefined ||
+        current < NODE_SCHEMA_VERSION_V13 ||
+        current > latest ||
+        migratedVersions[0] !== NODE_SCHEMA_VERSION_V13)
+        throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
+    if (migratedVersions.some((version, index) => version !== NODE_SCHEMA_VERSION_V13 + index))
+        throw new Error('NODE_DATABASE_MIGRATION_HISTORY_INVALID');
+    assertNodeSchemaV13(database);
+    for (const entry of catalog) {
+        if (entry.version <= current)
+            continue;
         database.exec('BEGIN IMMEDIATE');
         try {
-            database.exec(NODE_SCHEMA_MIGRATION_V12);
+            database.exec(entry.sql);
+            entry.assert(database);
             database
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V12, Date.now());
-            assertNodeSchemaV12(database);
+                .run(entry.version, Date.now());
             database.exec('COMMIT');
         }
         catch (error) {
@@ -477,62 +417,8 @@ function migrate(database) {
             throw error;
         }
     }
-    assertNodeSchemaV12(database);
-}
-function applyNodeSchemaV9Migration(database, migration, recordVersion) {
-    database.exec('PRAGMA foreign_keys = OFF');
-    try {
-        database.exec('BEGIN IMMEDIATE');
-        database.exec(migration);
-        if (recordVersion)
-            database
-                .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-                .run(NODE_SCHEMA_VERSION_V9, Date.now());
-        database.exec('COMMIT');
-    }
-    catch (error) {
-        database.exec('ROLLBACK');
-        throw error;
-    }
-    finally {
-        database.exec('PRAGMA foreign_keys = ON');
-    }
-}
-function applyNodeSchemaV10Migration(database) {
-    database.exec('PRAGMA foreign_keys = OFF');
-    try {
-        database.exec('BEGIN IMMEDIATE');
-        database.exec(NODE_SCHEMA_MIGRATION_V10);
-        database
-            .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-            .run(NODE_SCHEMA_VERSION_V10, Date.now());
-        database.exec('COMMIT');
-    }
-    catch (error) {
-        database.exec('ROLLBACK');
-        throw error;
-    }
-    finally {
-        database.exec('PRAGMA foreign_keys = ON');
-    }
-}
-function applyNodeSchemaV11Migration(database) {
-    database.exec('PRAGMA foreign_keys = OFF');
-    try {
-        database.exec('BEGIN IMMEDIATE');
-        database.exec(NODE_SCHEMA_MIGRATION_V11);
-        database
-            .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
-            .run(NODE_SCHEMA_VERSION_V11, Date.now());
-        database.exec('COMMIT');
-    }
-    catch (error) {
-        database.exec('ROLLBACK');
-        throw error;
-    }
-    finally {
-        database.exec('PRAGMA foreign_keys = ON');
-    }
+    if (catalog.length > 0)
+        catalog[catalog.length - 1].assert(database);
 }
 function mcpInstallation(row) {
     const runtime = mcpRuntimeDescriptorSchema.parse(JSON.parse(stringValue(row, 'runtime')));

package/dist/migrations/demo.js

@@ -0,0 +1,9 @@
+/** Example only: never import this migration into the production catalog. */
+export const NODE_SCHEMA_MIGRATION_DEMO = {
+    version: 1,
+    sql: 'CREATE TABLE migration_demo_example (id INTEGER PRIMARY KEY) STRICT;',
+    assert: (database) => {
+        if (!database.prepare("SELECT 1 FROM sqlite_master WHERE name='migration_demo_example'").get())
+            throw new Error('NODE_DATABASE_SCHEMA_INVALID:migration_demo_example');
+    }
+};

package/dist/migrations/types.js

@@ -0,0 +1 @@
+export {};

package/dist/migrations/v013.js

@@ -0,0 +1,327 @@
+import { DatabaseSync } from 'node:sqlite';
+export const NODE_SCHEMA_VERSION_V13 = 13;
+/** Complete schema at the supported SQLite baseline; future changes use the migration catalog. */
+export const NODE_SCHEMA_V13 = String.raw `CREATE TABLE "agent_sessions" (
+    id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+    runner TEXT NOT NULL CHECK (runner IN ('mar-agent', 'codex', 'claude-code', 'opencode')),
+    pin_order INTEGER CHECK (pin_order IS NULL OR pin_order >= 0),
+    metadata TEXT NOT NULL CHECK (json_valid(metadata))
+  ) STRICT;
+
+CREATE TABLE "conversation_files" (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL REFERENCES hosted_conversations(id) ON DELETE CASCADE,
+    category TEXT NOT NULL CHECK (category IN ('UPLOAD','OUTPUT')),
+    relative_path TEXT NOT NULL,
+    display_name TEXT NOT NULL,
+    mime_type TEXT NOT NULL,
+    size INTEGER NOT NULL CHECK (size >= 0),
+    source TEXT NOT NULL CHECK (source IN ('USER','AGENT','SYSTEM')),
+    turn_id TEXT,
+    item_id TEXT,
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0),
+    UNIQUE (conversation_id, category, relative_path)
+  ) STRICT;
+
+CREATE TABLE conversation_template_publish_jobs (
+    id TEXT PRIMARY KEY,
+    template_id TEXT NOT NULL,
+    draft_revision INTEGER NOT NULL CHECK (draft_revision > 0),
+    stage TEXT NOT NULL CHECK (
+      stage IN ('VALIDATING','ENUMERATING','COPYING','SCANNING','MANIFEST','SEALED','REGISTERED')
+    ),
+    status TEXT NOT NULL CHECK (status IN ('QUEUED','RUNNING','SUCCEEDED','FAILED')),
+    version_id TEXT REFERENCES conversation_template_versions(id) ON DELETE SET NULL,
+    error_code TEXT,
+    error_summary TEXT,
+    requested_by_user_id INTEGER NOT NULL CHECK (requested_by_user_id > 0),
+    draft TEXT NOT NULL CHECK (json_valid(draft)),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0)
+  ) STRICT;
+
+CREATE TABLE conversation_template_versions (
+    id TEXT PRIMARY KEY,
+    template_id TEXT NOT NULL,
+    version_number INTEGER NOT NULL CHECK (version_number > 0),
+    draft_revision INTEGER NOT NULL CHECK (draft_revision > 0),
+    status TEXT NOT NULL CHECK (status IN ('AVAILABLE','DISABLED','CORRUPTED','RETAINED')),
+    storage_key TEXT NOT NULL UNIQUE,
+    manifest TEXT NOT NULL CHECK (json_valid(manifest)),
+    content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),
+    manifest_hash TEXT NOT NULL CHECK (length(manifest_hash) = 64),
+    file_count INTEGER NOT NULL CHECK (file_count >= 0),
+    total_bytes INTEGER NOT NULL CHECK (total_bytes >= 0),
+    host_policy_version INTEGER NOT NULL CHECK (host_policy_version > 0),
+    published_by_user_id INTEGER NOT NULL CHECK (published_by_user_id > 0),
+    published_at INTEGER NOT NULL CHECK (published_at >= 0),
+    reference_count INTEGER NOT NULL DEFAULT 0 CHECK (reference_count >= 0), mcp_config_hash TEXT NOT NULL DEFAULT '4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945'
+    CHECK (length(mcp_config_hash) = 64),
+    UNIQUE (template_id, version_number)
+  ) STRICT;
+
+CREATE TABLE hosted_conversation_messages (
+    conversation_id TEXT NOT NULL REFERENCES hosted_conversations(id) ON DELETE CASCADE,
+    client_message_id TEXT NOT NULL,
+    run_id TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('RUNNING','SUCCEEDED','FAILED','INTERRUPTED')),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0), user_text_present INTEGER NOT NULL DEFAULT 1
+      CHECK (user_text_present IN (0,1)),
+    PRIMARY KEY (conversation_id, client_message_id)
+  ) STRICT;
+
+CREATE TABLE "hosted_conversations" (
+    id TEXT PRIMARY KEY,
+    user_storage_key TEXT NOT NULL,
+    conversation_storage_key TEXT NOT NULL,
+    client_request_id TEXT,
+    node_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    template_id TEXT NOT NULL,
+    template_name TEXT NOT NULL,
+    active_version_id TEXT NOT NULL REFERENCES conversation_template_versions(id),
+    title TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('ACTIVE')),
+    model_id TEXT NOT NULL,
+    template_deleted INTEGER NOT NULL DEFAULT 0 CHECK (template_deleted IN (0,1)),
+    used_bytes INTEGER NOT NULL DEFAULT 0 CHECK (used_bytes >= 0),
+    max_bytes INTEGER NOT NULL CHECK (max_bytes > 0),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0),
+    last_activity_at INTEGER NOT NULL CHECK (last_activity_at >= 0),
+    pinned_at INTEGER CHECK (pinned_at IS NULL OR pinned_at >= 0),
+    title_source TEXT NOT NULL DEFAULT 'CUSTOM'
+      CHECK (title_source IN ('DEFAULT','AUTO','CUSTOM')),
+    UNIQUE (user_storage_key, conversation_storage_key),
+    UNIQUE (user_storage_key, client_request_id)
+  ) STRICT;
+
+CREATE TABLE mcp_installations (
+      target_kind TEXT NOT NULL CHECK (target_kind IN ('NODE','WORKSPACE')),
+      target_id TEXT NOT NULL, catalog_entry_id TEXT NOT NULL, server_name TEXT NOT NULL,
+      display_name TEXT NOT NULL, version TEXT NOT NULL,
+      enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
+      runtime TEXT NOT NULL CHECK (json_valid(runtime)),
+      configuration TEXT NOT NULL CHECK (json_valid(configuration)), installed_at INTEGER NOT NULL,
+      PRIMARY KEY (target_kind,target_id,server_name),
+      CHECK ((target_kind='NODE' AND target_id='') OR (target_kind='WORKSPACE' AND target_id<>''))
+    ) STRICT;
+
+CREATE TABLE node_schema_migrations (
+      version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL
+    ) STRICT;
+
+CREATE TABLE "runner_defaults" (
+    runner TEXT PRIMARY KEY CHECK (runner IN ('mar-agent', 'codex', 'claude-code', 'opencode')),
+    model TEXT NOT NULL, effort TEXT NOT NULL, access TEXT NOT NULL
+  ) STRICT;
+
+CREATE TABLE terminal_sessions (
+      id TEXT PRIMARY KEY, workspace_id TEXT REFERENCES workspaces(id) ON DELETE SET NULL,
+      profile_id TEXT NOT NULL,
+      state TEXT NOT NULL CHECK (state IN ('RUNNING', 'EXITED', 'CLOSED')),
+      exit_code INTEGER, rows INTEGER NOT NULL CHECK (rows > 0 AND rows <= 1000),
+      cols INTEGER NOT NULL CHECK (cols > 0 AND cols <= 1000),
+      latest_sequence INTEGER NOT NULL CHECK (latest_sequence >= 0),
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+    ) STRICT;
+
+CREATE TABLE workspaces (
+      id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE,
+      kind TEXT NOT NULL CHECK (kind IN ('DIRECTORY', 'GIT_WORKSPACE')),
+      git_summary TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+    , preserve_git_config INTEGER NOT NULL DEFAULT 1 CHECK (preserve_git_config IN (0,1))) STRICT;
+
+CREATE INDEX conversation_files_conversation_updated
+    ON conversation_files(conversation_id, updated_at DESC, id);
+
+CREATE INDEX conversation_template_publish_jobs_status
+    ON conversation_template_publish_jobs(status, updated_at);
+
+CREATE INDEX conversation_template_publish_jobs_template
+    ON conversation_template_publish_jobs(template_id, created_at, id);
+
+CREATE INDEX conversation_template_versions_template_status
+    ON conversation_template_versions(template_id, status, published_at);
+
+CREATE INDEX hosted_conversations_template
+    ON hosted_conversations(template_id, status, id);
+
+CREATE INDEX hosted_conversations_user_pin_activity
+    ON hosted_conversations(
+      user_storage_key,
+      (pinned_at IS NOT NULL) DESC,
+      last_activity_at DESC,
+      id DESC
+    );`;
+export function assertNodeSchemaV13(database, exactBaseline = false) {
+    const required = {
+        agent_sessions: ['id', 'workspace_id', 'runner', 'pin_order', 'metadata'],
+        conversation_files: [
+            'id',
+            'conversation_id',
+            'category',
+            'relative_path',
+            'display_name',
+            'mime_type',
+            'size',
+            'source',
+            'turn_id',
+            'item_id',
+            'created_at',
+            'updated_at'
+        ],
+        conversation_template_publish_jobs: [
+            'id',
+            'template_id',
+            'draft_revision',
+            'stage',
+            'status',
+            'version_id',
+            'error_code',
+            'error_summary',
+            'requested_by_user_id',
+            'draft',
+            'created_at',
+            'updated_at'
+        ],
+        conversation_template_versions: [
+            'id',
+            'template_id',
+            'version_number',
+            'draft_revision',
+            'status',
+            'storage_key',
+            'manifest',
+            'content_hash',
+            'manifest_hash',
+            'file_count',
+            'total_bytes',
+            'host_policy_version',
+            'published_by_user_id',
+            'published_at',
+            'reference_count',
+            'mcp_config_hash'
+        ],
+        hosted_conversation_messages: [
+            'conversation_id',
+            'client_message_id',
+            'run_id',
+            'status',
+            'created_at',
+            'updated_at',
+            'user_text_present'
+        ],
+        hosted_conversations: [
+            'id',
+            'user_storage_key',
+            'conversation_storage_key',
+            'client_request_id',
+            'node_id',
+            'session_id',
+            'template_id',
+            'template_name',
+            'active_version_id',
+            'title',
+            'status',
+            'model_id',
+            'template_deleted',
+            'used_bytes',
+            'max_bytes',
+            'created_at',
+            'updated_at',
+            'last_activity_at',
+            'pinned_at',
+            'title_source'
+        ],
+        mcp_installations: [
+            'target_kind',
+            'target_id',
+            'catalog_entry_id',
+            'server_name',
+            'display_name',
+            'version',
+            'enabled',
+            'runtime',
+            'configuration',
+            'installed_at'
+        ],
+        node_schema_migrations: ['version', 'applied_at'],
+        runner_defaults: ['runner', 'model', 'effort', 'access'],
+        terminal_sessions: [
+            'id',
+            'workspace_id',
+            'profile_id',
+            'state',
+            'exit_code',
+            'rows',
+            'cols',
+            'latest_sequence',
+            'created_at',
+            'updated_at'
+        ],
+        workspaces: [
+            'id',
+            'path',
+            'kind',
+            'git_summary',
+            'created_at',
+            'updated_at',
+            'preserve_git_config'
+        ]
+    };
+    for (const [table, expected] of Object.entries(required)) {
+        const columns = database.prepare(`PRAGMA table_info(${table})`).all();
+        if (expected.some((name) => !columns.some((column) => column.name === name)))
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${table}`);
+    }
+    for (const name of [
+        'conversation_files_conversation_updated',
+        'conversation_template_publish_jobs_status',
+        'conversation_template_publish_jobs_template',
+        'conversation_template_versions_template_status',
+        'hosted_conversations_template',
+        'hosted_conversations_user_pin_activity'
+    ]) {
+        if (!database.prepare("SELECT 1 FROM sqlite_master WHERE type='index' AND name=?").get(name))
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${name}`);
+    }
+    const workspace = database
+        .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='workspaces'")
+        .get();
+    if (typeof workspace?.sql !== 'string' ||
+        !workspace.sql.includes('preserve_git_config INTEGER NOT NULL DEFAULT 1'))
+        throw new Error('NODE_DATABASE_SCHEMA_INVALID:workspaces');
+    for (const name of ['agent_sessions', 'runner_defaults']) {
+        const row = database
+            .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name=?")
+            .get(name);
+        const definition = row?.sql;
+        if (typeof definition !== 'string' ||
+            !["'mar-agent'", "'codex'", "'claude-code'", "'opencode'"].every((runner) => definition.includes(runner)))
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${name}:runner`);
+    }
+    if (database.prepare('PRAGMA foreign_key_check').all().length !== 0)
+        throw new Error('NODE_DATABASE_SCHEMA_INVALID:foreign_keys');
+    if (exactBaseline) {
+        // Only compare whole DDL at v13; later additive migrations may extend these tables.
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            const query = "SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name";
+            const expected = reference.prepare(query).all();
+            const actual = database.prepare(query).all();
+            if (actual.length !== expected.length ||
+                expected.some((entry, index) => actual[index]?.type !== entry.type ||
+                    actual[index]?.name !== entry.name ||
+                    actual[index]?.sql !== entry.sql))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID:baseline');
+        }
+        finally {
+            reference.close();
+        }
+    }
+}

package/dist/runner/mar-agent/managed-run-controller.js

@@ -244,6 +244,7 @@ export class MarAgentManagedRunController {
         let executionModels = [];
         try {
             const sessionKey = input.externalSessionId ?? input.sessionId;
+            // Reserve both identities while opening so a concurrent release can await the same runtime.
             const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
             if (acquisitionKeys.some((key) => this.#runtimeAcquisitions.get(key) !== undefined))
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');