@promptbook/cli 0.113.0-9 → 0.114.0-0

package/apps/agents-server/src/database/createMissingAgentsFromBooks.ts

@@ -0,0 +1,77 @@
+import { parseAgentSource } from '../../../../src/book-2.0/agent-source/parseAgentSource';
+import type { string_book } from '../../../../src/book-2.0/agent-source/string_book';
+import type { AgentCollectionInSupabase } from '../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentCollectionInSupabase';
+
+/**
+ * Logger surface used while creating missing agents.
+ *
+ * @private utility of Agents Server default-agent seeding
+ */
+type CreateMissingAgentsLogger = Pick<Console, 'info'>;
+
+/**
+ * Options for creating only the missing agents from a set of bundled books.
+ *
+ * @private utility of Agents Server default-agent seeding
+ */
+export type CreateMissingAgentsFromBooksOptions = {
+    /**
+     * Agent collection bound to the target server namespace.
+     */
+    readonly collection: AgentCollectionInSupabase;
+
+    /**
+     * Bundled agent books to reinstate, in deterministic order.
+     */
+    readonly agentBooks: ReadonlyArray<string_book>;
+
+    /**
+     * Names of the agents that already exist and must not be recreated.
+     */
+    readonly existingAgentNames: ReadonlySet<string>;
+
+    /**
+     * Optional folder the created agents should be placed in (for example the `.core` folder).
+     */
+    readonly folderId?: number | null;
+
+    /**
+     * Optional logger for installer output.
+     */
+    readonly logger?: CreateMissingAgentsLogger;
+};
+
+/**
+ * Creates only the agents whose name is not already present, reusing the shared persistence mechanism.
+ *
+ * This is the single place that turns a list of bundled books into persisted agents, so both the core-agent seeder and
+ * the default-agent reinstatement share exactly the same creation logic.
+ *
+ * @param options - Collection, books, and the set of already-present agent names.
+ * @returns Names of the agents created during this run.
+ *
+ * @private utility of Agents Server default-agent seeding
+ */
+export async function createMissingAgentsFromBooks(
+    options: CreateMissingAgentsFromBooksOptions,
+): Promise<ReadonlyArray<string>> {
+    const { collection, agentBooks, existingAgentNames, folderId, logger } = options;
+    const createdAgentNames: Array<string> = [];
+
+    for (const [index, agentBook] of agentBooks.entries()) {
+        const { agentName } = parseAgentSource(agentBook);
+
+        if (existingAgentNames.has(agentName)) {
+            continue;
+        }
+
+        const createdAgent = await collection.createAgent(agentBook, {
+            folderId: folderId ?? undefined,
+            sortOrder: index,
+        });
+        createdAgentNames.push(createdAgent.agentName);
+        logger?.info(`Created agent: ${createdAgent.agentName}`);
+    }
+
+    return createdAgentNames;
+}

package/apps/agents-server/src/database/metadataDefaults.ts

@@ -47,7 +47,7 @@ import {
     SERVER_LANGUAGE_METADATA_KEY,
 } from '../languages/ServerLanguageRegistry';
 import { AGENT_VISIBILITY_OPTIONS, DEFAULT_VISIBILITY_METADATA_KEY } from '../utils/agentVisibility';
-import { CHAT_FEEDBACK_MODE_OPTIONS } from '../utils/chatFeedbackMode';
+import { CHAT_FEEDBACK_MODE_OPTIONS, DEFAULT_CHAT_FEEDBACK_MODE } from '../utils/chatFeedbackMode';
 import { SERVER_VISIBILITY_METADATA_KEY, SERVER_VISIBILITY_OPTIONS } from '../utils/serverVisibility';
 
 /**
@@ -301,7 +301,7 @@ export const metadataDefaults: ReadonlyArray<MetadataDefinition> = [
     },
     {
         key: 'CHAT_FEEDBACK_MODE',
-        value: 'stars',
+        value: DEFAULT_CHAT_FEEDBACK_MODE,
         note: `Controls post-response feedback UI mode. Allowed values: ${formatMetadataOptionValues(
             CHAT_FEEDBACK_MODE_OPTIONS,
         )}.`,

package/apps/agents-server/src/database/migrations/2026-07-1400-wallet-browser-profile-record-type.sql

@@ -0,0 +1,16 @@
+-- Allow the new `BROWSER_PROFILE` wallet record type which links one agent to its persistent
+-- browser-profile directory on the filesystem.
+--
+-- Backwards compatible: older server versions keep reading and writing the existing record types,
+-- they only cannot create `BROWSER_PROFILE` records.
+
+ALTER TABLE "prefix_Wallet"
+    DROP CONSTRAINT IF EXISTS "prefix_Wallet_recordType_check";
+
+-- The constraint kept its original name when the table was renamed from `prefix_UserWallet`
+ALTER TABLE "prefix_Wallet"
+    DROP CONSTRAINT IF EXISTS "prefix_UserWallet_recordType_check";
+
+ALTER TABLE "prefix_Wallet"
+    ADD CONSTRAINT "prefix_Wallet_recordType_check"
+    CHECK ("recordType" IN ('USERNAME_PASSWORD', 'SESSION_COOKIE', 'ACCESS_TOKEN', 'BROWSER_PROFILE'));

package/apps/agents-server/src/database/migrations/2026-07-1700-chat-history-chat-task-links.sql

@@ -0,0 +1,10 @@
+-- Link recorded chat-history messages to canonical durable chats and their chat-completion tasks
+-- Backwards compatible: only adds new nullable columns, older servers keep working unchanged
+ALTER TABLE "prefix_ChatHistory" ADD COLUMN IF NOT EXISTS "chatId" TEXT NULL;
+ALTER TABLE "prefix_ChatHistory" ADD COLUMN IF NOT EXISTS "taskId" TEXT NULL;
+
+COMMENT ON COLUMN "prefix_ChatHistory"."chatId" IS 'The id of the canonical `UserChat` this message belongs to, `NULL` for legacy stateless chats';
+COMMENT ON COLUMN "prefix_ChatHistory"."taskId" IS 'The id of the durable `UserChatJob` (chat-completion task) which produced or was queued by this message';
+
+CREATE INDEX IF NOT EXISTS "prefix_ChatHistory_chatId_idx" ON "prefix_ChatHistory" ("chatId");
+CREATE INDEX IF NOT EXISTS "prefix_ChatHistory_taskId_idx" ON "prefix_ChatHistory" ("taskId");

package/apps/agents-server/src/database/migrations/2026-07-2500-user-chat-email-source.sql

@@ -0,0 +1,13 @@
+ALTER TABLE "prefix_UserChat"
+DROP CONSTRAINT IF EXISTS "prefix_UserChat_source_check";
+
+ALTER TABLE "prefix_UserChat"
+ADD CONSTRAINT "prefix_UserChat_source_check"
+CHECK ("source" IN ('WEB_UI', 'OPENAI_API', 'TEAM_MEMBER', 'EMAIL'));
+
+ALTER TABLE "prefix_ChatHistory"
+DROP CONSTRAINT IF EXISTS "prefix_ChatHistory_source_check";
+
+ALTER TABLE "prefix_ChatHistory"
+ADD CONSTRAINT "prefix_ChatHistory_source_check"
+CHECK ("source" IN ('AGENT_PAGE_CHAT', 'OPENAI_API_COMPATIBILITY', 'EMAIL'));

package/apps/agents-server/src/database/reinstateDefaultAgents.ts

@@ -0,0 +1,111 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import { AgentCollectionInSupabase } from '../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentCollectionInSupabase';
+import type { AgentsDatabaseSchema } from '../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentsDatabaseSchema';
+import { loadDefaultAgentBooks } from '../utils/defaultAgents/loadDefaultAgentBooks';
+import { createMissingAgentsFromBooks } from './createMissingAgentsFromBooks';
+import { $provideSupabaseForServer } from './$provideSupabaseForServer';
+
+/**
+ * Environment variable with an explicit default-agent source directory.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+const DEFAULT_AGENTS_DIRECTORY_ENV_NAME = 'PTBK_DEFAULT_AGENTS_DIR';
+
+/**
+ * Environment variable carrying the current Agents Server table prefix.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+const SUPABASE_TABLE_PREFIX_ENV_NAME = 'SUPABASE_TABLE_PREFIX';
+
+/**
+ * Logger surface used by the default-agent reinstatement.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+type ReinstateDefaultAgentsLogger = Pick<Console, 'info' | 'warn'>;
+
+/**
+ * Options for reinstating any missing bundled normal default agents on the current server.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+export type ReinstateDefaultAgentsOptions = {
+    /**
+     * Optional explicit directory containing default `*.book` files.
+     */
+    readonly defaultAgentDirectory?: string | null;
+
+    /**
+     * Optional table prefix for the server namespace being reinstated.
+     */
+    readonly tablePrefix?: string | null;
+
+    /**
+     * Optional logger for installer output.
+     */
+    readonly logger?: ReinstateDefaultAgentsLogger;
+};
+
+/**
+ * Result of one default-agent reinstatement run.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+export type ReinstateDefaultAgentsResult = {
+    /**
+     * Names of the normal default agents created during this run.
+     */
+    readonly createdAgentNames: ReadonlyArray<string>;
+};
+
+/**
+ * Recreates only the normal default agents that are missing from the current server.
+ *
+ * Unlike `seedDefaultAgents` — which only seeds a brand-new empty server — this reinstatement recreates individually
+ * missing default agents while keeping every existing (possibly edited) agent untouched, so an admin can restore the
+ * showcase agents at any time. It reuses the exact same creation logic used when the server is first created.
+ *
+ * @param options - Optional reinstatement controls.
+ * @returns Reinstatement summary listing the created agents.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+export async function reinstateDefaultAgents(
+    options: ReinstateDefaultAgentsOptions = {},
+): Promise<ReinstateDefaultAgentsResult> {
+    const logger = options.logger ?? console;
+    const tablePrefix = options.tablePrefix ?? process.env[SUPABASE_TABLE_PREFIX_ENV_NAME] ?? '';
+    const defaultAgentDirectory = options.defaultAgentDirectory ?? process.env[DEFAULT_AGENTS_DIRECTORY_ENV_NAME];
+    const collection = new AgentCollectionInSupabase(resolveAgentsDatabaseSupabaseClient(), { tablePrefix });
+
+    const defaultAgentBooks = await loadDefaultAgentBooks({ defaultAgentDirectory });
+
+    if (defaultAgentBooks.length === 0) {
+        logger.warn('Skipping default agents because no bundled *.book files were found.');
+        return { createdAgentNames: [] };
+    }
+
+    const activeAgents = await collection.listAgents();
+    const existingAgentNames = new Set(activeAgents.map((activeAgent) => activeAgent.agentName));
+    const createdAgentNames = await createMissingAgentsFromBooks({
+        collection,
+        agentBooks: defaultAgentBooks,
+        existingAgentNames,
+        logger,
+    });
+
+    return { createdAgentNames };
+}
+
+/**
+ * Resolves the Supabase-shaped client for the Agent collection subset.
+ *
+ * @returns Supabase client typed for agent collection persistence.
+ *
+ * @private utility of standalone default-agent reinstatement
+ */
+function resolveAgentsDatabaseSupabaseClient(): SupabaseClient<AgentsDatabaseSchema> {
+    return $provideSupabaseForServer() as unknown as SupabaseClient<AgentsDatabaseSchema>;
+}

package/apps/agents-server/src/database/schema.ts

@@ -302,6 +302,8 @@ export type AgentsServerDatabase = {
                     actorType: 'ANONYMOUS' | 'TEAM_MEMBER' | 'API_KEY' | null;
                     usage: Json | null;
                     userId: number | null;
+                    chatId: string | null;
+                    taskId: string | null;
                 };
                 Insert: {
                     id?: number;
@@ -322,6 +324,8 @@ export type AgentsServerDatabase = {
                     actorType?: 'ANONYMOUS' | 'TEAM_MEMBER' | 'API_KEY' | null;
                     usage?: Json | null;
                     userId?: number | null;
+                    chatId?: string | null;
+                    taskId?: string | null;
                 };
                 Update: {
                     id?: number;
@@ -342,6 +346,8 @@ export type AgentsServerDatabase = {
                     actorType?: 'ANONYMOUS' | 'TEAM_MEMBER' | 'API_KEY' | null;
                     usage?: Json | null;
                     userId?: number | null;
+                    chatId?: string | null;
+                    taskId?: string | null;
                 };
                 Relationships: [
                     {
@@ -913,7 +919,7 @@ export type AgentsServerDatabase = {
                     userId: number;
                     isUserScoped: boolean;
                     agentPermanentId: string | null;
-                    recordType: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN';
+                    recordType: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN' | 'BROWSER_PROFILE';
                     service: string;
                     key: string;
                     jsonSchema: Json | null;
@@ -931,7 +937,7 @@ export type AgentsServerDatabase = {
                     userId: number;
                     isUserScoped?: boolean;
                     agentPermanentId?: string | null;
-                    recordType: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN';
+                    recordType: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN' | 'BROWSER_PROFILE';
                     service: string;
                     key?: string;
                     jsonSchema?: Json | null;
@@ -949,7 +955,7 @@ export type AgentsServerDatabase = {
                     userId?: number;
                     isUserScoped?: boolean;
                     agentPermanentId?: string | null;
-                    recordType?: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN';
+                    recordType?: 'USERNAME_PASSWORD' | 'SESSION_COOKIE' | 'ACCESS_TOKEN' | 'BROWSER_PROFILE';
                     service?: string;
                     key?: string;
                     jsonSchema?: Json | null;

package/apps/agents-server/src/database/seedCoreAgents.ts

@@ -2,10 +2,9 @@ import type { SupabaseClient } from '@supabase/supabase-js';
 import { spaceTrim } from 'spacetrim';
 import { AgentCollectionInSupabase } from '../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentCollectionInSupabase';
 import type { AgentsDatabaseSchema } from '../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentsDatabaseSchema';
-import { parseAgentSource } from '../../../../src/book-2.0/agent-source/parseAgentSource';
-import type { string_book } from '../../../../src/book-2.0/agent-source/string_book';
 import { DatabaseError } from '../../../../src/errors/DatabaseError';
 import { CORE_AGENT_DIRECTORY_NAME, loadCoreAgentBooks } from '../utils/defaultAgents/loadDefaultAgentBooks';
+import { createMissingAgentsFromBooks } from './createMissingAgentsFromBooks';
 import { $provideSupabaseForServer } from './$provideSupabaseForServer';
 
 /**
@@ -87,38 +86,17 @@ export async function seedCoreAgents(options: SeedCoreAgentsOptions = {}): Promi
 
     const coreFolderId = await ensureCoreFolderExists(tablePrefix);
     const existingAgentNames = await loadExistingActiveAgentNames(tablePrefix);
-    const createdAgentNames: Array<string> = [];
-
-    for (const [index, coreAgentBook] of coreAgentBooks.entries()) {
-        const agentName = parseCoreAgentName(coreAgentBook);
-
-        if (existingAgentNames.has(agentName)) {
-            continue;
-        }
-
-        const createdAgent = await collection.createAgent(coreAgentBook, {
-            folderId: coreFolderId,
-            sortOrder: index,
-        });
-        createdAgentNames.push(createdAgent.agentName);
-        logger.info(`Created \`.core\` agent: ${createdAgent.agentName}`);
-    }
+    const createdAgentNames = await createMissingAgentsFromBooks({
+        collection,
+        agentBooks: coreAgentBooks,
+        existingAgentNames,
+        folderId: coreFolderId,
+        logger,
+    });
 
     return { coreFolderId, createdAgentNames };
 }
 
-/**
- * Reads the agent name from one bundled `.core` book source.
- *
- * @param coreAgentBook - Raw `.core` agent book source.
- * @returns Persisted agent name parsed from the book.
- *
- * @private utility of `.core` folder seeding
- */
-function parseCoreAgentName(coreAgentBook: string_book): string {
-    return parseAgentSource(coreAgentBook).agentName;
-}
-
 /**
  * Reads the set of active agent names already persisted on the current server.
  *

package/apps/agents-server/src/database/sqlite/$provideAgentsServerSqliteDatabase.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { resolveAgentsServerSqliteDatabasePath } from './resolveAgentsServerSqliteDatabasePath';
+import { resolveServerSqliteDatabasePath } from './resolveServerSqliteDatabasePath';
 
 /**
  * Shape of the `better-sqlite3` module constructor loaded at runtime.
@@ -40,44 +41,75 @@ export type AgentsServerSqliteStatement = {
 };
 
 /**
- * Cached SQLite database connection.
+ * Cached SQLite database connections keyed by absolute database file path.
  */
-let agentsServerSqliteDatabase: AgentsServerSqliteDatabase | null = null;
+const sqliteDatabaseByPath = new Map<string, AgentsServerSqliteDatabase>();
 
 /**
- * Opens and initializes the shared local SQLite database.
+ * Opens and initializes one SQLite database file, caching the connection per path.
  *
- * @returns Shared SQLite database connection.
+ * @param databasePath - Absolute path of the SQLite database file.
+ * @returns Cached SQLite database connection.
  *
  * @private exported from Agents Server SQLite utilities
  */
-export function $provideAgentsServerSqliteDatabase(): AgentsServerSqliteDatabase {
-    if (agentsServerSqliteDatabase) {
-        return agentsServerSqliteDatabase;
+export function $provideSqliteDatabaseAtPath(databasePath: string): AgentsServerSqliteDatabase {
+    const cachedDatabase = sqliteDatabaseByPath.get(databasePath);
+    if (cachedDatabase) {
+        return cachedDatabase;
     }
 
-    const databasePath = resolveAgentsServerSqliteDatabasePath();
     const databaseDirectory = dirname(databasePath);
-
     if (!existsSync(databaseDirectory)) {
         mkdirSync(databaseDirectory, { recursive: true });
     }
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const BetterSqlite = require('better-sqlite3') as BetterSqliteConstructor;
-    agentsServerSqliteDatabase = new BetterSqlite(databasePath);
-    agentsServerSqliteDatabase.pragma('journal_mode = WAL');
-    agentsServerSqliteDatabase.pragma('foreign_keys = ON');
+    const database = new BetterSqlite(databasePath);
+    database.pragma('journal_mode = WAL');
+    database.pragma('foreign_keys = ON');
 
-    return agentsServerSqliteDatabase;
+    sqliteDatabaseByPath.set(databasePath, database);
+    return database;
 }
 
 /**
- * Closes the cached SQLite connection and resets adapter state for isolated tests.
+ * Opens the VPS-wide SQLite registry database.
+ *
+ * This database is owned by the super-admin and holds only VPS-level data,
+ * most importantly the `_Server` table listing all servers running on this VPS.
+ * Server-scoped data (agents, projects, metadata, users, ...) lives in isolated
+ * per-server databases provided by `$provideServerSqliteDatabase`.
+ *
+ * @returns Shared VPS registry SQLite database connection.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $provideVpsRegistrySqliteDatabase(): AgentsServerSqliteDatabase {
+    return $provideSqliteDatabaseAtPath(resolveAgentsServerSqliteDatabasePath());
+}
+
+/**
+ * Opens the isolated SQLite database of one server namespace.
+ *
+ * @param tablePrefix - Stable server namespace key, or an empty string for the default server.
+ * @returns Per-server SQLite database connection.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export function $provideServerSqliteDatabase(tablePrefix: string): AgentsServerSqliteDatabase {
+    return $provideSqliteDatabaseAtPath(resolveServerSqliteDatabasePath(tablePrefix));
+}
+
+/**
+ * Closes all cached SQLite connections and resets adapter state for isolated tests.
  *
  * @private exported from Agents Server SQLite utilities
  */
 export function $resetAgentsServerSqliteDatabaseForTests(): void {
-    agentsServerSqliteDatabase?.close?.();
-    agentsServerSqliteDatabase = null;
+    for (const database of sqliteDatabaseByPath.values()) {
+        database.close?.();
+    }
+    sqliteDatabaseByPath.clear();
 }

package/apps/agents-server/src/database/sqlite/$provideCurrentServerSqliteDatabase.ts

@@ -0,0 +1,18 @@
+import { $provideServer } from '../../tools/$provideServer';
+import type { AgentsServerSqliteDatabase } from './$provideAgentsServerSqliteDatabase';
+import { resolveServerSqliteDatabaseForTablePrefix } from './resolveLocalSqliteTableLocation';
+
+/**
+ * Opens the isolated SQLite database of the server handling the current request.
+ *
+ * Used by raw-SQL features (for example the embedded database admin) so every
+ * server administrator only ever sees the data of their own server.
+ *
+ * @returns Isolated SQLite database of the current server.
+ *
+ * @private exported from Agents Server SQLite utilities
+ */
+export async function $provideCurrentServerSqliteDatabase(): Promise<AgentsServerSqliteDatabase> {
+    const { tablePrefix } = await $provideServer();
+    return resolveServerSqliteDatabaseForTablePrefix(tablePrefix);
+}

package/apps/agents-server/src/database/sqlite/$provideLocalSqliteSupabase.ts

@@ -1,11 +1,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-import {
-    $provideAgentsServerSqliteDatabase,
-    $resetAgentsServerSqliteDatabaseForTests,
-} from './$provideAgentsServerSqliteDatabase';
+import { $resetAgentsServerSqliteDatabaseForTests } from './$provideAgentsServerSqliteDatabase';
 import { ensureTable } from './localSqliteSupabase/ensureTable';
 import { resolveReadIndexColumns, resolveTableBaseName } from './localSqliteSupabase/localSqliteTableSchema';
 import { LocalSqliteSupabaseClient } from './localSqliteSupabase/LocalSqliteSupabaseClient';
+import { resolveLocalSqliteTableLocation } from './resolveLocalSqliteTableLocation';
+import { invalidateStandaloneServerRegistryCache } from './standaloneServerRegistryStore';
 
 /**
  * Cached Supabase-shaped local client.
@@ -13,37 +12,40 @@ import { LocalSqliteSupabaseClient } from './localSqliteSupabase/LocalSqliteSupa
 let localSqliteSupabase: SupabaseClient | null = null;
 
 /**
- * Provides a Supabase-shaped client backed by a local SQLite database.
+ * Provides a Supabase-shaped client backed by isolated local SQLite databases.
+ *
+ * Table names are routed per query: VPS-level tables go to the VPS registry
+ * database while server-prefixed tables go to the isolated database file of
+ * the owning server, so servers cannot leak data into each other.
  */
 export function $provideLocalSqliteSupabase(): SupabaseClient {
     if (localSqliteSupabase) {
         return localSqliteSupabase;
     }
 
-    localSqliteSupabase = new LocalSqliteSupabaseClient(
-        $provideAgentsServerSqliteDatabase(),
-    ) as unknown as SupabaseClient;
+    localSqliteSupabase = new LocalSqliteSupabaseClient(resolveLocalSqliteTableLocation) as unknown as SupabaseClient;
     return localSqliteSupabase;
 }
 
 /**
- * Closes the cached SQLite connection and resets adapter state for isolated tests.
+ * Closes all cached SQLite connections and resets adapter state for isolated tests.
  */
 export function $resetLocalSqliteSupabaseForTests(): void {
     $resetAgentsServerSqliteDatabaseForTests();
+    invalidateStandaloneServerRegistryCache();
     localSqliteSupabase = null;
 }
 
 /**
  * Ensures read indexes for a table that is queried through direct SQLite SQL.
  *
- * @param tableName - Actual table name, including any server prefix.
+ * @param tableName - Logical table name, including any server prefix.
  *
  * @private internal SQLite utility of Agents Server
  */
 export function ensureLocalSqliteTableReadIndexes(tableName: string): void {
-    const database = $provideAgentsServerSqliteDatabase();
-    const tableBaseName = resolveTableBaseName(tableName);
+    const { database, localTableName } = resolveLocalSqliteTableLocation(tableName);
+    const tableBaseName = resolveTableBaseName(localTableName);
 
-    ensureTable(database, tableName, resolveReadIndexColumns(tableBaseName));
+    ensureTable(database, localTableName, resolveReadIndexColumns(tableBaseName));
 }

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/LocalSqliteSupabaseClient.ts

@@ -1,21 +1,33 @@
 import type { TODO_any } from '@promptbook-local/types';
 import type { AgentsServerSqliteDatabase } from '../$provideAgentsServerSqliteDatabase';
+import type { LocalSqliteTableLocation } from '../resolveLocalSqliteTableLocation';
 import type { LocalSqliteSelectOptions, LocalSqliteUpsertOptions } from './localSqliteTypes';
 import { LocalSqliteQueryBuilder } from './LocalSqliteQueryBuilder';
 
+/**
+ * Resolver routing one logical table name to its isolated SQLite database.
+ *
+ * @private type of `LocalSqliteSupabaseClient`
+ */
+export type LocalSqliteTableLocationResolver = (tableName: string) => LocalSqliteTableLocation;
+
 /**
  * Supabase-shaped client with only the table query surface used by Agents Server.
  *
+ * Every table access is routed through the location resolver, so each server
+ * namespace transparently works with its own isolated SQLite database file.
+ *
  * @private class of `$provideLocalSqliteSupabase`
  */
 export class LocalSqliteSupabaseClient {
-    public constructor(private readonly database: AgentsServerSqliteDatabase) {}
+    public constructor(private readonly resolveTableLocation: LocalSqliteTableLocationResolver) {}
 
     /**
-     * Starts a query for one SQLite table.
+     * Starts a query for one logical SQLite table.
      */
     public from(tableName: string): LocalSqliteTable {
-        return new LocalSqliteTable(this.database, tableName);
+        const { database, localTableName } = this.resolveTableLocation(tableName);
+        return new LocalSqliteTable(database, localTableName);
     }
 }
 

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteTableSchema.ts

@@ -51,7 +51,10 @@ const TEXT_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([['Metadata',
  *
  * @private constant of `$provideLocalSqliteSupabase`
  */
-const INTEGER_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([['ServerLimit', new Set(['value'])]]);
+const INTEGER_COLUMNS_BY_TABLE = new Map<string, ReadonlySet<string>>([
+    ['File', new Set(['fileSize'])],
+    ['ServerLimit', new Set(['value'])],
+]);
 
 /**
  * Boolean columns stored as integers by SQLite and restored as booleans.
@@ -79,7 +82,7 @@ const TEXT_PRIMARY_KEY_TABLES = new Set([
  * @private constant of `$provideLocalSqliteSupabase`
  */
 const UNIQUE_INDEX_COLUMNS_BY_TABLE = new Map<string, ReadonlyArray<ReadonlyArray<string>>>([
-    ['_Server', [['name'], ['domain']]],
+    ['_Server', [['name'], ['domain'], ['tablePrefix']]],
     ['Metadata', [['key']]],
     ['ServerLimit', [['key']]],
     ['Agent', [['permanentId']]],