@myagentroam/node 0.9.171 → 0.9.173

package/dist/connector.js

@@ -1399,6 +1399,7 @@ export class NodeConnector {
                 throw new Error('NODE_CONFIG_UNAVAILABLE');
             return this.config;
         }, this.runtime, (workspaceId) => {
+            this.terminalManager.removeWorkspaceAssociation(workspaceId);
             this.workspaceFileService.dispose(workspaceId);
             this.workspaceCoordinator.invalidateChanges(workspaceId);
             this.workspaceSessionService.invalidate(workspaceId);

package/dist/database-relations.js

@@ -0,0 +1,42 @@
+export function assertNodeNoForeignKeys(database) {
+    const tables = database
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        .all();
+    for (const { name } of tables) {
+        if (database.prepare('SELECT 1 FROM pragma_foreign_key_list(?) LIMIT 1').get(name) !== undefined)
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:foreign_keys:${name}`);
+    }
+}
+/** Validate persisted Node associations independently of physical foreign keys. */
+export function assertNodeRelations(database) {
+    const checks = {
+        agent_sessions: `SELECT 1 FROM agent_sessions child LEFT JOIN workspaces parent
+      ON parent.id=child.workspace_id WHERE parent.id IS NULL LIMIT 1`,
+        terminal_sessions: `SELECT 1 FROM terminal_sessions child LEFT JOIN workspaces parent
+      ON parent.id=child.workspace_id WHERE child.workspace_id IS NOT NULL AND parent.id IS NULL LIMIT 1`,
+        conversation_files: `SELECT 1 FROM conversation_files child LEFT JOIN hosted_conversations parent
+      ON parent.id=child.conversation_id WHERE parent.id IS NULL LIMIT 1`,
+        hosted_conversation_messages: `SELECT 1 FROM hosted_conversation_messages child LEFT JOIN hosted_conversations parent
+      ON parent.id=child.conversation_id WHERE parent.id IS NULL LIMIT 1`,
+        hosted_conversations: `SELECT 1 FROM hosted_conversations child LEFT JOIN conversation_template_versions parent
+      ON parent.id=child.active_version_id WHERE parent.id IS NULL OR parent.template_id<>child.template_id LIMIT 1`,
+        conversation_template_publish_jobs: `SELECT 1 FROM conversation_template_publish_jobs child LEFT JOIN conversation_template_versions parent
+      ON parent.id=child.version_id WHERE child.version_id IS NOT NULL
+      AND (parent.id IS NULL OR parent.template_id<>child.template_id) LIMIT 1`,
+        scheduled_session_tasks: `SELECT 1 FROM scheduled_session_tasks child
+      LEFT JOIN agent_sessions session ON session.id=child.session_id
+      LEFT JOIN workspaces workspace ON workspace.id=child.workspace_id
+      WHERE session.id IS NULL OR workspace.id IS NULL OR session.workspace_id<>child.workspace_id
+      OR session.runner<>child.runner LIMIT 1`,
+        scheduled_session_occurrences: `SELECT 1 FROM scheduled_session_occurrences child LEFT JOIN scheduled_session_tasks parent
+      ON parent.id=child.task_id WHERE parent.id IS NULL LIMIT 1`,
+        scheduled_session_proposals: `SELECT 1 FROM scheduled_session_proposals child LEFT JOIN scheduled_session_tasks parent
+      ON parent.id=child.task_id WHERE parent.id IS NULL LIMIT 1`,
+        mcp_installations: `SELECT 1 FROM mcp_installations child LEFT JOIN workspaces parent
+      ON parent.id=child.target_id WHERE child.target_kind='WORKSPACE' AND parent.id IS NULL LIMIT 1`
+    };
+    for (const [table, query] of Object.entries(checks)) {
+        if (database.prepare(query).get() !== undefined)
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:relations:${table}`);
+    }
+}

package/dist/database.js

@@ -7,10 +7,14 @@ import { mcpCatalogEntrySchema, mcpInstallationConfigurationSchema, mcpRuntimeDe
 import { assertNodeSchemaV13, NODE_SCHEMA_V13, NODE_SCHEMA_VERSION_V13 } from './migrations/v013.js';
 import { NODE_SCHEMA_MIGRATION_V14 } from './migrations/v014.js';
 import { NODE_SCHEMA_MIGRATION_V15 } from './migrations/v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './migrations/v016.js';
+import { ScheduledSessionStore } from './service/scheduled-session-store.js';
+import { assertNodeNoForeignKeys, assertNodeRelations } from './database-relations.js';
 // Future released migrations must be contiguous, immutable and begin at v14; Demo is excluded.
 export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V14,
-    NODE_SCHEMA_MIGRATION_V15
+    NODE_SCHEMA_MIGRATION_V15,
+    NODE_SCHEMA_MIGRATION_V16
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;
@@ -24,14 +28,14 @@ export class NodeDatabase {
         const releaseMigrationLock = acquireNodeMigrationLock(path);
         try {
             this.raw = new DatabaseSync(path, {
-                enableForeignKeyConstraints: true,
+                enableForeignKeyConstraints: false,
                 timeout: 5_000,
                 defensive: true
             });
             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;');
+                this.raw.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;');
             }
             catch (error) {
                 this.raw.close();
@@ -42,6 +46,18 @@ export class NodeDatabase {
             releaseMigrationLock();
         }
     }
+    write(action) {
+        this.raw.exec('BEGIN IMMEDIATE');
+        try {
+            const result = action();
+            this.raw.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.raw.exec('ROLLBACK');
+            throw error;
+        }
+    }
     close() {
         this.raw.close();
     }
@@ -78,33 +94,35 @@ export class NodeDatabase {
         return rows.map(mcpInstallation);
     }
     saveMcpInstallation(input) {
-        const entry = mcpCatalogEntrySchema.parse(input.entry);
-        const configuration = mcpInstallationConfigurationSchema.parse(input.configuration);
-        const targetId = input.targetKind === 'NODE' ? '' : (input.targetId ?? '');
-        if (input.targetKind === 'WORKSPACE' && this.getWorkspace(targetId) === undefined)
-            throw new Error('WORKSPACE_NOT_FOUND');
-        const installedAt = this.now();
-        this.raw
-            .prepare(`INSERT INTO mcp_installations
-         (target_kind,target_id,catalog_entry_id,server_name,display_name,version,enabled,runtime,configuration,installed_at)
-         VALUES (?,?,?,?,?,?,?,?,?,?)
-         ON CONFLICT(target_kind,target_id,server_name) DO UPDATE SET
-           catalog_entry_id=excluded.catalog_entry_id,display_name=excluded.display_name,
-           version=excluded.version,enabled=excluded.enabled,runtime=excluded.runtime,
-           configuration=excluded.configuration,installed_at=excluded.installed_at`)
-            .run(input.targetKind, targetId, entry.id, entry.serverName, entry.displayName, entry.version, input.enabled ? 1 : 0, JSON.stringify(entry.runtime), JSON.stringify(configuration), installedAt);
-        return {
-            targetKind: input.targetKind,
-            targetId,
-            catalogEntryId: entry.id,
-            serverName: entry.serverName,
-            displayName: entry.displayName,
-            version: entry.version,
-            enabled: input.enabled,
-            runtime: entry.runtime,
-            configuration,
-            installedAt
-        };
+        return this.write(() => {
+            const entry = mcpCatalogEntrySchema.parse(input.entry);
+            const configuration = mcpInstallationConfigurationSchema.parse(input.configuration);
+            const targetId = input.targetKind === 'NODE' ? '' : (input.targetId ?? '');
+            if (input.targetKind === 'WORKSPACE' && this.getWorkspace(targetId) === undefined)
+                throw new Error('WORKSPACE_NOT_FOUND');
+            const installedAt = this.now();
+            this.raw
+                .prepare(`INSERT INTO mcp_installations
+           (target_kind,target_id,catalog_entry_id,server_name,display_name,version,enabled,runtime,configuration,installed_at)
+           VALUES (?,?,?,?,?,?,?,?,?,?)
+           ON CONFLICT(target_kind,target_id,server_name) DO UPDATE SET
+             catalog_entry_id=excluded.catalog_entry_id,display_name=excluded.display_name,
+             version=excluded.version,enabled=excluded.enabled,runtime=excluded.runtime,
+             configuration=excluded.configuration,installed_at=excluded.installed_at`)
+                .run(input.targetKind, targetId, entry.id, entry.serverName, entry.displayName, entry.version, input.enabled ? 1 : 0, JSON.stringify(entry.runtime), JSON.stringify(configuration), installedAt);
+            return {
+                targetKind: input.targetKind,
+                targetId,
+                catalogEntryId: entry.id,
+                serverName: entry.serverName,
+                displayName: entry.displayName,
+                version: entry.version,
+                enabled: input.enabled,
+                runtime: entry.runtime,
+                configuration,
+                installedAt
+            };
+        });
     }
     removeMcpInstallation(targetKind, targetId, serverName) {
         return (Number(this.raw
@@ -125,15 +143,19 @@ export class NodeDatabase {
      * the Node-local bounded replay buffer and must never be passed here.
      */
     saveTerminalSession(input) {
-        this.raw
-            .prepare(`INSERT INTO terminal_sessions
-          (id, workspace_id, profile_id, state, exit_code, rows, cols, latest_sequence, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET workspace_id = excluded.workspace_id, profile_id = excluded.profile_id, state = excluded.state,
-           exit_code = excluded.exit_code, rows = excluded.rows, cols = excluded.cols,
-           latest_sequence = excluded.latest_sequence, updated_at = excluded.updated_at`)
-            .run(input.id, input.workspaceId, input.profileId, input.state, input.exitCode, input.rows, input.cols, input.latestSequence, input.createdAt, input.updatedAt);
-        return this.getTerminalSession(input.id);
+        return this.write(() => {
+            if (input.workspaceId !== null && this.getWorkspace(input.workspaceId) === undefined)
+                throw new Error('WORKSPACE_NOT_FOUND');
+            this.raw
+                .prepare(`INSERT INTO terminal_sessions
+            (id, workspace_id, profile_id, state, exit_code, rows, cols, latest_sequence, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET workspace_id = excluded.workspace_id, profile_id = excluded.profile_id, state = excluded.state,
+             exit_code = excluded.exit_code, rows = excluded.rows, cols = excluded.cols,
+             latest_sequence = excluded.latest_sequence, updated_at = excluded.updated_at`)
+                .run(input.id, input.workspaceId, input.profileId, input.state, input.exitCode, input.rows, input.cols, input.latestSequence, input.createdAt, input.updatedAt);
+            return this.getTerminalSession(input.id);
+        });
     }
     getTerminalSession(id) {
         const row = this.raw
@@ -203,14 +225,16 @@ export class NodeDatabase {
         const current = this.getWorkspace(id);
         if (current === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
-        this.raw.exec('BEGIN');
+        this.raw.exec('BEGIN IMMEDIATE');
         try {
-            // Session deletion cascades their runs, conversation and attachments. The workspace
-            // record itself never represents a filesystem deletion.
+            new ScheduledSessionStore(this.raw).removeForWorkspace(id);
             this.raw.prepare('DELETE FROM agent_sessions WHERE workspace_id = ?').run(id);
             this.raw
                 .prepare("DELETE FROM mcp_installations WHERE target_kind='WORKSPACE' AND target_id = ?")
                 .run(id);
+            this.raw
+                .prepare('UPDATE terminal_sessions SET workspace_id=NULL WHERE workspace_id=?')
+                .run(id);
             this.raw.prepare('DELETE FROM workspaces WHERE id = ?').run(id);
             this.raw.exec('COMMIT');
             return current;
@@ -267,6 +291,16 @@ export class NodeDatabase {
         });
         this.raw.exec('BEGIN IMMEDIATE');
         try {
+            if (this.getWorkspace(input.workspaceId) === undefined)
+                throw new Error('WORKSPACE_NOT_FOUND');
+            const scheduled = this.raw
+                .prepare('SELECT workspace_id,runner FROM scheduled_session_tasks WHERE session_id=?')
+                .get(input.externalSessionId);
+            if (scheduled !== undefined &&
+                (scheduled['workspace_id'] !== input.workspaceId || scheduled['runner'] !== input.runner))
+                throw Object.assign(new Error('SCHEDULE_SESSION_MISMATCH'), {
+                    publicMessage: "The scheduled task must use its session's Workspace and Runner."
+                });
             if (pinAtTop)
                 this.raw
                     .prepare('UPDATE agent_sessions SET pin_order = pin_order + 1 WHERE workspace_id = ? AND pin_order IS NOT NULL')
@@ -339,7 +373,18 @@ export class NodeDatabase {
         }
     }
     deleteSessionRecord(sessionId) {
-        return (Number(this.raw.prepare('DELETE FROM agent_sessions WHERE id = ?').run(sessionId).changes) > 0);
+        this.raw.exec('BEGIN IMMEDIATE');
+        try {
+            new ScheduledSessionStore(this.raw).removeForSession(sessionId);
+            const removed = Number(this.raw.prepare('DELETE FROM agent_sessions WHERE id = ?').run(sessionId).changes) >
+                0;
+            this.raw.exec('COMMIT');
+            return removed;
+        }
+        catch (error) {
+            this.raw.exec('ROLLBACK');
+            throw error;
+        }
     }
 }
 export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
@@ -397,10 +442,12 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
     const migratedVersions = database
         .prepare('SELECT version FROM node_schema_migrations ORDER BY version')
         .all().map((row) => numberValue(row, 'version'));
-    if (latest === NODE_SCHEMA_MIGRATION_V15.version &&
+    if (latest >= NODE_SCHEMA_MIGRATION_V15.version &&
         migratedVersions.length === 4 &&
         migratedVersions.every((version, index) => version === NODE_SCHEMA_VERSION_V13 + index) &&
-        migratedVersions.at(-1) === OBSOLETE_NODE_SCHEMA_V16) {
+        migratedVersions.at(-1) === OBSOLETE_NODE_SCHEMA_V16 &&
+        database.prepare('PRAGMA table_info(scheduled_session_tasks)').all().some((column) => column.name === 'notify_user_id') &&
+        database.prepare('PRAGMA foreign_key_list(scheduled_session_tasks)').all().length !== 0) {
         downgradeLegacyRecipientSchema(database);
         migratedVersions.pop();
     }
@@ -416,10 +463,18 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
     for (const entry of catalog) {
         if (entry.version <= current)
             continue;
+        const foreignKeys = database.prepare('PRAGMA foreign_keys').get()?.['foreign_keys'];
+        if (entry.rebuildTables)
+            database.exec('PRAGMA foreign_keys=OFF');
         database.exec('BEGIN IMMEDIATE');
         try {
+            entry.preflight?.(database);
             database.exec(entry.sql);
             entry.assert(database);
+            if (entry.version >= NODE_SCHEMA_MIGRATION_V16.version) {
+                assertNodeNoForeignKeys(database);
+                assertNodeRelations(database);
+            }
             database
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
                 .run(entry.version, Date.now());
@@ -429,9 +484,17 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
             database.exec('ROLLBACK');
             throw error;
         }
+        finally {
+            if (entry.rebuildTables && foreignKeys === 1)
+                database.exec('PRAGMA foreign_keys=ON');
+        }
     }
     if (catalog.length > 0)
         catalog[catalog.length - 1].assert(database);
+    if (latest >= NODE_SCHEMA_MIGRATION_V16.version) {
+        assertNodeNoForeignKeys(database);
+        assertNodeRelations(database);
+    }
 }
 function downgradeLegacyRecipientSchema(database) {
     const reference = new DatabaseSync(':memory:');

package/dist/migrations/v016.js

@@ -0,0 +1,388 @@
+import { DatabaseSync } from 'node:sqlite';
+import { assertNodeRelations } from '../database-relations.js';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+const obsoleteTables = [
+    'share_sessions',
+    'share_invitations',
+    'share_participants',
+    'worktree_snapshots',
+    'worktree_shares'
+];
+const currentTables = [
+    'agent_sessions',
+    'conversation_files',
+    'conversation_template_publish_jobs',
+    'conversation_template_versions',
+    'hosted_conversation_messages',
+    'hosted_conversations',
+    'mcp_installations',
+    'node_schema_migrations',
+    'runner_defaults',
+    'scheduled_session_occurrences',
+    'scheduled_session_proposals',
+    'scheduled_session_tasks',
+    'terminal_sessions',
+    'workspaces'
+];
+const rebuiltColumns = {
+    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'
+    ],
+    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'
+    ],
+    scheduled_session_occurrences: [
+        'id',
+        'task_id',
+        'due_at',
+        'status',
+        'code',
+        'run_id',
+        'created_at',
+        'updated_at'
+    ],
+    scheduled_session_proposals: [
+        'id',
+        'task_id',
+        'proposed_by_user_id',
+        'base_revision',
+        'objective',
+        'cron',
+        'timezone',
+        'status',
+        'created_at',
+        'resolved_at'
+    ],
+    scheduled_session_tasks: [
+        'id',
+        'session_id',
+        'workspace_id',
+        'runner',
+        'owner_user_id',
+        'objective',
+        'cron',
+        'timezone',
+        'enabled',
+        'revision',
+        'next_run_at',
+        'created_at',
+        'updated_at',
+        'notify_on_terminal'
+    ],
+    terminal_sessions: [
+        'id',
+        'workspace_id',
+        'profile_id',
+        'state',
+        'exit_code',
+        'rows',
+        'cols',
+        'latest_sequence',
+        'created_at',
+        'updated_at'
+    ]
+};
+export const NODE_SCHEMA_MIGRATION_V16 = {
+    version: 16,
+    rebuildTables: true,
+    preflight(database) {
+        const tables = database
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+            .all();
+        for (const { name } of tables) {
+            if (obsoleteTables.some((table) => table === name)) {
+                if (database.prepare(`SELECT 1 FROM "${name}" LIMIT 1`).get() !== undefined)
+                    throw new Error(`NODE_DATABASE_OBSOLETE_TABLE_NOT_EMPTY:${name}`);
+            }
+            else if (!currentTables.some((table) => table === name)) {
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:table:${name}`);
+            }
+        }
+        for (const [table, expected] of Object.entries(rebuiltColumns)) {
+            const actual = database.prepare(`PRAGMA table_info(${table})`).all();
+            if (actual.length !== expected.length ||
+                actual.some((column) => !expected.includes(column.name)))
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${table}`);
+        }
+        if (database.prepare("SELECT 1 FROM sqlite_master WHERE type='trigger' LIMIT 1").get() !==
+            undefined)
+            throw new Error('NODE_DATABASE_SCHEMA_INVALID:triggers');
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            reference.exec(NODE_SCHEMA_MIGRATION_V14.sql);
+            reference.exec(NODE_SCHEMA_MIGRATION_V15.sql);
+            const normalize = (sql) => sql
+                .replace(/\s+REFERENCES\s+\w+\([^)]*\)(?:\s+ON DELETE\s+(?:CASCADE|SET NULL))?/giu, '')
+                .replace(/"(\w+)"/gu, '$1')
+                .replace(/\s+/gu, ' ')
+                .replace(/\s*([(),])\s*/gu, '$1')
+                .trim();
+            const query = "SELECT type,name,tbl_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().filter((entry) => !obsoleteTables.some((table) => table === entry.tbl_name));
+            const definition = (entry) => {
+                const sql = normalize(entry.sql);
+                // Released upgrades appended this nullable column; new installs declared it second.
+                return entry.name === 'terminal_sessions'
+                    ? sql.replace(/(?:,workspace_id TEXT|workspace_id TEXT,)/u, '')
+                    : sql;
+            };
+            if (actual.length !== expected.length ||
+                expected.some((entry, index) => entry.type !== actual[index]?.type ||
+                    entry.name !== actual[index]?.name ||
+                    definition(entry) !== definition(actual[index])))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID:definitions');
+        }
+        finally {
+            reference.close();
+        }
+    },
+    sql: `DROP TABLE IF EXISTS share_sessions;
+DROP TABLE IF EXISTS share_invitations;
+DROP TABLE IF EXISTS share_participants;
+DROP TABLE IF EXISTS worktree_snapshots;
+DROP TABLE IF EXISTS worktree_shares;
+CREATE TABLE _node_v16_agent_sessions (
+    id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL,
+    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;
+INSERT INTO _node_v16_agent_sessions (id,workspace_id,runner,pin_order,metadata) SELECT id,workspace_id,runner,pin_order,metadata FROM agent_sessions;
+DROP TABLE agent_sessions;
+ALTER TABLE _node_v16_agent_sessions RENAME TO agent_sessions;
+CREATE TABLE _node_v16_conversation_files (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL,
+    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;
+INSERT INTO _node_v16_conversation_files (id,conversation_id,category,relative_path,display_name,mime_type,size,source,turn_id,item_id,created_at,updated_at) SELECT id,conversation_id,category,relative_path,display_name,mime_type,size,source,turn_id,item_id,created_at,updated_at FROM conversation_files;
+DROP TABLE conversation_files;
+ALTER TABLE _node_v16_conversation_files RENAME TO conversation_files;
+CREATE INDEX conversation_files_conversation_updated
+    ON conversation_files(conversation_id, updated_at DESC, id);
+CREATE TABLE _node_v16_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,
+    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;
+INSERT INTO _node_v16_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) SELECT id,template_id,draft_revision,stage,status,version_id,error_code,error_summary,requested_by_user_id,draft,created_at,updated_at FROM conversation_template_publish_jobs;
+DROP TABLE conversation_template_publish_jobs;
+ALTER TABLE _node_v16_conversation_template_publish_jobs RENAME TO conversation_template_publish_jobs;
+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 TABLE _node_v16_hosted_conversation_messages (
+    conversation_id TEXT NOT NULL,
+    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;
+INSERT INTO _node_v16_hosted_conversation_messages (conversation_id,client_message_id,run_id,status,created_at,updated_at,user_text_present) SELECT conversation_id,client_message_id,run_id,status,created_at,updated_at,user_text_present FROM hosted_conversation_messages;
+DROP TABLE hosted_conversation_messages;
+ALTER TABLE _node_v16_hosted_conversation_messages RENAME TO hosted_conversation_messages;
+CREATE TABLE _node_v16_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,
+    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;
+INSERT INTO _node_v16_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) SELECT 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 FROM hosted_conversations;
+DROP TABLE hosted_conversations;
+ALTER TABLE _node_v16_hosted_conversations RENAME TO hosted_conversations;
+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
+    );
+CREATE TABLE _node_v16_scheduled_session_occurrences (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL,
+    due_at INTEGER NOT NULL CHECK (due_at >= 0),
+    status TEXT NOT NULL CHECK (status IN ('CLAIMED','SUBMITTED','SUCCEEDED','SKIPPED','FAILED')),
+    code TEXT,
+    run_id TEXT,
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0),
+    UNIQUE(task_id, due_at)
+  ) STRICT;
+INSERT INTO _node_v16_scheduled_session_occurrences (id,task_id,due_at,status,code,run_id,created_at,updated_at) SELECT id,task_id,due_at,status,code,run_id,created_at,updated_at FROM scheduled_session_occurrences;
+DROP TABLE scheduled_session_occurrences;
+ALTER TABLE _node_v16_scheduled_session_occurrences RENAME TO scheduled_session_occurrences;
+CREATE INDEX scheduled_session_occurrences_recent
+    ON scheduled_session_occurrences(task_id, due_at DESC);
+CREATE TABLE _node_v16_scheduled_session_proposals (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL,
+    proposed_by_user_id INTEGER NOT NULL CHECK (proposed_by_user_id > 0),
+    base_revision INTEGER NOT NULL CHECK (base_revision > 0),
+    objective TEXT CHECK (objective IS NULL OR length(objective) BETWEEN 1 AND 20000),
+    cron TEXT,
+    timezone TEXT,
+    status TEXT NOT NULL CHECK (status IN ('PENDING','ACCEPTED','REJECTED','STALE')),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    resolved_at INTEGER
+  ) STRICT;
+INSERT INTO _node_v16_scheduled_session_proposals (id,task_id,proposed_by_user_id,base_revision,objective,cron,timezone,status,created_at,resolved_at) SELECT id,task_id,proposed_by_user_id,base_revision,objective,cron,timezone,status,created_at,resolved_at FROM scheduled_session_proposals;
+DROP TABLE scheduled_session_proposals;
+ALTER TABLE _node_v16_scheduled_session_proposals RENAME TO scheduled_session_proposals;
+CREATE INDEX scheduled_session_proposals_pending
+    ON scheduled_session_proposals(task_id, status, created_at DESC);
+CREATE TABLE _node_v16_scheduled_session_tasks (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL UNIQUE,
+    workspace_id TEXT NOT NULL,
+    runner TEXT NOT NULL CHECK (runner IN ('mar-agent','codex','claude-code','opencode')),
+    owner_user_id INTEGER NOT NULL CHECK (owner_user_id > 0),
+    objective TEXT NOT NULL CHECK (length(objective) BETWEEN 1 AND 20000),
+    cron TEXT NOT NULL,
+    timezone TEXT NOT NULL,
+    enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
+    revision INTEGER NOT NULL CHECK (revision > 0),
+    next_run_at INTEGER CHECK (next_run_at IS NULL OR next_run_at >= 0),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0)
+  , notify_on_terminal INTEGER NOT NULL DEFAULT 0 CHECK (notify_on_terminal IN (0,1))) STRICT;
+INSERT INTO _node_v16_scheduled_session_tasks (id,session_id,workspace_id,runner,owner_user_id,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at,notify_on_terminal) SELECT id,session_id,workspace_id,runner,owner_user_id,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at,notify_on_terminal FROM scheduled_session_tasks;
+DROP TABLE scheduled_session_tasks;
+ALTER TABLE _node_v16_scheduled_session_tasks RENAME TO scheduled_session_tasks;
+CREATE INDEX scheduled_session_tasks_due
+    ON scheduled_session_tasks(enabled, next_run_at);
+CREATE TABLE _node_v16_terminal_sessions (
+      id TEXT PRIMARY KEY, workspace_id TEXT,
+      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;
+INSERT INTO _node_v16_terminal_sessions (id,workspace_id,profile_id,state,exit_code,rows,cols,latest_sequence,created_at,updated_at) SELECT id,workspace_id,profile_id,state,exit_code,rows,cols,latest_sequence,created_at,updated_at FROM terminal_sessions;
+DROP TABLE terminal_sessions;
+ALTER TABLE _node_v16_terminal_sessions RENAME TO terminal_sessions;`,
+    assert(database) {
+        NODE_SCHEMA_MIGRATION_V15.assert(database);
+        NODE_SCHEMA_MIGRATION_V16.preflight(database);
+        const tables = database
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+            .all();
+        if (tables.length !== currentTables.length ||
+            tables.some(({ name }) => !currentTables.some((table) => table === name)))
+            throw new Error('NODE_DATABASE_SCHEMA_INVALID:tables');
+        for (const { name } of tables) {
+            if (database.prepare(`PRAGMA foreign_key_list(${name})`).all().length !== 0)
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:foreign_keys:${name}`);
+        }
+        if (database.prepare("SELECT 1 FROM sqlite_master WHERE type='trigger' LIMIT 1").get() !==
+            undefined)
+            throw new Error('NODE_DATABASE_SCHEMA_INVALID:triggers');
+        assertNodeRelations(database);
+    }
+};

package/dist/runner/mar-agent/compact-extensions.js

@@ -1,4 +1,4 @@
-import { buildCompactEvidence, countModelTokens, generateModelText } from '@myagentroam/agent';
+import { buildCompactEvidence, countModelTokens, generateModelText, MarAgentError } from '@myagentroam/agent';
 import { marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
 /** Resolve optional dedicated credentials in the same factory batch without widening the SDK catalog. */
 export function compactRuntimeConfigurations(models, raw) {
@@ -58,6 +58,7 @@ export function marAgentCompactExtensionSource(state) {
 }
 export async function generateMarAgentCompact(context, selected, signal) {
     signal.throwIfAborted();
+    const startedAt = Date.now();
     const instruction = context.getPrompt();
     const overhead = countModelTokens(system) + countModelTokens(instruction) + 128;
     const full = buildCompactEvidence(context.messages, {
@@ -66,14 +67,39 @@ export async function generateMarAgentCompact(context, selected, signal) {
     });
     const window = selected.model.contextWindowTokens;
     const budget = Math.floor(window * 0.9) - overhead;
-    if (budget <= 0)
+    let modelRequests = 0;
+    let inputTokensEstimateAfter = overhead;
+    const report = async (state, reason, errorCode) => {
+        try {
+            await context.reportDiagnostic?.({
+                modelId: selected.model.id,
+                providerModelId: selected.model.modelId,
+                reasoningEffort: selected.reasoningEffort,
+                state,
+                inputTokensEstimateBefore: countModelTokens(full) + overhead,
+                inputTokensEstimateAfter,
+                modelRequests,
+                elapsedMs: Math.max(0, Date.now() - startedAt),
+                ...(reason === undefined ? {} : { reason }),
+                ...(errorCode === undefined ? {} : { errorCode })
+            });
+        }
+        catch {
+            // Telemetry is best effort and cannot turn a successful generation into a fallback.
+        }
+    };
+    if (budget <= 0) {
+        await report('DECLINED', 'INPUT_BUDGET_EXHAUSTED');
         return undefined;
+    }
     const evidence = countModelTokens(full) + overhead <= window
         ? full
         : buildCompactEvidence(context.messages, {
             maxTokens: budget,
             ...(context.focus === undefined ? {} : { focus: context.focus })
         });
+    inputTokensEstimateAfter = countModelTokens(evidence) + overhead;
+    await report('STARTED');
     try {
         const result = await generateModelText({
             model: selected.model,
@@ -84,14 +110,22 @@ export async function generateMarAgentCompact(context, selected, signal) {
                 { role: 'user', content: instruction }
             ],
             outputLimit: Math.min(selected.model.maxOutputTokens, context.summaryTokenBudget),
+            onAttemptDiagnostic: async (diagnostic) => {
+                if (diagnostic.state === 'STARTED') {
+                    modelRequests++;
+                    await report('STARTED');
+                }
+            },
             signal
         });
+        await report(result ? 'SUCCEEDED' : 'DECLINED', result ? undefined : 'MODEL_INCOMPLETE');
         return result
             ? { summary: result.text, ...(result.usage === undefined ? {} : { usage: result.usage }) }
             : undefined;
     }
-    catch {
+    catch (error) {
         signal.throwIfAborted();
+        await report('FAILED', 'MODEL_FAILED', error instanceof MarAgentError ? error.code : 'MAR_AGENT_COMPACT_MODEL_FAILED');
         return undefined;
     }
 }

package/dist/service/conversation-history-service.js

@@ -739,7 +739,16 @@ function sameConversationTurn(left, right) {
     if (left.id === right.id)
         return true;
     const leftMessageId = conversationClientMessageId(left);
-    return leftMessageId !== null && leftMessageId === conversationClientMessageId(right);
+    if (leftMessageId !== null)
+        return leftMessageId === conversationClientMessageId(right);
+    if (left.userItemId !== null || right.userItemId !== null)
+        return false;
+    // Item-only live Turns have no input receipt. Runtime namespaces the stable
+    // Runner Item identity by Run, so reconcile it with the unprefixed history Item.
+    const [native, local] = left.runId === null ? [left, right] : [right, left];
+    if (native.runId !== null || local.runId === null)
+        return false;
+    return native.items.some((item) => local.items.some((candidate) => candidate.kind === item.kind && candidate.id === `${local.runId}:${item.id}`));
 }
 function terminalConversationTurn(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);

package/dist/service/hosted-conversation-store.js

@@ -3,6 +3,7 @@ import { lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from
 import { tmpdir } from 'node:os';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 import { conversationFileProjectionSchema, hostedConversationManifestSchema, hostedConversationSummarySchema } from '@myagentroam/protocol';
+import { assertNodeRelations } from '../database-relations.js';
 const STORAGE_KEY = /^[A-Za-z0-9][A-Za-z0-9_-]{7,159}$/u;
 const PROTOCOL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u;
 const CURSOR_BINDING = /^[A-Za-z0-9_-]{43}$/u;
@@ -194,6 +195,12 @@ export class HostedConversationStore {
             database.exec('BEGIN IMMEDIATE');
             try {
                 this.adjustVersionReferences(versionReferences(conversation), []);
+                database
+                    .prepare('DELETE FROM conversation_files WHERE conversation_id=?')
+                    .run(conversation.id);
+                database
+                    .prepare('DELETE FROM hosted_conversation_messages WHERE conversation_id=?')
+                    .run(conversation.id);
                 const deleted = database
                     .prepare('DELETE FROM hosted_conversations WHERE id=?')
                     .run(conversation.id);
@@ -626,11 +633,13 @@ export class HostedConversationStore {
             .get(conversationId) !== undefined);
     }
     createMessage(record) {
-        this.options.database.raw
+        const result = this.options.database.raw
             .prepare(`INSERT INTO hosted_conversation_messages
          (conversation_id,client_message_id,run_id,user_text_present,status,created_at,updated_at)
-         VALUES (?,?,?,?,?,?,?)`)
-            .run(record.conversationId, record.clientMessageId, record.runId, record.userTextPresent ? 1 : 0, record.status, record.createdAt, record.updatedAt);
+         SELECT ?,?,?,?,?,?,? FROM hosted_conversations WHERE id=?`)
+            .run(record.conversationId, record.clientMessageId, record.runId, record.userTextPresent ? 1 : 0, record.status, record.createdAt, record.updatedAt, record.conversationId);
+        if (Number(result.changes) !== 1)
+            throw new Error('HOSTED_CONVERSATION_NOT_FOUND');
         return record;
     }
     finishMessage(conversationId, clientMessageId, status, updatedAt) {
@@ -1006,6 +1015,7 @@ export class HostedConversationStore {
         }
     }
     insertConversation(manifest) {
+        this.assertConversationVersion(manifest);
         this.options.database.raw
             .prepare(`INSERT INTO hosted_conversations
          (id,user_storage_key,conversation_storage_key,client_request_id,node_id,session_id,
@@ -1016,6 +1026,7 @@ export class HostedConversationStore {
             .run(manifest.id, manifest.userStorageKey, manifest.conversationStorageKey, manifest.clientRequestId ?? null, manifest.nodeId, manifest.sessionId, manifest.templateId, manifest.templateName, manifest.activeVersionId, manifest.title, manifest.titleSource, manifest.pinnedAt, manifest.status, manifest.modelId, manifest.templateDeleted ? 1 : 0, manifest.quota.usedBytes, manifest.quota.maxBytes, manifest.createdAt, manifest.updatedAt, manifest.lastActivityAt);
     }
     updateConversationRow(manifest) {
+        this.assertConversationVersion(manifest);
         const result = this.options.database.raw
             .prepare(`UPDATE hosted_conversations
          SET template_id=?,template_name=?,active_version_id=?,title=?,title_source=?,pinned_at=?,
@@ -1026,6 +1037,14 @@ export class HostedConversationStore {
         if (Number(result.changes) !== 1)
             throw new Error('HOSTED_CONVERSATION_STORAGE_INVALID');
     }
+    assertConversationVersion(manifest) {
+        if (this.options.database.raw
+            .prepare('SELECT 1 FROM conversation_template_versions WHERE id=? AND template_id=?')
+            .get(manifest.activeVersionId, manifest.templateId) === undefined)
+            throw Object.assign(new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED'), {
+                publicDetails: 'The active template version does not exist or belongs to another template.'
+            });
+    }
     adjustVersionReferences(previous, next) {
         const counts = new Map();
         for (const id of previous)
@@ -1098,6 +1117,7 @@ export class HostedConversationStore {
             const addReference = database.prepare('UPDATE conversation_template_versions SET reference_count=reference_count+1 WHERE id=?');
             for (const item of rebuilt) {
                 const manifest = item.manifest;
+                this.assertConversationVersion(manifest);
                 upsert.run(manifest.id, manifest.userStorageKey, manifest.conversationStorageKey, manifest.clientRequestId ?? null, manifest.nodeId, manifest.sessionId, manifest.templateId, manifest.templateName, manifest.activeVersionId, manifest.title, manifest.titleSource, manifest.pinnedAt, manifest.status, manifest.modelId, manifest.templateDeleted ? 1 : 0, manifest.quota.usedBytes, manifest.quota.maxBytes, manifest.createdAt, manifest.updatedAt, manifest.lastActivityAt);
                 for (const file of item.files)
                     insertConversationFile(insertFile, file);
@@ -1108,13 +1128,7 @@ export class HostedConversationStore {
                 .prepare(`UPDATE hosted_conversation_messages
            SET status='INTERRUPTED',updated_at=? WHERE status='RUNNING'`)
                 .run(Date.now());
-            for (const table of [
-                'hosted_conversations',
-                'conversation_files',
-                'hosted_conversation_messages'
-            ])
-                if (database.prepare(`PRAGMA foreign_key_check(${table})`).get() !== undefined)
-                    throw new Error('HOSTED_CONVERSATION_STORAGE_INVALID');
+            assertNodeRelations(database);
             database.exec('COMMIT');
         }
         catch (error) {

package/dist/service/scheduled-session-store.js

@@ -51,55 +51,100 @@ export class ScheduledSessionStore {
             createdAt: now,
             updatedAt: now
         };
-        this.database
-            .prepare(`INSERT INTO scheduled_session_tasks
+        return this.write(() => {
+            const session = this.database
+                .prepare('SELECT workspace_id,runner FROM agent_sessions WHERE id=?')
+                .get(task.sessionId);
+            if (session === undefined)
+                throw new Error('SESSION_NOT_FOUND');
+            if (session['workspace_id'] !== task.workspaceId || session['runner'] !== task.runner)
+                throw Object.assign(new Error('SCHEDULE_SESSION_MISMATCH'), {
+                    publicMessage: "The scheduled task must use its session's Workspace and Runner."
+                });
+            if (this.database.prepare('SELECT 1 FROM workspaces WHERE id=?').get(task.workspaceId) ===
+                undefined)
+                throw new Error('WORKSPACE_NOT_FOUND');
+            this.database
+                .prepare(`INSERT INTO scheduled_session_tasks
         (id,session_id,workspace_id,runner,owner_user_id,notify_on_terminal,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at)
         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
-            .run(task.id, task.sessionId, task.workspaceId, task.runner, task.ownerUserId, task.notifyOnTerminal ? 1 : 0, task.objective, task.cron, task.timezone, task.enabled ? 1 : 0, 1, task.nextRunAt, now, now);
-        return task;
+                .run(task.id, task.sessionId, task.workspaceId, task.runner, task.ownerUserId, task.notifyOnTerminal ? 1 : 0, task.objective, task.cron, task.timezone, task.enabled ? 1 : 0, 1, task.nextRunAt, now, now);
+            return task;
+        });
     }
     update(sessionId, expectedRevision, patch) {
-        const current = this.get(sessionId);
-        if (current === undefined)
-            throw new Error('SCHEDULE_NOT_FOUND');
-        if (current.revision !== expectedRevision)
-            throw new Error('SCHEDULE_REVISION_CONFLICT');
-        if (patch.ownerUserId !== undefined &&
-            (!Number.isSafeInteger(patch.ownerUserId) || patch.ownerUserId < 1))
-            throw new Error('SCHEDULE_OWNER_INVALID');
-        const objective = patch.objective ?? current.objective;
-        const cron = patch.cron ?? current.cron;
-        const timezone = patch.timezone ?? current.timezone;
-        validate(objective, cron, timezone);
-        const enabled = patch.enabled ?? current.enabled;
-        const ownerUserId = patch.ownerUserId ?? current.ownerUserId;
-        const nextRunAt = enabled
-            ? patch.enabled === true || patch.cron !== undefined || patch.timezone !== undefined
-                ? nextScheduledAt(cron, timezone, this.now())
-                : current.nextRunAt
-            : null;
-        const now = this.now();
-        const result = this.database
-            .prepare(`UPDATE scheduled_session_tasks SET objective=?,cron=?,timezone=?,enabled=?,owner_user_id=?,notify_on_terminal=?,revision=?,next_run_at=?,updated_at=?
+        return this.write(() => {
+            const current = this.get(sessionId);
+            if (current === undefined)
+                throw new Error('SCHEDULE_NOT_FOUND');
+            if (current.revision !== expectedRevision)
+                throw new Error('SCHEDULE_REVISION_CONFLICT');
+            if (patch.ownerUserId !== undefined &&
+                (!Number.isSafeInteger(patch.ownerUserId) || patch.ownerUserId < 1))
+                throw new Error('SCHEDULE_OWNER_INVALID');
+            const objective = patch.objective ?? current.objective;
+            const cron = patch.cron ?? current.cron;
+            const timezone = patch.timezone ?? current.timezone;
+            validate(objective, cron, timezone);
+            const enabled = patch.enabled ?? current.enabled;
+            const ownerUserId = patch.ownerUserId ?? current.ownerUserId;
+            const nextRunAt = enabled
+                ? patch.enabled === true || patch.cron !== undefined || patch.timezone !== undefined
+                    ? nextScheduledAt(cron, timezone, this.now())
+                    : current.nextRunAt
+                : null;
+            const now = this.now();
+            const result = this.database
+                .prepare(`UPDATE scheduled_session_tasks SET objective=?,cron=?,timezone=?,enabled=?,owner_user_id=?,notify_on_terminal=?,revision=?,next_run_at=?,updated_at=?
         WHERE session_id=? AND revision=?`)
-            .run(objective.trim(), cron, timezone, enabled ? 1 : 0, ownerUserId, (patch.notifyOnTerminal ?? current.notifyOnTerminal) ? 1 : 0, expectedRevision + 1, nextRunAt, now, sessionId, expectedRevision);
-        if (result.changes !== 1)
-            throw new Error('SCHEDULE_REVISION_CONFLICT');
-        this.database
-            .prepare(`UPDATE scheduled_session_proposals SET status='STALE',resolved_at=?
+                .run(objective.trim(), cron, timezone, enabled ? 1 : 0, ownerUserId, (patch.notifyOnTerminal ?? current.notifyOnTerminal) ? 1 : 0, expectedRevision + 1, nextRunAt, now, sessionId, expectedRevision);
+            if (result.changes !== 1)
+                throw new Error('SCHEDULE_REVISION_CONFLICT');
+            this.database
+                .prepare(`UPDATE scheduled_session_proposals SET status='STALE',resolved_at=?
       WHERE task_id=? AND status='PENDING' AND base_revision<?`)
-            .run(now, current.id, expectedRevision + 1);
-        this.database
-            .prepare("DELETE FROM scheduled_session_proposals WHERE task_id=? AND status='STALE'")
-            .run(current.id);
-        return this.get(sessionId);
+                .run(now, current.id, expectedRevision + 1);
+            this.database
+                .prepare("DELETE FROM scheduled_session_proposals WHERE task_id=? AND status='STALE'")
+                .run(current.id);
+            return this.get(sessionId);
+        });
     }
     remove(sessionId, expectedRevision) {
-        const result = this.database
-            .prepare('DELETE FROM scheduled_session_tasks WHERE session_id=? AND revision=?')
-            .run(sessionId, expectedRevision);
-        if (result.changes !== 1)
-            throw new Error('SCHEDULE_REVISION_CONFLICT');
+        this.write(() => {
+            const task = this.get(sessionId);
+            if (task === undefined || task.revision !== expectedRevision)
+                throw new Error('SCHEDULE_REVISION_CONFLICT');
+            this.deleteTasks('id', task.id);
+        });
+    }
+    removeForSession(sessionId) {
+        this.write(() => this.deleteTasks('session_id', sessionId));
+    }
+    removeForWorkspace(workspaceId) {
+        this.write(() => this.deleteTasks('workspace_id', workspaceId));
+    }
+    deleteTasks(column, value) {
+        for (const table of ['scheduled_session_occurrences', 'scheduled_session_proposals']) {
+            this.database
+                .prepare(`DELETE FROM ${table} WHERE task_id IN
+        (SELECT id FROM scheduled_session_tasks WHERE ${column}=?)`)
+                .run(value);
+        }
+        this.database.prepare(`DELETE FROM scheduled_session_tasks WHERE ${column}=?`).run(value);
+    }
+    write(action) {
+        // A savepoint keeps this operation atomic both alone and inside a parent deletion.
+        this.database.exec('SAVEPOINT scheduled_session_write');
+        try {
+            const result = action();
+            this.database.exec('RELEASE scheduled_session_write');
+            return result;
+        }
+        catch (error) {
+            this.database.exec('ROLLBACK TO scheduled_session_write; RELEASE scheduled_session_write');
+            throw error;
+        }
     }
     claim(sessionId, dueAt, expectedRevision) {
         const current = this.get(sessionId);
@@ -176,18 +221,25 @@ export class ScheduledSessionStore {
         if (patch.objective === undefined && patch.cron === undefined && patch.timezone === undefined)
             throw new Error('SCHEDULE_PROPOSAL_INVALID');
         validate(patch.objective ?? task.objective, patch.cron ?? task.cron, patch.timezone ?? task.timezone);
-        const pending = this.database
-            .prepare("SELECT COUNT(*) AS count FROM scheduled_session_proposals WHERE task_id=? AND status='PENDING'")
-            .get(task.id);
-        if (pending.count >= 50)
-            throw new Error('SCHEDULE_PROPOSAL_LIMIT');
-        const id = randomUUID();
-        this.database
-            .prepare(`INSERT INTO scheduled_session_proposals
+        return this.write(() => {
+            const current = this.getById(task.id);
+            if (current === undefined)
+                throw new Error('SCHEDULE_NOT_FOUND');
+            if (current.revision !== task.revision || current.ownerUserId !== task.ownerUserId)
+                throw new Error('SCHEDULE_REVISION_CONFLICT');
+            const pending = this.database
+                .prepare("SELECT COUNT(*) AS count FROM scheduled_session_proposals WHERE task_id=? AND status='PENDING'")
+                .get(task.id);
+            if (pending.count >= 50)
+                throw new Error('SCHEDULE_PROPOSAL_LIMIT');
+            const id = randomUUID();
+            this.database
+                .prepare(`INSERT INTO scheduled_session_proposals
       (id,task_id,proposed_by_user_id,base_revision,objective,cron,timezone,status,created_at)
       VALUES (?,?,?,?,?,?,?,'PENDING',?)`)
-            .run(id, task.id, actorUserId, task.revision, patch.objective ?? null, patch.cron ?? null, patch.timezone ?? null, this.now());
-        return id;
+                .run(id, task.id, actorUserId, task.revision, patch.objective ?? null, patch.cron ?? null, patch.timezone ?? null, this.now());
+            return id;
+        });
     }
     resolveProposal(sessionId, proposalId, ownerUserId, accept) {
         const task = this.get(sessionId);

package/dist/terminal.js

@@ -186,6 +186,16 @@ export class TerminalManager {
     get(terminalId) {
         return this.summary(this.requireTerminal(terminalId));
     }
+    /** A removed registration no longer owns live or historical Terminal metadata. */
+    removeWorkspaceAssociation(workspaceId) {
+        for (const terminal of this.terminals.values()) {
+            if (terminal.workspaceId !== workspaceId)
+                continue;
+            terminal.workspaceId = null;
+            terminal.updatedAt = this.now();
+            this.notifySummary(terminal);
+        }
+    }
     /** One attachment may write; active writers cannot be replaced. */
     authorizeAttach(input) {
         if (typeof input.terminalId !== 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.171",
+  "version": "0.9.173",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -36,10 +36,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.171",
+    "@myagentroam/agent": "0.9.173",
     "@myagentroam/code-navigation": "0.9.129",
     "@myagentroam/marctl": "0.9.123",
-    "@myagentroam/protocol": "0.9.171"
+    "@myagentroam/protocol": "0.9.173"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"