@crouter/api 0.3.387 → 0.3.389

package/dist/core/scoped-state/db.js

@@ -0,0 +1,247 @@
+import { DatabaseSync } from 'node:sqlite';
+import { forgetPrepared } from '../sqlite-statements.js';
+import { chmodSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import lockfile from 'proper-lockfile';
+import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
+import { withExclusiveDirectoryLock } from '../exclusive-lock.js';
+import { layoutNeedsMigration } from '../layout.js';
+import { providerStore, projectStore, userStore } from './paths.js';
+import { createScopedSchema, ensureProviderModelCooldowns, PROVIDER_SCHEMA_VERSION, SCOPED_SCHEMA_VERSION } from './schema.js';
+const handles = new Map();
+export const PROFILE_ID_SHAPE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;
+export function writeOwnerRoot(db, key, root) {
+    db.prepare('UPDATE scope_owners SET root=? WHERE owner_key=?').run(root, key);
+}
+function version(db) {
+    return Number(db.prepare('PRAGMA user_version').get().user_version);
+}
+function assertVersion(db, store) {
+    const found = version(db);
+    if (found === 0)
+        throw new Error(`scoped SQL store is uninitialized: ${store.path}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+    const expected = store.kind === 'provider' ? PROVIDER_SCHEMA_VERSION : SCOPED_SCHEMA_VERSION;
+    if (found > expected)
+        throw new Error(`scoped SQL store ${store.path} uses unsupported schema version ${found}`);
+    if (found !== expected)
+        throw new Error(`scoped SQL store ${store.path} requires an explicit conversion`);
+}
+function upgradeScopedStore(db, store) {
+    if (store.kind === 'provider') {
+        if (version(db) === PROVIDER_SCHEMA_VERSION) {
+            db.exec('PRAGMA busy_timeout = 5000');
+            ensureProviderModelCooldowns(db);
+        }
+        return;
+    }
+    if (version(db) >= SCOPED_SCHEMA_VERSION)
+        return;
+    db.exec('PRAGMA busy_timeout = 5000; BEGIN IMMEDIATE');
+    try {
+        if (version(db) === 1) {
+            const columns = db.prepare('PRAGMA table_info(profiles)').all();
+            if (!columns.some(({ name }) => name === 'grantee'))
+                db.exec('ALTER TABLE profiles ADD COLUMN grantee TEXT');
+            db.exec('PRAGMA user_version = 2');
+        }
+        if (version(db) === 2) {
+            const columns = db.prepare('PRAGMA table_info(profiles)').all();
+            if (columns.some(({ name }) => name === 'home'))
+                db.exec('ALTER TABLE profiles DROP COLUMN home');
+            db.exec('PRAGMA user_version = 3');
+        }
+        if (version(db) === 3) {
+            db.exec("ALTER TABLE profiles ADD COLUMN delivery_limits_json TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(delivery_limits_json))");
+            db.exec('PRAGMA user_version = 4');
+        }
+        if (version(db) === 4) {
+            db.exec(`CREATE TABLE IF NOT EXISTS legacy_project_caps (profile_id TEXT NOT NULL, path TEXT NOT NULL, memory TEXT NOT NULL CHECK(memory IN ('none','name','preview')), PRIMARY KEY(profile_id,path))`);
+            const columns = db.prepare('PRAGMA table_info(profile_projects)').all();
+            if (columns.some(({ name }) => name === 'memory')) {
+                db.exec(`INSERT INTO legacy_project_caps SELECT profile_id, path, memory FROM profile_projects WHERE memory != 'content';
+          ALTER TABLE profile_projects DROP COLUMN memory;`);
+            }
+            db.exec(`PRAGMA user_version = ${SCOPED_SCHEMA_VERSION}`);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function assertScopedStoreReady(store) {
+    const db = new DatabaseSync(store.path);
+    try {
+        upgradeScopedStore(db, store);
+        assertVersion(db, store);
+    }
+    finally {
+        db.close();
+    }
+}
+export function discardIncompleteScopedStore(store) {
+    if (!scopedStoreExists(store))
+        return;
+    const db = new DatabaseSync(store.path, { readOnly: true });
+    let found;
+    try {
+        found = version(db);
+    }
+    finally {
+        db.close();
+    }
+    if (found === 0)
+        for (const path of [store.path, `${store.path}-wal`, `${store.path}-shm`])
+            rmSync(path, { force: true });
+}
+export function withProjectStateLock(root, run) {
+    return withExclusiveDirectoryLock(join(root, '.init.lock'), () => {
+        const path = join(root, STATE_FILE);
+        const deadline = Date.now() + 5_000;
+        let pollMs = 10;
+        for (;;) {
+            let release;
+            try {
+                release = lockfile.lockSync(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 });
+            }
+            catch (error) {
+                if (error.code !== 'ELOCKED')
+                    throw error;
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    throw new Error(`timed out waiting for project state conversion lock: ${path}`, { cause: error });
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.min(pollMs, remaining));
+                pollMs = Math.min(pollMs * 2, 250);
+                continue;
+            }
+            try {
+                return run();
+            }
+            finally {
+                release();
+            }
+        }
+    });
+}
+function secure(path) {
+    if (existsSync(path))
+        chmodSync(path, 0o600);
+    for (const suffix of ['-wal', '-shm'])
+        if (existsSync(`${path}${suffix}`))
+            chmodSync(`${path}${suffix}`, 0o600);
+}
+export function scopedStoreExists(store) {
+    return existsSync(store.path);
+}
+export function legacyScopedStorePaths(store) {
+    if (store.kind === 'project')
+        return [join(store.root, STATE_FILE)];
+    if (store.kind === 'provider')
+        return [join(store.root, 'anthropic-subscriptions.json'), join(store.root, 'openai-codex-subscriptions.json'), join(store.root, 'provider-rotation.json')];
+    const paths = [join(store.root, CONFIG_FILE), join(store.root, STATE_FILE), join(store.root, 'profile-defaults.json')];
+    const profiles = join(store.root, PROFILE_DIR);
+    if (existsSync(profiles))
+        for (const entry of readdirSync(profiles, { withFileTypes: true }))
+            if (entry.isDirectory() && PROFILE_ID_SHAPE.test(entry.name))
+                paths.push(join(profiles, entry.name, 'profile.json'), join(profiles, entry.name, CONFIG_FILE), join(profiles, entry.name, STATE_FILE));
+    return paths;
+}
+export function initializeFreshScopedStore(input) {
+    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
+    if (store.kind !== 'project')
+        mkdirSync(store.root, { recursive: true, mode: 0o700 });
+    const initialize = () => {
+        if (store.kind === 'project')
+            discardIncompleteScopedStore(store);
+        if (scopedStoreExists(store))
+            return;
+        const legacyPath = legacyScopedStorePaths(store).find(existsSync);
+        if (legacyPath !== undefined)
+            throw new Error(`legacy scoped state exists at ${legacyPath}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+        createScopedStore(store, (db) => {
+            createScopedSchema(db, store.kind);
+            if (store.kind !== 'provider')
+                writeOwnerRoot(db, store.kind, store.root);
+        });
+    };
+    if (store.kind === 'project')
+        withProjectStateLock(store.root, initialize);
+    else
+        withExclusiveDirectoryLock(join(store.root, '.init.lock'), initialize);
+}
+export function openScopedStore(store) {
+    if (layoutNeedsMigration())
+        throw new Error('layout_migration_required');
+    const cached = handles.get(store.path);
+    if (cached !== undefined)
+        return cached;
+    initializeFreshScopedStore(store);
+    const db = new DatabaseSync(store.path);
+    try {
+        db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;');
+        upgradeScopedStore(db, store);
+        assertVersion(db, store);
+        secure(store.path);
+        handles.set(store.path, db);
+        return db;
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+}
+export function createScopedStore(store, create) {
+    if (existsSync(store.path))
+        throw new Error(`scoped SQL store already exists: ${store.path}`);
+    if (store.kind !== 'project')
+        mkdirSync(store.root, { recursive: true, mode: 0o700 });
+    if (!statSync(store.root).isDirectory())
+        throw new Error(`scoped SQL root is not a directory: ${store.root}`);
+    if (store.kind !== 'project' || process.platform !== 'linux')
+        chmodSync(store.root, 0o700);
+    writeFileSync(store.path, '', { mode: 0o600 });
+    const db = new DatabaseSync(store.path);
+    try {
+        db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; BEGIN IMMEDIATE;');
+        create(db);
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        secure(store.path);
+        db.close();
+    }
+}
+export function withScopedWrite(store, run) {
+    const db = openScopedStore(store);
+    if (db.isTransaction)
+        return run(db);
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const value = run(db);
+        db.exec('COMMIT');
+        secure(store.path);
+        return value;
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+}
+export function closeScopedStores() {
+    for (const db of handles.values()) {
+        forgetPrepared(db);
+        db.close();
+    }
+    handles.clear();
+}

package/dist/core/scoped-state/migrate.d.ts

@@ -0,0 +1,8 @@
+export { initializeFreshScopedStore } from './db.js';
+/** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
+export declare function convertLegacyScopedStore(input: {
+    kind: 'user' | 'project' | 'provider';
+    root: string;
+}): void;
+/** Converts legacy provider pools only after the activation owner has stopped every writer sharing this agent directory. */
+export declare function convertLegacyProviderStore(agentDir: string): Promise<void>;

package/dist/core/scoped-state/migrate.js

@@ -0,0 +1,187 @@
+import { prepared as cachedStatement } from '../sqlite-statements.js';
+import { randomUUID } from 'node:crypto';
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import lockfile from 'proper-lockfile';
+import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
+import { LockedJsonFile } from '../locked-file.js';
+import { assertScopedStoreReady, createScopedStore, discardIncompleteScopedStore, legacyScopedStorePaths, PROFILE_ID_SHAPE, scopedStoreExists, withProjectStateLock, writeOwnerRoot } from './db.js';
+import { canonicalRoot, providerStore, projectStore, userStore } from './paths.js';
+import { profileSpace } from '../layout.js';
+import { createScopedSchema } from './schema.js';
+function json(path) { return JSON.parse(readFileSync(path, 'utf8')); }
+function existsLegacy(paths) { return paths.some(existsSync); }
+function preserve(root, paths) { const target = join(root, '.legacy-scoped-state'); try {
+    mkdirSync(target, { mode: 0o700 });
+}
+catch (error) {
+    if (error.code !== 'EEXIST' || !statSync(target).isDirectory())
+        throw error;
+} chmodSync(target, 0o700); for (const path of paths)
+    if (existsSync(path) && statSync(path).isFile()) {
+        const fromRoot = relative(root, path);
+        if (fromRoot === '' || fromRoot.startsWith('..'))
+            throw new Error(`legacy state is outside its owning root: ${path}`);
+        const destination = join(target, fromRoot);
+        if (dirname(destination) !== target)
+            mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+        copyFileSync(path, destination);
+        chmodSync(destination, 0o600);
+    } }
+export { initializeFreshScopedStore } from './db.js';
+/** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
+export function convertLegacyScopedStore(input) {
+    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
+    if (input.kind !== 'project' && scopedStoreExists(store))
+        return;
+    if (input.kind === 'provider')
+        throw new Error('provider conversion requires convertLegacyProviderStore() under coordinated shared-agent-dir activation');
+    const paths = legacyScopedStorePaths(store);
+    const convert = () => {
+        if (input.kind === 'project')
+            discardIncompleteScopedStore(store);
+        if (scopedStoreExists(store))
+            return;
+        if (input.kind === 'project' && existsLegacy(paths))
+            preserve(store.root, paths);
+        createScopedStore(store, (db) => {
+            createScopedSchema(db, input.kind);
+            const owner = input.kind === 'user' ? 'user' : 'project';
+            writeOwnerRoot(db, owner, store.root);
+            if (input.kind === 'user')
+                importUser(db, store.root);
+            else
+                importState(db, owner, join(store.root, STATE_FILE));
+        });
+        if (input.kind === 'user' && existsLegacy(paths))
+            preserve(store.root, paths);
+    };
+    if (input.kind === 'project')
+        withProjectStateLock(store.root, () => { convert(); assertScopedStoreReady(store); });
+    else
+        convert();
+}
+function parseLegacyProviderPool(path) {
+    if (!existsSync(path))
+        return [];
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(raw))
+        throw new Error(`legacy subscription pool is malformed: ${path}`);
+    const labels = new Set();
+    return raw.map((item, position) => {
+        if (item === null || typeof item !== 'object' || Array.isArray(item))
+            throw new Error(`legacy subscription pool entry ${position + 1} is malformed: ${path}`);
+        const value = item;
+        const label = typeof value.label === 'string' ? value.label.trim() : '';
+        const refresh = typeof value.refresh === 'string' ? value.refresh.trim() : '';
+        const access = typeof value.access === 'string' ? value.access.trim() : '';
+        const expires = Number(value.expires);
+        if (!label || !refresh || !access || !Number.isFinite(expires))
+            throw new Error(`legacy subscription pool entry ${position + 1} is incomplete: ${path}`);
+        const labelKey = label.toLowerCase();
+        if (labels.has(labelKey))
+            throw new Error(`legacy subscription pool has duplicate label "${label}": ${path}`);
+        labels.add(labelKey);
+        const timing = (field) => Number.isFinite(Number(value[field])) ? Number(value[field]) : 0;
+        const accountId = typeof value.accountId === 'string' && value.accountId.trim() !== '' ? value.accountId.trim() : undefined;
+        return { label, refresh, access, expires, rateLimitedUntil: timing('rateLimitedUntil'), lastAttemptAt: timing('lastAttemptAt'), lastRateLimitedAt: timing('lastRateLimitedAt'), ...(value.authFailure === 'invalid_grant' ? { authFailure: 'invalid_grant' } : {}), ...(accountId ? { accountId } : {}) };
+    });
+}
+function parseLegacyRotation(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        throw new Error(`legacy provider rotation settings are malformed: ${path}`);
+    const value = raw;
+    return { ...(value.defaultFallbackStrength === 'ultra' || value.defaultFallbackStrength === 'strong' || value.defaultFallbackStrength === 'medium' || value.defaultFallbackStrength === 'light' ? { defaultFallbackStrength: value.defaultFallbackStrength } : {}), ...(typeof value.revertWhenAvailable === 'boolean' ? { revertWhenAvailable: value.revertWhenAvailable } : {}) };
+}
+async function withLegacyProviderLocks(paths, run) {
+    const releases = [];
+    try {
+        for (const path of paths)
+            if (existsSync(path))
+                releases.push(await lockfile.lock(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 }));
+        return await run();
+    }
+    finally {
+        await Promise.allSettled(releases.reverse().map((release) => release()));
+    }
+}
+/** Converts legacy provider pools only after the activation owner has stopped every writer sharing this agent directory. */
+export async function convertLegacyProviderStore(agentDir) {
+    const store = providerStore(agentDir);
+    if (scopedStoreExists(store))
+        return;
+    const paths = legacyScopedStorePaths(store);
+    await withLegacyProviderLocks(paths, async () => {
+        if (scopedStoreExists(store))
+            return;
+        const pools = new Map(paths.slice(0, 2).map((path, index) => [index === 0 ? 'anthropic' : 'openai-codex', parseLegacyProviderPool(path)]));
+        const rotation = parseLegacyRotation(paths[2]);
+        mkdirSync(store.root, { recursive: true, mode: 0o700 });
+        preserve(store.root, paths);
+        for (const [provider, pool] of pools) {
+            const accounts = Object.fromEntries(pool.map((entry) => { const id = randomUUID(); return [id, { refresh: entry.refresh, access: entry.access, expires: entry.expires, ...(entry.accountId ? { accountId: entry.accountId } : {}) }]; }));
+            const file = new LockedJsonFile(join(store.root, `${provider}-credentials.json`), true, '{"version":1,"accounts":{}}\n');
+            await file.withLockAsync(async (_current, _held, publish) => { publish(`${JSON.stringify({ version: 1, accounts })}\n`); return { result: undefined }; });
+        }
+        createScopedStore(store, (db) => {
+            createScopedSchema(db, 'provider');
+            for (const [provider, pool] of pools) {
+                const accounts = JSON.parse(readFileSync(join(store.root, `${provider}-credentials.json`), 'utf8'));
+                const ids = Object.keys(accounts.accounts);
+                const insert = cachedStatement(db, 'INSERT INTO managed_accounts(provider_id,id,label,label_key,position,last_attempt_at,last_rate_limited_at,rate_limited_until,auth_failure) VALUES(?,?,?,?,?,?,?,?,?)');
+                pool.forEach((entry, position) => insert.run(provider, ids[position], entry.label, entry.label.toLowerCase(), position, entry.lastAttemptAt, entry.lastRateLimitedAt, entry.rateLimitedUntil, entry.authFailure ?? null));
+            }
+            if (rotation.defaultFallbackStrength !== undefined || rotation.revertWhenAvailable !== undefined)
+                cachedStatement(db, 'INSERT INTO rotation_settings(singleton,default_fallback_strength,revert_when_available) VALUES(1,?,?)').run(rotation.defaultFallbackStrength ?? null, rotation.revertWhenAvailable === undefined ? null : rotation.revertWhenAvailable ? 1 : 0);
+        });
+    });
+}
+function importSettings(db, owner, path) { if (!existsSync(path))
+    return; const raw = json(path); if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+    throw new Error(`legacy config is malformed: ${path}`); cachedStatement(db, 'INSERT INTO scope_settings(owner_key,raw_json) VALUES(?,?)').run(owner, JSON.stringify(raw)); }
+function importState(db, owner, path) { if (!existsSync(path))
+    return; const raw = json(path); if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+    throw new Error(`legacy state is malformed: ${path}`); const state = raw; cachedStatement(db, 'INSERT INTO scope_bookkeeping(owner_key,last_self_check,active_canvas) VALUES(?,?,?)').run(owner, state.last_self_check ?? null, state.activeCanvas ?? null); const market = cachedStatement(db, 'INSERT INTO scope_marketplaces(owner_key,name,last_updated) VALUES(?,?,?)'); for (const [name, value] of Object.entries(state.marketplaces ?? {}))
+    market.run(owner, name, value.last_updated ?? null); const plugins = cachedStatement(db, 'INSERT INTO scope_plugins(owner_key,name,last_updated,etag,checked_at) VALUES(?,?,?,?,?)'); for (const [name, value] of Object.entries(state.plugins ?? {}))
+    plugins.run(owner, name, value.last_updated ?? null, value.etag ?? null, value.checked_at ?? null); }
+function importUser(db, root) {
+    importSettings(db, 'user', join(root, CONFIG_FILE));
+    importState(db, 'user', join(root, STATE_FILE));
+    const profiles = join(root, PROFILE_DIR);
+    if (existsSync(profiles))
+        for (const entry of readdirSync(profiles, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !PROFILE_ID_SHAPE.test(entry.name))
+                continue;
+            const id = entry.name;
+            const profileRoot = join(profiles, id);
+            const path = join(profileRoot, 'profile.json');
+            if (!existsSync(path))
+                throw new Error(`legacy profile manifest is missing: ${path}`);
+            const manifest = json(path);
+            if (!manifest || typeof manifest !== 'object' || !Array.isArray(manifest.projects) || typeof manifest.name !== 'string' || typeof manifest.created_at !== 'string')
+                throw new Error(`legacy profile manifest is malformed: ${path}`);
+            cachedStatement(db, 'INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,default_kind,grantee,metadata_json) VALUES(?,?,?,?,?,?,?,?)').run(id, manifest.name, manifest.created_at, manifest.last_used_at ?? null, manifest.paused_at ?? null, manifest.default_kind ?? null, manifest.grantee ?? null, JSON.stringify(manifest.metadata ?? {}));
+            cachedStatement(db, 'INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${id}`, 'profile', canonicalRoot(profileSpace(manifest.grantee ?? 'app:terminal', id).memory), id);
+            const project = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
+            const cap = cachedStatement(db, 'INSERT INTO legacy_project_caps(profile_id,path,memory) VALUES(?,?,?)');
+            manifest.projects.forEach((p, position) => { project.run(id, p.path, position); if (p.memory !== undefined && p.memory !== 'content')
+                cap.run(id, p.path, p.memory); });
+            importSettings(db, `profile:${id}`, join(profileRoot, CONFIG_FILE));
+            importState(db, `profile:${id}`, join(profileRoot, STATE_FILE));
+        }
+    const defaults = join(root, 'profile-defaults.json');
+    if (existsSync(defaults)) {
+        const raw = json(defaults);
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error(`legacy profile defaults are malformed: ${defaults}`);
+        const insert = cachedStatement(db, 'INSERT INTO profile_defaults(directory,profile_id) VALUES(?,?)');
+        for (const [directory, id] of Object.entries(raw)) {
+            if (typeof id !== 'string')
+                throw new Error(`legacy profile default is malformed: ${defaults}`);
+            insert.run(directory, id);
+        }
+    }
+}

package/dist/core/scoped-state/paths.d.ts

@@ -0,0 +1,9 @@
+export type ScopedStore = {
+    path: string;
+    root: string;
+    kind: 'user' | 'project' | 'provider';
+};
+export declare function canonicalRoot(root: string): string;
+export declare function userStore(root: string): ScopedStore;
+export declare function projectStore(root: string): ScopedStore;
+export declare function providerStore(agentDir: string): ScopedStore;

package/dist/core/scoped-state/paths.js

@@ -0,0 +1,27 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+export function canonicalRoot(root) {
+    const absolute = resolve(root);
+    let existing = absolute;
+    const missing = [];
+    while (!existsSync(existing)) {
+        const parent = dirname(existing);
+        if (parent === existing)
+            return absolute;
+        missing.unshift(basename(existing));
+        existing = parent;
+    }
+    return resolve(realpathSync(existing), ...missing);
+}
+export function userStore(root) {
+    const canonical = canonicalRoot(root);
+    return { path: join(canonical, 'operations.db'), root: canonical, kind: 'user' };
+}
+export function projectStore(root) {
+    const canonical = canonicalRoot(root);
+    return { path: join(canonical, 'operations.db'), root: canonical, kind: 'project' };
+}
+export function providerStore(agentDir) {
+    const canonical = canonicalRoot(agentDir);
+    return { path: join(canonical, 'crouter-operations.db'), root: canonical, kind: 'provider' };
+}

package/dist/core/scoped-state/profiles.d.ts

@@ -0,0 +1,27 @@
+import type { ProfileManifest } from '../../types.js';
+export type StoredProfile = {
+    profileId: string;
+    manifest: ProfileManifest;
+};
+export declare function listStoredProfiles(root: string): StoredProfile[];
+export declare function getStoredProfile(root: string, id: string): StoredProfile | null;
+/** Pause gates need only this column; do not hydrate projects or JSON manifests. */
+export declare function profilePaused(root: string, id: string): boolean;
+export declare function pausedProfileIds(root: string): Set<string>;
+export declare function insertStoredProfile(root: string, profile: StoredProfile): void;
+export declare function updateStoredProfile(root: string, id: string, mutate: (current: ProfileManifest) => ProfileManifest): StoredProfile | null;
+export declare function deleteStoredProfile(root: string, id: string): boolean;
+export declare function rewriteLocalProfileGrantees(root: string): void;
+export declare function readStoredDefaults(root: string): Record<string, string>;
+export declare function mutateStoredDefaults(root: string, mutate: (current: Record<string, string>) => Record<string, string>): Record<string, string>;
+/** Pre-canvas per-project memory caps (`none|name|preview`) the canvas import has not converted yet. */
+export declare function listLegacyProjectCaps(root: string): Array<{
+    profileId: string;
+    path: string;
+    memory: string;
+}>;
+/** Store each converted profile's delivery limits and delete every legacy cap row, in one write. */
+export declare function commitConvertedProjectCaps(root: string, limits: ReadonlyArray<{
+    profileId: string;
+    deliveryLimits: Record<string, string>;
+}>): void;

package/dist/core/scoped-state/profiles.js

@@ -0,0 +1,93 @@
+import { prepared as cachedStatement } from '../sqlite-statements.js';
+import { canonicalRoot, userStore } from './paths.js';
+import { profileSpace } from '../layout.js';
+import { openScopedStore, withScopedWrite } from './db.js';
+function store(root) { return userStore(root); }
+function rowToProfile(row, projects) {
+    return { profileId: row.id, manifest: { schema_version: 1, name: row.name, projects, paused_at: row.paused_at, ...(row.default_kind === null ? {} : { default_kind: row.default_kind }), ...(row.grantee === null ? {} : { grantee: row.grantee }), ...(row.delivery_limits_json === '{}' ? {} : { delivery_limits: JSON.parse(row.delivery_limits_json) }), ...(Object.keys(JSON.parse(row.metadata_json)).length === 0 ? {} : { metadata: JSON.parse(row.metadata_json) }), created_at: row.created_at, last_used_at: row.last_used_at } };
+}
+function get(db, id) {
+    const row = cachedStatement(db, 'SELECT id, name, created_at, last_used_at, paused_at, default_kind, grantee, metadata_json, delivery_limits_json FROM profiles WHERE id=?').get(id);
+    if (!row)
+        return null;
+    const projects = cachedStatement(db, 'SELECT path FROM profile_projects WHERE profile_id=? ORDER BY position').all(id);
+    return rowToProfile(row, projects);
+}
+export function listStoredProfiles(root) {
+    const db = openScopedStore(store(root));
+    const ids = cachedStatement(db, 'SELECT id FROM profiles ORDER BY rowid').all();
+    return ids.map(({ id }) => get(db, id)).filter(Boolean);
+}
+export function getStoredProfile(root, id) { return get(openScopedStore(store(root)), id); }
+/** Pause gates need only this column; do not hydrate projects or JSON manifests. */
+export function profilePaused(root, id) {
+    const row = cachedStatement(openScopedStore(store(root)), 'SELECT paused_at FROM profiles WHERE id=?').get(id);
+    return row?.paused_at != null;
+}
+export function pausedProfileIds(root) {
+    const rows = cachedStatement(openScopedStore(store(root)), 'SELECT id FROM profiles WHERE paused_at IS NOT NULL').all();
+    return new Set(rows.map((row) => row.id));
+}
+export function insertStoredProfile(root, profile) {
+    withScopedWrite(store(root), (db) => {
+        cachedStatement(db, 'INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,default_kind,grantee,metadata_json,delivery_limits_json) VALUES(?,?,?,?,?,?,?,?,?)').run(profile.profileId, profile.manifest.name, profile.manifest.created_at, profile.manifest.last_used_at, profile.manifest.paused_at, profile.manifest.default_kind ?? null, profile.manifest.grantee ?? null, JSON.stringify(profile.manifest.metadata ?? {}), JSON.stringify(profile.manifest.delivery_limits ?? {}));
+        cachedStatement(db, 'INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${profile.profileId}`, 'profile', canonicalRoot(profileSpace(profile.manifest.grantee ?? 'app:terminal', profile.profileId).memory), profile.profileId);
+        const insert = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
+        profile.manifest.projects.forEach((project, position) => insert.run(profile.profileId, project.path, position));
+    });
+}
+export function updateStoredProfile(root, id, mutate) {
+    return withScopedWrite(store(root), (db) => {
+        const current = get(db, id);
+        if (!current)
+            return null;
+        const next = mutate(current.manifest);
+        cachedStatement(db, 'UPDATE profiles SET name=?, last_used_at=?, paused_at=?, default_kind=?, grantee=?, metadata_json=?, delivery_limits_json=? WHERE id=?').run(next.name, next.last_used_at, next.paused_at, next.default_kind ?? null, next.grantee ?? null, JSON.stringify(next.metadata ?? {}), JSON.stringify(next.delivery_limits ?? {}), id);
+        cachedStatement(db, 'DELETE FROM profile_projects WHERE profile_id=?').run(id);
+        const insert = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
+        next.projects.forEach((project, position) => insert.run(id, project.path, position));
+        return { profileId: id, manifest: next };
+    });
+}
+export function deleteStoredProfile(root, id) {
+    return withScopedWrite(store(root), (db) => {
+        if (!get(db, id))
+            return false;
+        const owner = `profile:${id}`;
+        cachedStatement(db, 'DELETE FROM scope_settings WHERE owner_key=?').run(owner);
+        cachedStatement(db, 'DELETE FROM scope_bookkeeping WHERE owner_key=?').run(owner);
+        cachedStatement(db, 'DELETE FROM scope_marketplaces WHERE owner_key=?').run(owner);
+        cachedStatement(db, 'DELETE FROM scope_plugins WHERE owner_key=?').run(owner);
+        cachedStatement(db, 'DELETE FROM scope_owners WHERE owner_key=?').run(owner);
+        cachedStatement(db, 'DELETE FROM profiles WHERE id=?').run(id);
+        return true;
+    });
+}
+export function rewriteLocalProfileGrantees(root) {
+    withScopedWrite(store(root), (db) => {
+        cachedStatement(db, "UPDATE profiles SET grantee = 'app:terminal' WHERE grantee = 'user:local'").run();
+    });
+}
+export function readStoredDefaults(root) {
+    const db = openScopedStore(store(root));
+    return Object.fromEntries(cachedStatement(db, 'SELECT directory,profile_id FROM profile_defaults').all().map((row) => [row.directory, row.profile_id]));
+}
+export function mutateStoredDefaults(root, mutate) {
+    return withScopedWrite(store(root), (db) => { const current = Object.fromEntries(cachedStatement(db, 'SELECT directory,profile_id FROM profile_defaults').all().map((row) => [row.directory, row.profile_id])); const next = mutate(current); cachedStatement(db, 'DELETE FROM profile_defaults').run(); const insert = cachedStatement(db, 'INSERT INTO profile_defaults(directory,profile_id) VALUES(?,?)'); for (const [directory, id] of Object.entries(next))
+        insert.run(directory, id); return next; });
+}
+/** Pre-canvas per-project memory caps (`none|name|preview`) the canvas import has not converted yet. */
+export function listLegacyProjectCaps(root) {
+    return cachedStatement(openScopedStore(store(root)), 'SELECT profile_id, path, memory FROM legacy_project_caps ORDER BY profile_id, path').all()
+        .map((r) => ({ profileId: r.profile_id, path: r.path, memory: r.memory }));
+}
+/** Store each converted profile's delivery limits and delete every legacy cap row, in one write. */
+export function commitConvertedProjectCaps(root, limits) {
+    withScopedWrite(store(root), (db) => {
+        const set = cachedStatement(db, 'UPDATE profiles SET delivery_limits_json=? WHERE id=?');
+        for (const l of limits)
+            if (set.run(JSON.stringify(l.deliveryLimits), l.profileId).changes !== 1)
+                throw new Error(`no stored profile ${l.profileId}`);
+        cachedStatement(db, 'DELETE FROM legacy_project_caps').run();
+    });
+}

package/dist/core/scoped-state/providers.d.ts

@@ -0,0 +1,24 @@
+import type { DatabaseSync } from 'node:sqlite';
+export type ProviderRow = {
+    providerId: string;
+    id: string;
+    label: string;
+    labelKey: string;
+    position: number;
+    lastAttemptAt: number;
+    lastRateLimitedAt: number;
+    rateLimitedUntil: number;
+    authFailure?: 'invalid_grant';
+};
+/** One model family's cooldown on one account (`managed_account_model_cooldowns`). */
+export type ProviderModelCooldown = {
+    family: string;
+    rateLimitedUntil: number;
+    lastRateLimitedAt: number;
+};
+export declare function providerRows(agentDir: string, providerId: string): ProviderRow[];
+export declare function providerRowByReference(db: DatabaseSync, providerId: string, ref: string): ProviderRow | undefined;
+export declare function providerModelCooldowns(db: DatabaseSync, providerId: string): Map<string, ProviderModelCooldown[]>;
+export declare function providerModelCooldownsFor(agentDir: string, providerId: string): Map<string, ProviderModelCooldown[]>;
+export declare function providerWrite<T>(agentDir: string, run: (db: DatabaseSync) => T): T;
+export declare function providerRevision(agentDir: string): number;

package/dist/core/scoped-state/providers.js

@@ -0,0 +1,19 @@
+import { prepared as cachedStatement } from '../sqlite-statements.js';
+import { openScopedStore, withScopedWrite } from './db.js';
+import { providerStore } from './paths.js';
+function map(row) { return { providerId: row.provider_id, id: row.id, label: row.label, labelKey: row.label_key, position: row.position, lastAttemptAt: row.last_attempt_at, lastRateLimitedAt: row.last_rate_limited_at, rateLimitedUntil: row.rate_limited_until, ...(row.auth_failure ? { authFailure: row.auth_failure } : {}) }; }
+const ROW_COLUMNS = 'provider_id,id,label,label_key,position,last_attempt_at,last_rate_limited_at,rate_limited_until,auth_failure';
+export function providerRows(agentDir, providerId) { const db = openScopedStore(providerStore(agentDir)); return db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? ORDER BY position`).all(providerId).map(map); }
+export function providerRowByReference(db, providerId, ref) { const needle = ref.trim().toLowerCase(); const position = Number.parseInt(needle, 10); const row = (Number.isFinite(position) && String(position) === needle && position >= 1 ? db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? AND position=?`).get(providerId, position - 1) : db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? AND label_key=?`).get(providerId, needle)); return row ? map(row) : undefined; }
+export function providerModelCooldowns(db, providerId) {
+    const out = new Map();
+    for (const row of cachedStatement(db, 'SELECT account_id,family,rate_limited_until,last_rate_limited_at FROM managed_account_model_cooldowns WHERE provider_id=? ORDER BY family').all(providerId)) {
+        const list = out.get(row.account_id) ?? [];
+        list.push({ family: row.family, rateLimitedUntil: row.rate_limited_until, lastRateLimitedAt: row.last_rate_limited_at });
+        out.set(row.account_id, list);
+    }
+    return out;
+}
+export function providerModelCooldownsFor(agentDir, providerId) { return providerModelCooldowns(openScopedStore(providerStore(agentDir)), providerId); }
+export function providerWrite(agentDir, run) { return withScopedWrite(providerStore(agentDir), (db) => { const value = run(db); cachedStatement(db, 'UPDATE provider_revision SET revision=revision+1 WHERE singleton=1').run(); return value; }); }
+export function providerRevision(agentDir) { const db = openScopedStore(providerStore(agentDir)); return cachedStatement(db, 'SELECT revision FROM provider_revision WHERE singleton=1').get().revision; }