iranti 0.2.19 → 0.2.21

package/README.md

@@ -9,10 +9,10 @@
 
 Iranti gives agents persistent, identity-based memory. Facts written by one agent are retrievable by any other agent through exact entity+key lookup. Iranti also supports hybrid search (lexical + vector) when exact keys are unknown. Memory persists across sessions and survives context window limits.
 
-**Latest release:** [`v0.2.19`](https://github.com/nfemmanuel/iranti/releases/tag/v0.2.19)  
+**Latest release:** [`v0.2.20`](https://github.com/nfemmanuel/iranti/releases/tag/v0.2.20)  
 Published packages:
-- `iranti@0.2.19`
-- `@iranti/sdk@0.2.19`
+- `iranti@0.2.20`
+- `@iranti/sdk@0.2.20`
 
 ---
 
@@ -173,7 +173,7 @@ The next leverage is still product simplicity: setup, operations, and day-to-day
 
 ## Quickstart
 
-**Requirements**: Node.js 18+, PostgreSQL, Python 3.8+
+**Requirements**: Node.js 18+, PostgreSQL with pgvector support, Python 3.8+
 
 Docker is optional. It is one local way to run PostgreSQL if you do not already have a database. Iranti still requires PostgreSQL; the setup improvement is smarter bootstrap and clearer guidance, not a second storage backend.
 
@@ -190,7 +190,7 @@ iranti run --instance local
 
 `iranti setup` now defaults to an isolated per-project runtime. Shared machine-level instances are still supported, but they are now an explicit choice rather than the default.
 
-If local PostgreSQL is available, setup can bootstrap a localhost database for you. If local PostgreSQL is not available, setup recommends Docker when Docker is installed, and otherwise steers you to managed PostgreSQL with concrete install guidance.
+If local PostgreSQL is available and pgvector-capable, setup can bootstrap a localhost database for you. If Docker is available, setup now prefers the Docker path over a plain local listener because it guarantees pgvector. If local PostgreSQL is reachable but does not provide pgvector, setup now fails early with a direct action path instead of a late Prisma migration error.
 
 Long-running agents can now checkpoint and recover interrupted work. Programmatic session lifecycle methods are available through the SDK and REST API:
 - `checkpoint()`

package/dist/scripts/iranti-cli.js

@@ -221,6 +221,17 @@ function builtScriptPath(scriptName) {
 }
 function formatSetupBootstrapFailure(error) {
     const reason = error instanceof Error ? error.message : String(error);
+    if (/Could not find Prisma Schema/i.test(reason)) {
+        return new Error(`Database bootstrap failed because Prisma could not locate prisma/schema.prisma from the active package. ` +
+            `This usually means the installed CLI bundle or working-directory handoff is wrong. ` +
+            `Underlying error: ${reason}`);
+    }
+    if (/extension "vector" is not available|pgvector extension is not installed|does not have the pgvector extension installed/i.test(reason)) {
+        return new Error(`Database bootstrap failed because the target PostgreSQL server does not provide pgvector. ` +
+            `Iranti currently requires pgvector-capable PostgreSQL for schema bootstrap. ` +
+            `Install pgvector on that server, or rerun setup with --db-mode docker or a managed pgvector-capable database. ` +
+            `Underlying error: ${reason}`);
+    }
     return new Error(`Database bootstrap failed after instance configuration. ` +
         `Common causes are a non-empty database that Prisma has not baselined yet, or a PostgreSQL server without the pgvector extension installed. ` +
         `Re-run setup without --bootstrap-db, or point Iranti at a fresh pgvector-capable database. ` +
@@ -761,29 +772,31 @@ function inferProjectMode(projectPath, instanceEnvFile) {
 }
 function recommendDatabaseMode(checks) {
     const reachableLocal = checks.find((check) => check.name === 'localhost:5432')?.status === 'pass';
-    const docker = checks.find((check) => check.name === 'docker')?.status === 'pass';
-    if (reachableLocal)
+    const docker = checks.find((check) => check.name === 'docker daemon')?.status === 'pass';
+    if (reachableLocal && !docker)
         return 'local';
     if (docker)
         return 'docker';
+    if (reachableLocal)
+        return 'local';
     return 'managed';
 }
 function quickInstallGuidanceLines() {
     if (process.platform === 'win32') {
         return [
             'Docker: winget install Docker.DockerDesktop',
-            'PostgreSQL: winget install PostgreSQL.PostgreSQL.17',
+            'PostgreSQL: install PostgreSQL 17 and a pgvector-capable build or extension package.',
         ];
     }
     if (process.platform === 'darwin') {
         return [
             'Docker: brew install --cask docker',
-            'PostgreSQL: brew install postgresql@17',
+            'PostgreSQL: brew install postgresql@17 plus pgvector for that server.',
         ];
     }
     return [
         'Docker: install Docker Engine using your distro package manager or the official Docker instructions.',
-        'PostgreSQL: install PostgreSQL 16+ using your distro package manager.',
+        'PostgreSQL: install PostgreSQL 16+ and the pgvector extension using your distro package manager.',
     ];
 }
 function printQuickInstallGuidance() {
@@ -1181,6 +1194,32 @@ function hasDockerInstalled() {
         return false;
     }
 }
+function inspectDockerAvailability() {
+    if (!hasDockerInstalled()) {
+        return {
+            installed: false,
+            daemonReachable: false,
+            detail: 'Docker is not installed or not on PATH.',
+        };
+    }
+    const proc = runCommandCapture('docker', ['info', '--format', '{{.ServerVersion}}']);
+    if (proc.status === 0) {
+        const version = proc.stdout.trim();
+        return {
+            installed: true,
+            daemonReachable: true,
+            detail: version
+                ? `Docker daemon is reachable (server ${version}).`
+                : 'Docker daemon is reachable.',
+        };
+    }
+    const reason = (proc.stderr || proc.stdout).trim() || 'Docker daemon did not respond.';
+    return {
+        installed: true,
+        daemonReachable: false,
+        detail: `Docker CLI is installed, but the daemon is not reachable. ${reason}`,
+    };
+}
 async function isPortAvailable(port, host = '127.0.0.1') {
     return await new Promise((resolve) => {
         const server = net_1.default.createServer();
@@ -1244,9 +1283,19 @@ async function waitForTcpPort(host, port, timeoutMs) {
     throw new Error(`Timed out waiting for ${host}:${port} to accept TCP connections.`);
 }
 async function runDockerPostgresContainer(options) {
+    const docker = inspectDockerAvailability();
+    if (!docker.installed) {
+        throw new Error('Docker CLI is not installed or not on PATH. Install Docker Desktop or Docker Engine before using --db-mode docker.');
+    }
+    if (!docker.daemonReachable) {
+        throw new Error(`Docker daemon is not reachable. Start Docker Desktop or Docker Engine, then retry. ${docker.detail}`);
+    }
     const inspect = process.platform === 'win32'
         ? (0, child_process_1.spawnSync)(process.env.ComSpec ?? 'cmd.exe', ['/d', '/c', `docker ps -a --format "{{.Names}}"`], { encoding: 'utf8' })
         : (0, child_process_1.spawnSync)('docker', ['ps', '-a', '--format', '{{.Names}}'], { encoding: 'utf8' });
+    if (inspect.status !== 0) {
+        throw new Error(`Failed to inspect Docker containers. ${(inspect.stderr ?? inspect.stdout ?? '').trim() || 'docker ps returned a non-zero exit code.'}`);
+    }
     const names = (inspect.stdout ?? '').split(/\r?\n/).map((value) => value.trim()).filter(Boolean);
     if (names.includes(options.containerName)) {
         const start = process.platform === 'win32'
@@ -1295,10 +1344,12 @@ async function executeSetupPlan(plan) {
     });
     if (plan.bootstrapDatabase) {
         try {
-            if (plan.databaseMode === 'docker') {
+            if (plan.databaseMode === 'docker' && !plan.databaseProvisioned) {
                 const parsed = parsePostgresConnectionString(plan.databaseUrl);
                 await runDockerPostgresContainer({
-                    containerName: sanitizeIdentifier(`iranti_${plan.instanceName}_db`, `iranti_${plan.instanceName}_db`),
+                    containerName: plan.dockerContainerName
+                        ? sanitizeIdentifier(plan.dockerContainerName, `iranti_${plan.instanceName}_db`)
+                        : sanitizeIdentifier(`iranti_${plan.instanceName}_db`, `iranti_${plan.instanceName}_db`),
                     hostPort: Number.parseInt(parsed.port || '5432', 10),
                     password: decodeURIComponent(parsed.password || 'postgres'),
                     database: postgresDatabaseName(plan.databaseUrl),
@@ -1306,6 +1357,7 @@ async function executeSetupPlan(plan) {
             }
             if (plan.databaseMode === 'local') {
                 await ensurePostgresDatabaseExists(plan.databaseUrl);
+                await ensureLocalPostgresPgvectorAvailable(plan.databaseUrl);
             }
             await runBundledScript('setup', [], {
                 DATABASE_URL: plan.databaseUrl,
@@ -1313,6 +1365,9 @@ async function executeSetupPlan(plan) {
             });
         }
         catch (error) {
+            if (plan.databaseMode === 'docker' && error instanceof Error && /Docker daemon is not reachable|Docker CLI is not installed/i.test(error.message)) {
+                throw error;
+            }
             throw formatSetupBootstrapFailure(error);
         }
     }
@@ -1437,7 +1492,7 @@ function defaultsSetupPlan(args) {
         if (!explicit) {
             if (hasCommandInstalled('psql'))
                 return 'local';
-            if (hasDockerInstalled())
+            if (inspectDockerAvailability().daemonReachable)
                 return 'docker';
             return 'managed';
         }
@@ -1699,15 +1754,20 @@ async function canConnectTcp(port, host = '127.0.0.1', timeoutMs = 800) {
     });
 }
 async function collectDependencyChecks() {
-    const docker = hasDockerInstalled();
+    const docker = inspectDockerAvailability();
     const psql = hasCommandInstalled('psql');
     const pgIsReady = hasCommandInstalled('pg_isready');
     const postgresPort = await canConnectTcp(5432);
     const checks = [
         {
             name: 'docker',
-            status: docker ? 'pass' : 'warn',
-            detail: docker ? 'Docker is installed.' : 'Docker is not installed or not on PATH.',
+            status: docker.installed ? 'pass' : 'warn',
+            detail: docker.installed ? 'Docker CLI is installed.' : docker.detail,
+        },
+        {
+            name: 'docker daemon',
+            status: docker.daemonReachable ? 'pass' : 'warn',
+            detail: docker.detail,
         },
         {
             name: 'psql',
@@ -1942,6 +2002,46 @@ async function ensurePostgresDatabaseExists(databaseUrl) {
         throw new Error(`Failed to create local PostgreSQL database '${databaseName}'. ${create.stderr?.trim() || create.stdout?.trim() || 'psql returned a non-zero exit code.'}`);
     }
 }
+async function ensureLocalPostgresPgvectorAvailable(databaseUrl) {
+    const parsed = parsePostgresConnectionString(databaseUrl);
+    if (!isLocalPostgresHost(parsed.hostname)) {
+        return;
+    }
+    if (!hasCommandInstalled('psql')) {
+        return;
+    }
+    const adminDatabase = parsed.searchParams.get('admin_db')?.trim() || 'postgres';
+    const host = parsed.hostname;
+    const port = parsed.port || '5432';
+    const user = decodeURIComponent(parsed.username || 'postgres');
+    const password = decodeURIComponent(parsed.password || '');
+    const extraEnv = password ? { PGPASSWORD: password } : undefined;
+    const probe = (0, child_process_1.spawnSync)('psql', [
+        '-h',
+        host,
+        '-p',
+        port,
+        '-U',
+        user,
+        '-d',
+        adminDatabase,
+        '-tAc',
+        "SELECT 1 FROM pg_available_extensions WHERE name = 'vector';",
+    ], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            ...extraEnv,
+        },
+    });
+    if (probe.status !== 0) {
+        throw new Error(`Failed to inspect local PostgreSQL for pgvector availability. ${probe.stderr?.trim() || probe.stdout?.trim() || 'psql returned a non-zero exit code.'}`);
+    }
+    if ((probe.stdout ?? '').trim() !== '1') {
+        throw new Error('Local PostgreSQL server does not have the pgvector extension installed.');
+    }
+}
 function detectPythonLauncher() {
     const candidates = process.platform === 'win32'
         ? [
@@ -2270,6 +2370,32 @@ function canScheduleWindowsGlobalNpmSelfUpgrade(context) {
 function escapeForSingleQuotedPowerShell(value) {
     return value.replace(/'/g, "''");
 }
+function resolveWindowsDetachedExecutable(executable) {
+    if (path_1.default.isAbsolute(executable)) {
+        return executable;
+    }
+    const candidates = executable.toLowerCase().endsWith('.cmd') || executable.toLowerCase().endsWith('.exe')
+        ? [executable]
+        : [`${executable}.cmd`, `${executable}.exe`, executable];
+    for (const candidate of candidates) {
+        const probe = (0, child_process_1.spawnSync)('where', [candidate], { encoding: 'utf8' });
+        if (probe.status === 0) {
+            const resolved = (probe.stdout ?? '').split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+            if (resolved) {
+                if (!path_1.default.extname(resolved)) {
+                    const cmdVariant = `${resolved}.cmd`;
+                    const exeVariant = `${resolved}.exe`;
+                    if (fs_1.default.existsSync(cmdVariant))
+                        return cmdVariant;
+                    if (fs_1.default.existsSync(exeVariant))
+                        return exeVariant;
+                }
+                return resolved;
+            }
+        }
+    }
+    return executable;
+}
 function resolveDetachedUpgradeCwd(command) {
     const desired = command.cwd?.trim();
     if (!desired) {
@@ -2283,12 +2409,30 @@ function resolveDetachedUpgradeCwd(command) {
     }
     return normalized;
 }
+function launchDetachedWindowsPowerShellFile(scriptPath, cwd) {
+    const command = [
+        'Start-Process',
+        '-WindowStyle Hidden',
+        `-WorkingDirectory '${escapeForSingleQuotedPowerShell(cwd)}'`,
+        "-FilePath 'powershell.exe'",
+        `-ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-File','${escapeForSingleQuotedPowerShell(scriptPath)}')`,
+    ].join(' ');
+    const proc = (0, child_process_1.spawnSync)('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command], {
+        encoding: 'utf8',
+        cwd,
+        env: process.env,
+        windowsHide: true,
+    });
+    if (proc.status !== 0) {
+        throw new Error(`Failed to schedule detached PowerShell handoff. ${(proc.stderr || proc.stdout).trim() || 'powershell returned a non-zero exit code.'}`);
+    }
+}
 function scheduleDetachedWindowsGlobalNpmUpgrade(command, postCommand) {
     const neutralCwd = resolveDetachedUpgradeCwd(command);
     const parentPid = process.pid;
-    const powershell = 'powershell.exe';
     const escapedCwd = escapeForSingleQuotedPowerShell(neutralCwd);
-    const escapedExecutable = escapeForSingleQuotedPowerShell(command.executable);
+    const detachedExecutable = resolveWindowsDetachedExecutable(command.executable);
+    const escapedExecutable = escapeForSingleQuotedPowerShell(detachedExecutable);
     const escapedArgs = command.args.map((arg) => `'${escapeForSingleQuotedPowerShell(arg)}'`).join(', ');
     const script = [
         `$parentPid = ${parentPid}`,
@@ -2297,15 +2441,9 @@ function scheduleDetachedWindowsGlobalNpmUpgrade(command, postCommand) {
         `& '${escapedExecutable}' @(${escapedArgs})`,
         ...(postCommand ? [`if ($LASTEXITCODE -eq 0) { ${postCommand} }`] : []),
         'exit $LASTEXITCODE',
-    ].join('; ');
-    const child = (0, child_process_1.spawn)(powershell, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script], {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-        cwd: neutralCwd,
-        env: process.env,
-    });
-    child.unref();
+    ].join(';\r\n');
+    const scriptPath = writeDetachedWindowsScript('iranti-upgrade', `${script};\r\n`);
+    launchDetachedWindowsPowerShellFile(scriptPath, neutralCwd);
 }
 function verifyPythonInstall(command) {
     const version = detectPythonInstalledVersion(command);
@@ -2684,6 +2822,7 @@ async function stopUninstallProcesses(processes) {
 }
 function buildDetachedWindowsUninstallScript(options) {
     const lines = [
+        "$ErrorActionPreference = 'SilentlyContinue'",
         `$parentPid = ${options.parentPid}`,
         'while (Get-Process -Id $parentPid -ErrorAction SilentlyContinue) { Start-Sleep -Milliseconds 500 }',
     ];
@@ -2691,15 +2830,20 @@ function buildDetachedWindowsUninstallScript(options) {
         lines.push(`taskkill /PID ${pid} /T /F > $null 2>&1`);
     }
     if (options.removeCodex) {
-        lines.push("$codexGet = Get-Command codex -ErrorAction SilentlyContinue");
-        lines.push("if ($codexGet) { codex mcp get iranti --json > $null 2>&1; if ($LASTEXITCODE -eq 0) { codex mcp remove iranti > $null 2>&1 } }");
+        const codexExecutable = escapeForSingleQuotedPowerShell(options.codexExecutable ?? resolveWindowsDetachedExecutable('codex'));
+        lines.push(`$codexExe = '${codexExecutable}'`);
+        lines.push("if (Test-Path -LiteralPath $codexExe) { & $codexExe mcp get iranti --json > $null 2>&1; if ($LASTEXITCODE -eq 0) { & $codexExe mcp remove iranti > $null 2>&1 } }");
     }
     if (options.removeGlobalNpm) {
-        lines.push('& npm uninstall -g iranti');
+        const npmExecutable = escapeForSingleQuotedPowerShell(options.npmExecutable ?? resolveWindowsDetachedExecutable('npm'));
+        lines.push(`$npmExe = '${npmExecutable}'`);
+        lines.push("if (Test-Path -LiteralPath $npmExe) { & $npmExe uninstall -g iranti > $null 2>&1 }");
     }
     if (options.python) {
         const args = options.python.args.map((arg) => `'${escapeForSingleQuotedPowerShell(arg)}'`).join(', ');
-        lines.push(`& '${escapeForSingleQuotedPowerShell(options.python.executable)}' @(${args})`);
+        const pythonExecutable = escapeForSingleQuotedPowerShell(resolveWindowsDetachedExecutable(options.python.executable));
+        lines.push(`$pythonExe = '${pythonExecutable}'`);
+        lines.push(`if (Test-Path -LiteralPath $pythonExe) { & $pythonExe @(${args}) > $null 2>&1 }`);
     }
     for (const filePath of options.artifactFiles) {
         lines.push(`if (Test-Path -LiteralPath '${escapeForSingleQuotedPowerShell(filePath)}') { Remove-Item -LiteralPath '${escapeForSingleQuotedPowerShell(filePath)}' -Force }`);
@@ -2708,7 +2852,13 @@ function buildDetachedWindowsUninstallScript(options) {
         lines.push(`if (Test-Path -LiteralPath '${escapeForSingleQuotedPowerShell(dirPath)}') { Remove-Item -LiteralPath '${escapeForSingleQuotedPowerShell(dirPath)}' -Recurse -Force }`);
     }
     lines.push('exit 0');
-    return lines.join('; ');
+    return `${lines.join(';\r\n')};\r\n`;
+}
+function writeDetachedWindowsScript(prefix, scriptContents) {
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `${prefix}-`));
+    const scriptPath = path_1.default.join(tempDir, `${prefix}.ps1`);
+    fs_1.default.writeFileSync(scriptPath, scriptContents, 'utf8');
+    return scriptPath;
 }
 async function uninstallCommand(args) {
     const scope = normalizeScope(getFlag(args, 'scope'));
@@ -2786,17 +2936,13 @@ async function uninstallCommand(args) {
                 removeCodex: actions.removeCodexRegistration,
                 python: actions.removePython ? pythonCommand : null,
                 removeGlobalNpm: actions.removeGlobalNpm,
+                npmExecutable: resolveWindowsDetachedExecutable('npm'),
+                codexExecutable: resolveWindowsDetachedExecutable('codex'),
                 runtimeRoots: actions.removeRuntimeRoots ? runtimeRoots.map((entry) => entry.path) : [],
                 artifactFiles,
             });
-            const child = (0, child_process_1.spawn)('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script], {
-                detached: true,
-                stdio: 'ignore',
-                windowsHide: true,
-                cwd: os_1.default.homedir(),
-                env: process.env,
-            });
-            child.unref();
+            const scriptPath = writeDetachedWindowsScript('iranti-uninstall', script);
+            launchDetachedWindowsPowerShellFile(scriptPath, os_1.default.homedir());
             execution.push({
                 label: 'detached-uninstall',
                 status: 'warn',
@@ -3130,7 +3276,7 @@ async function setupCommand(args) {
     const dependencyChecks = await collectDependencyChecks();
     printDependencyChecks(dependencyChecks);
     const recommendedDatabaseMode = recommendDatabaseMode(dependencyChecks);
-    console.log(`${infoLabel()} Recommended database path: ${recommendedDatabaseMode === 'local' ? 'local PostgreSQL' : recommendedDatabaseMode === 'docker' ? 'Docker-hosted PostgreSQL' : 'managed PostgreSQL'}`);
+    console.log(`${infoLabel()} Recommended database path: ${recommendedDatabaseMode === 'local' ? 'local PostgreSQL (pgvector required)' : recommendedDatabaseMode === 'docker' ? 'Docker-hosted PostgreSQL' : 'managed PostgreSQL'}`);
     if (recommendedDatabaseMode === 'managed' && dependencyChecks.every((check) => check.status === 'warn')) {
         printQuickInstallGuidance();
     }
@@ -3177,10 +3323,13 @@ async function setupCommand(args) {
         }
         const existingPort = Number.parseInt(existingInstance?.env.IRANTI_PORT ?? '3001', 10);
         const port = await chooseAvailablePort(prompt, 'API port', existingPort, Boolean(existingInstance));
-        const dockerAvailable = hasDockerInstalled();
+        const dockerStatus = inspectDockerAvailability();
+        const dockerAvailable = dockerStatus.daemonReachable;
         const psqlAvailable = hasCommandInstalled('psql');
         let dbUrl = '';
         let bootstrapDatabase = false;
+        let databaseProvisioned = false;
+        let dockerContainerName;
         let databaseMode = recommendedDatabaseMode;
         while (true) {
             const defaultMode = recommendedDatabaseMode;
@@ -3210,13 +3359,14 @@ async function setupCommand(args) {
             if (dbMode === 'docker') {
                 databaseMode = 'docker';
                 if (!dockerAvailable) {
-                    console.log(`${warnLabel()} Docker is not installed or not on PATH. Choose local or managed instead.`);
+                    console.log(`${warnLabel()} ${dockerStatus.detail}`);
                     continue;
                 }
                 const dbHostPort = await chooseAvailablePort(prompt, 'Docker PostgreSQL host port', 5432, false);
                 const dbName = sanitizeIdentifier(await promptNonEmpty(prompt, 'Docker PostgreSQL database name', `iranti_${instanceName}`), `iranti_${instanceName}`);
                 const dbPassword = await promptRequiredSecret(prompt, 'Docker PostgreSQL password');
                 const containerName = sanitizeIdentifier(await promptNonEmpty(prompt, 'Docker container name', `iranti_${instanceName}_db`), `iranti_${instanceName}_db`);
+                dockerContainerName = containerName;
                 dbUrl = `postgresql://postgres:${dbPassword}@localhost:${dbHostPort}/${dbName}`;
                 console.log(`${infoLabel()} Docker will be used only for PostgreSQL. Iranti itself does not require Docker once a PostgreSQL database is available.`);
                 if (await promptYesNo(prompt, `Start or reuse Docker container '${containerName}' now?`, true)) {
@@ -3227,11 +3377,9 @@ async function setupCommand(args) {
                         database: dbName,
                     });
                     console.log(`${okLabel()} Docker PostgreSQL ready at localhost:${dbHostPort}`);
-                    bootstrapDatabase = true;
-                }
-                else {
-                    bootstrapDatabase = await promptYesNo(prompt, 'Will you start PostgreSQL separately before first run?', false);
+                    databaseProvisioned = true;
                 }
+                bootstrapDatabase = await promptYesNo(prompt, 'Run migrations and seed the database now?', true);
                 break;
             }
             console.log(`${warnLabel()} Choose one of: local, managed, docker.`);
@@ -3333,6 +3481,8 @@ async function setupCommand(args) {
             codex,
             codexAgent: projects[0]?.agentId,
             bootstrapDatabase,
+            dockerContainerName,
+            databaseProvisioned,
         });
     });
     if (!result) {
@@ -3374,6 +3524,7 @@ async function doctorCommand(args) {
     const version = getPackageVersion();
     const pushEnvironmentChecks = async (env, prefix = '') => {
         const databaseUrl = env.DATABASE_URL;
+        let databaseInitializedForDoctor = false;
         checks.push(detectPlaceholder(databaseUrl)
             ? {
                 name: `${prefix}database configuration`,
@@ -3397,6 +3548,10 @@ async function doctorCommand(args) {
             name: `${prefix}${providerKeyCheck.name}`,
         });
         try {
+            if (!detectPlaceholder(databaseUrl)) {
+                (0, client_1.initDb)(databaseUrl);
+                databaseInitializedForDoctor = true;
+            }
             const backendName = (0, backends_1.resolveVectorBackendName)({
                 vectorBackend: env.IRANTI_VECTOR_BACKEND,
                 qdrantUrl: env.IRANTI_QDRANT_URL,
@@ -3436,6 +3591,11 @@ async function doctorCommand(args) {
                 detail: error instanceof Error ? error.message : String(error),
             });
         }
+        finally {
+            if (databaseInitializedForDoctor) {
+                await (0, client_1.disconnectDb)();
+            }
+        }
     };
     checks.push({
         name: 'node version',

package/dist/scripts/iranti-mcp.js

@@ -144,7 +144,7 @@ async function main() {
     await ensureDefaultAgent(iranti);
     const server = new mcp_js_1.McpServer({
         name: 'iranti-mcp',
-        version: '0.2.19',
+        version: '0.2.21',
     });
     server.registerTool('iranti_handshake', {
         description: `Initialize or refresh an agent's working-memory brief for the current task.

package/dist/scripts/setup.js

@@ -9,15 +9,35 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const client_1 = require("../src/library/client");
 const escalationPaths_1 = require("../src/lib/escalationPaths");
-const PACKAGE_ROOT = path_1.default.resolve(__dirname, '..');
+function resolvePackageRoot() {
+    let dir = __dirname;
+    for (let i = 0; i < 8; i += 1) {
+        const pkgPath = path_1.default.join(dir, 'package.json');
+        const prismaSchema = path_1.default.join(dir, 'prisma', 'schema.prisma');
+        if (fs_1.default.existsSync(pkgPath) && fs_1.default.existsSync(prismaSchema)) {
+            return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`Could not resolve Iranti package root from ${__dirname}`);
+}
+const PACKAGE_ROOT = resolvePackageRoot();
+const PRISMA_SCHEMA = path_1.default.join(PACKAGE_ROOT, 'prisma', 'schema.prisma');
+const BASE_ENV = { ...process.env };
 // ─── Helpers ─────────────────────────────────────────────────────────────────
-function run(command, label) {
+function run(command, label, extraEnv) {
     console.log(`  Running: ${label}...`);
     try {
         (0, child_process_1.execSync)(command, {
             stdio: 'inherit',
             cwd: PACKAGE_ROOT,
-            env: process.env,
+            env: {
+                ...BASE_ENV,
+                ...extraEnv,
+            },
         });
     }
     catch {
@@ -26,7 +46,7 @@ function run(command, label) {
     }
 }
 function scriptCommand(distScriptName, sourceScriptPath) {
-    const distScriptPath = path_1.default.resolve(__dirname, '..', 'dist', 'scripts', distScriptName);
+    const distScriptPath = path_1.default.join(PACKAGE_ROOT, 'dist', 'scripts', distScriptName);
     if (fs_1.default.existsSync(distScriptPath)) {
         return `node ${JSON.stringify(distScriptPath)}`;
     }
@@ -57,13 +77,18 @@ async function setup() {
         process.env.DATABASE_URL = dbUrl;
         (0, client_1.initDb)(dbUrl);
     }
+    const runtimeEnv = dbUrl
+        ? {
+            DATABASE_URL: dbUrl,
+        }
+        : undefined;
     // 1. Run migrations
     console.log('Step 1 — Running database migrations...');
-    run('npx prisma migrate deploy', 'prisma migrate deploy');
+    run(`npx prisma migrate deploy --schema ${JSON.stringify(PRISMA_SCHEMA)}`, 'prisma migrate deploy', runtimeEnv);
     console.log('  ✓ Migrations complete\n');
     // 2. Generate Prisma client
     console.log('Step 2 — Generating Prisma client...');
-    run('npx prisma generate', 'prisma generate');
+    run(`npx prisma generate --schema ${JSON.stringify(PRISMA_SCHEMA)}`, 'prisma generate', runtimeEnv);
     console.log('  ✓ Client generated\n');
     // 3. Seed Staff Namespace if not already seeded
     console.log('Step 3 — Seeding Staff Namespace...');

package/dist/src/api/server.js

@@ -39,7 +39,7 @@ const INSTANCE_DIR = process.env.IRANTI_INSTANCE_DIR?.trim()
 const INSTANCE_RUNTIME_FILE = process.env.IRANTI_INSTANCE_RUNTIME_FILE?.trim()
     || (INSTANCE_DIR ? (0, runtimeLifecycle_1.runtimeFileForInstance)(INSTANCE_DIR) : null);
 const INSTANCE_NAME = process.env.IRANTI_INSTANCE_NAME?.trim() || (INSTANCE_DIR ? path_1.default.basename(INSTANCE_DIR) : 'adhoc');
-const VERSION = '0.2.19';
+const VERSION = '0.2.21';
 try {
     fs_1.default.mkdirSync(path_1.default.dirname(REQUEST_LOG_FILE), { recursive: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iranti",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Memory infrastructure for multi-agent AI systems",
   "main": "dist/src/sdk/index.js",
   "files": [
@@ -16,6 +16,7 @@
     "dist/scripts/api-key-list.js",
     "dist/scripts/api-key-revoke.js",
     "bin/iranti.js",
+    "prisma.config.ts",
     "prisma/schema.prisma",
     "prisma/migrations/**/*",
     ".env.example",

package/prisma.config.ts

@@ -0,0 +1,14 @@
+// This file was generated by Prisma, and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});