@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/src/foundation/storage/control-store.js

@@ -1,530 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-import { assertManagedAgentDescriptor, assertRecoveryAuthority, assertTerminalSessionLaunch, assertTerminalTopologySnapshot, } from "../workspace-contracts/index.js";
-import { assertLaunchInstance, assertLaunchInstanceOutcome, assertNativeProcessIdentity, assertProcessContainmentIdentity, } from "../lifecycle/index.js";
-export const DEFAULT_WORKSPACE_ID = "workspace-default";
-const INITIAL_WORKSPACE_ID = DEFAULT_WORKSPACE_ID;
-export class ControlStore {
-    bootNonce;
-    database;
-    constructor(path, bootNonce = null) {
-        this.bootNonce = bootNonce;
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-        this.database = new DatabaseSync(path);
-        try {
-            this.database.exec("PRAGMA journal_mode = WAL");
-            this.database.exec("PRAGMA foreign_keys = ON");
-            this.migrate();
-            if (bootNonce !== null) {
-                this.reconcilePriorBootGenerations(bootNonce);
-                this.reconcilePriorBootLaunchInstances(bootNonce);
-            }
-        }
-        catch (error) {
-            this.database.close();
-            throw error;
-        }
-    }
-    migrate() {
-        const versionRow = this.database.prepare("PRAGMA user_version").get();
-        const version = versionRow.user_version;
-        if (version > 5)
-            throw new Error(`control database version ${version} is newer than supported version 5`);
-        if (version !== 0)
-            this.#assertCurrentControlSchema();
-        if (version === 0) {
-            this.database.exec(`
-        BEGIN IMMEDIATE;
-        CREATE TABLE workspaces (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL,
-          selected_agent_id TEXT,
-          created_at TEXT NOT NULL
-        );
-        CREATE TABLE driver_profiles (
-          id TEXT PRIMARY KEY,
-          kind TEXT NOT NULL,
-          profile_json TEXT NOT NULL,
-          created_at TEXT NOT NULL
-        );
-        CREATE TABLE terminal_agents (
-          id TEXT PRIMARY KEY,
-          workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-          name TEXT NOT NULL,
-          profile_id TEXT NOT NULL REFERENCES driver_profiles(id),
-          profile_json TEXT NOT NULL,
-          surface_json TEXT,
-          created_at TEXT NOT NULL
-        );
-        CREATE TABLE process_generations (
-          id TEXT PRIMARY KEY,
-          agent_id TEXT NOT NULL REFERENCES terminal_agents(id) ON DELETE CASCADE,
-          sequence INTEGER NOT NULL,
-          profile_id TEXT NOT NULL REFERENCES driver_profiles(id),
-          state TEXT NOT NULL,
-          capabilities_json TEXT NOT NULL,
-          started_at TEXT NOT NULL,
-          exited_at TEXT,
-          exit_code INTEGER,
-          signal INTEGER,
-          error TEXT,
-          owner_boot_nonce TEXT,
-          UNIQUE(agent_id, sequence)
-        );
-        CREATE INDEX idx_agents_workspace ON terminal_agents(workspace_id, created_at);
-        CREATE INDEX idx_generations_agent ON process_generations(agent_id, sequence DESC);
-        CREATE INDEX idx_generations_owner_boot ON process_generations(owner_boot_nonce, state);
-        PRAGMA user_version = 1;
-        COMMIT;
-      `);
-            const now = new Date().toISOString();
-            this.database.prepare("INSERT INTO workspaces (id, name, selected_agent_id, created_at) VALUES (?, ?, NULL, ?)")
-                .run(INITIAL_WORKSPACE_ID, "Workspace", now);
-        }
-        if (version <= 1) {
-            const columns = this.database.prepare("PRAGMA table_info(process_generations)").all();
-            if (!columns.some(column => column.name === "owner_boot_nonce")) {
-                this.database.exec("ALTER TABLE process_generations ADD COLUMN owner_boot_nonce TEXT");
-            }
-            this.database.exec(`
-        BEGIN IMMEDIATE;
-        CREATE INDEX IF NOT EXISTS idx_generations_owner_boot ON process_generations(owner_boot_nonce, state);
-        CREATE TABLE foreground_terminal_leases (
-          id TEXT PRIMARY KEY,
-          owner_id TEXT NOT NULL,
-          profile_json TEXT NOT NULL,
-          state TEXT NOT NULL,
-          generation_id TEXT,
-          process_identity_json TEXT,
-          acquired_at TEXT NOT NULL,
-          heartbeat_at TEXT,
-          released_at TEXT,
-          outcome_json TEXT,
-          owner_boot_nonce TEXT NOT NULL
-        );
-        CREATE UNIQUE INDEX idx_one_live_foreground_lease ON foreground_terminal_leases((1)) WHERE state IN ('requested', 'active');
-        CREATE INDEX idx_foreground_lease_boot ON foreground_terminal_leases(owner_boot_nonce, state);
-        PRAGMA user_version = 2;
-        COMMIT;
-      `);
-        }
-        if (version <= 2) {
-            this.database.exec(`
-        BEGIN IMMEDIATE;
-        CREATE TABLE workspace_agents (
-          id TEXT PRIMARY KEY,
-          workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-          display_name TEXT NOT NULL,
-          adapter_id TEXT NOT NULL,
-          runtime_kind TEXT NOT NULL CHECK (runtime_kind IN ('structured', 'composed-terminal')),
-          lifecycle TEXT NOT NULL,
-          capability_json TEXT NOT NULL,
-          recovery_reference_id TEXT,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL,
-          CHECK (json_valid(capability_json))
-        );
-        CREATE INDEX idx_workspace_agents_workspace ON workspace_agents(workspace_id, created_at);
-        CREATE INDEX idx_workspace_agents_recovery ON workspace_agents(recovery_reference_id);
-
-        CREATE TABLE native_host_topology (
-          host_instance_id TEXT PRIMARY KEY,
-          protocol_version INTEGER NOT NULL CHECK (protocol_version = 1),
-          revision INTEGER NOT NULL CHECK (revision >= 0),
-          topology_json TEXT NOT NULL CHECK (json_valid(topology_json)),
-          rollback_json TEXT NOT NULL CHECK (json_valid(rollback_json)),
-          updated_at TEXT NOT NULL
-        );
-
-        CREATE TABLE terminal_sessions (
-          id TEXT PRIMARY KEY,
-          host_instance_id TEXT NOT NULL REFERENCES native_host_topology(host_instance_id) ON DELETE CASCADE,
-          pane_id TEXT NOT NULL,
-          lifecycle TEXT NOT NULL,
-          launch_json TEXT NOT NULL CHECK (json_valid(launch_json)),
-          recovery_reference_id TEXT,
-          updated_at TEXT NOT NULL
-        );
-        CREATE UNIQUE INDEX idx_terminal_sessions_pane ON terminal_sessions(host_instance_id, pane_id);
-        CREATE INDEX idx_terminal_sessions_recovery ON terminal_sessions(recovery_reference_id);
-
-        CREATE TABLE recovery_references (
-          id TEXT PRIMARY KEY,
-          agent_id TEXT NOT NULL REFERENCES workspace_agents(id) ON DELETE CASCADE,
-          authority_json TEXT NOT NULL CHECK (json_valid(authority_json)),
-          status TEXT NOT NULL CHECK (status IN ('pending', 'accepted', 'rejected', 'discontinuous')),
-          rollback_json TEXT NOT NULL CHECK (json_valid(rollback_json)),
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        );
-        CREATE INDEX idx_recovery_references_agent ON recovery_references(agent_id, status);
-        PRAGMA user_version = 3;
-        COMMIT;
-      `);
-        }
-        if (version <= 3) {
-            this.database.exec(`
-        BEGIN IMMEDIATE;
-        ALTER TABLE workspace_agents ADD COLUMN unread_count INTEGER NOT NULL DEFAULT 0 CHECK (unread_count >= 0);
-        ALTER TABLE workspace_agents ADD COLUMN attention INTEGER NOT NULL DEFAULT 0 CHECK (attention IN (0, 1));
-        ALTER TABLE workspace_agents ADD COLUMN failure_json TEXT CHECK (failure_json IS NULL OR json_valid(failure_json));
-        ALTER TABLE workspaces ADD COLUMN revision INTEGER NOT NULL DEFAULT 0 CHECK (revision >= 0);
-        PRAGMA user_version = 4;
-        COMMIT;
-      `);
-        }
-        if (version <= 4) {
-            this.database.exec(`
-        BEGIN IMMEDIATE;
-        UPDATE foreground_terminal_leases
-          SET state = 'interrupted',
-              released_at = COALESCE(released_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-              outcome_json = '{"kind":"interrupted","reason":"legacy-migration","message":"legacy foreground ownership cannot prove current launch-instance liveness"}'
-          WHERE state IN ('requested', 'active');
-        DROP INDEX IF EXISTS idx_one_live_foreground_lease;
-        CREATE TABLE launch_instances (
-          id TEXT PRIMARY KEY,
-          owner_client_id TEXT NOT NULL,
-          profile_id TEXT NOT NULL CHECK (profile_id IN ('a1', 'pi', 'sandbox')),
-          state TEXT NOT NULL CHECK (state IN ('requested', 'active', 'stopping', 'completed', 'interrupted')),
-          shutdown_policy TEXT NOT NULL CHECK (shutdown_policy = 'terminate-tree-on-close'),
-          guardian_identity_json TEXT NOT NULL CHECK (json_valid(guardian_identity_json)),
-          root_identity_json TEXT CHECK (root_identity_json IS NULL OR json_valid(root_identity_json)),
-          containment_identity_json TEXT CHECK (containment_identity_json IS NULL OR json_valid(containment_identity_json)),
-          created_at TEXT NOT NULL,
-          activated_at TEXT,
-          stopping_at TEXT,
-          completed_at TEXT,
-          outcome_json TEXT CHECK (outcome_json IS NULL OR json_valid(outcome_json)),
-          owner_boot_nonce TEXT NOT NULL,
-          CHECK ((state = 'requested' AND root_identity_json IS NULL AND containment_identity_json IS NULL AND activated_at IS NULL AND stopping_at IS NULL AND completed_at IS NULL AND outcome_json IS NULL)
-            OR (state = 'active' AND root_identity_json IS NOT NULL AND containment_identity_json IS NOT NULL AND activated_at IS NOT NULL AND stopping_at IS NULL AND completed_at IS NULL AND outcome_json IS NULL)
-            OR (state = 'stopping' AND root_identity_json IS NOT NULL AND containment_identity_json IS NOT NULL AND activated_at IS NOT NULL AND stopping_at IS NOT NULL AND completed_at IS NULL AND outcome_json IS NULL)
-            OR (state IN ('completed', 'interrupted') AND completed_at IS NOT NULL AND outcome_json IS NOT NULL))
-        );
-        CREATE INDEX idx_launch_instances_owner ON launch_instances(owner_client_id, state);
-        CREATE INDEX idx_launch_instances_boot ON launch_instances(owner_boot_nonce, state);
-        PRAGMA user_version = 5;
-        COMMIT;
-      `);
-        }
-        if (version === 0) {
-            this.database.exec("CREATE TABLE product_identity (schema TEXT PRIMARY KEY NOT NULL)");
-            this.database.prepare("INSERT INTO product_identity (schema) VALUES (?)").run(PRODUCT_IDENTITY.protocol.controlStoreSchema);
-        }
-    }
-    #assertCurrentControlSchema() {
-        const table = this.database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'product_identity'").get();
-        if (!table)
-            throw new Error("control database has no A1 product schema; legacy state is unsupported");
-        const identity = this.database.prepare("SELECT schema FROM product_identity").get();
-        if (identity?.schema !== PRODUCT_IDENTITY.protocol.controlStoreSchema) {
-            throw new Error(`control database schema ${String(identity?.schema)} is unsupported; expected ${PRODUCT_IDENTITY.protocol.controlStoreSchema}`);
-        }
-    }
-    reconcilePriorBootGenerations(bootNonce) {
-        const now = new Date().toISOString();
-        return this.#transaction(() => {
-            const result = this.database.prepare(`UPDATE process_generations
-        SET state = 'interrupted', exited_at = ?, error = COALESCE(error, 'supervisor ownership ended before a terminal outcome')
-        WHERE state NOT IN ('exited', 'stopped', 'interrupted', 'error')
-          AND (owner_boot_nonce IS NULL OR owner_boot_nonce <> ?)`)
-                .run(now, bootNonce);
-            return Number(result.changes);
-        });
-    }
-    createLaunchInstance(instance) {
-        if (this.bootNonce === null)
-            throw new Error("launch instance storage requires a supervisor boot identity");
-        assertLaunchInstance(instance);
-        if (instance.state !== "requested")
-            throw new Error("new launch instance must be requested");
-        this.database.prepare(`INSERT INTO launch_instances
-      (id, owner_client_id, profile_id, state, shutdown_policy, guardian_identity_json, root_identity_json, containment_identity_json,
-       created_at, activated_at, stopping_at, completed_at, outcome_json, owner_boot_nonce)
-      VALUES (?, ?, ?, 'requested', ?, ?, NULL, NULL, ?, NULL, NULL, NULL, NULL, ?)`)
-            .run(instance.id, instance.ownerClientId, instance.profileId, instance.shutdownPolicy, JSON.stringify(instance.guardianIdentity), instance.createdAt, this.bootNonce);
-    }
-    activateLaunchInstance(instanceId, ownerClientId, rootIdentity, containmentIdentity, activatedAt) {
-        if (this.bootNonce === null)
-            throw new Error("launch instance storage requires a supervisor boot identity");
-        assertNativeProcessIdentity(rootIdentity);
-        assertProcessContainmentIdentity(containmentIdentity);
-        const result = this.database.prepare(`UPDATE launch_instances
-      SET state = 'active', root_identity_json = ?, containment_identity_json = ?, activated_at = ?
-      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state = 'requested'`)
-            .run(JSON.stringify(rootIdentity), JSON.stringify(containmentIdentity), activatedAt, instanceId, ownerClientId, this.bootNonce);
-        return Number(result.changes) === 1;
-    }
-    beginLaunchInstanceStop(instanceId, ownerClientId, stoppingAt) {
-        if (this.bootNonce === null)
-            throw new Error("launch instance storage requires a supervisor boot identity");
-        const result = this.database.prepare(`UPDATE launch_instances SET state = 'stopping', stopping_at = ?
-      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state = 'active'`)
-            .run(stoppingAt, instanceId, ownerClientId, this.bootNonce);
-        return Number(result.changes) === 1;
-    }
-    completeLaunchInstance(instanceId, ownerClientId, terminalState, outcome, completedAt) {
-        if (this.bootNonce === null)
-            throw new Error("launch instance storage requires a supervisor boot identity");
-        assertLaunchInstanceOutcome(outcome);
-        if (terminalState === "completed" && outcome.kind === "interrupted")
-            throw new Error("completed launch instance cannot carry an interrupted outcome");
-        if (terminalState === "interrupted" && outcome.kind !== "interrupted" && outcome.kind !== "cleanup-error") {
-            throw new Error("interrupted launch instance requires an interrupted or cleanup-error outcome");
-        }
-        const result = this.database.prepare(`UPDATE launch_instances
-      SET state = ?, completed_at = ?, outcome_json = ?
-      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state IN ('requested', 'active', 'stopping')`)
-            .run(terminalState, completedAt, JSON.stringify(outcome), instanceId, ownerClientId, this.bootNonce);
-        return Number(result.changes) === 1;
-    }
-    loadActiveLaunchInstances() {
-        return this.database.prepare(`SELECT * FROM launch_instances
-      WHERE state IN ('requested', 'active', 'stopping') ORDER BY created_at, id`).all()
-            .map(launchInstanceFromRow);
-    }
-    loadLaunchInstance(instanceId) {
-        const row = this.database.prepare("SELECT * FROM launch_instances WHERE id = ?").get(instanceId);
-        return row ? launchInstanceFromRow(row) : null;
-    }
-    reconcilePriorBootLaunchInstances(bootNonce, reconciledAt = new Date().toISOString()) {
-        const outcome = {
-            kind: "interrupted",
-            reason: "supervisor-disconnect",
-            message: "launch instance ownership ended with a prior supervisor boot",
-        };
-        const result = this.database.prepare(`UPDATE launch_instances
-      SET state = 'interrupted', completed_at = ?, outcome_json = ?
-      WHERE state IN ('requested', 'active', 'stopping') AND owner_boot_nonce <> ?`)
-            .run(reconciledAt, JSON.stringify(outcome), bootNonce);
-        return Number(result.changes);
-    }
-    persistWorkspaceAgent(agent, updatedAt = new Date().toISOString()) {
-        const existing = this.loadWorkspaceAgentRecord(agent.id);
-        this.persistWorkspaceAgentRecord({
-            agent,
-            presentation: existing?.presentation ?? { unreadActivity: 0, attention: false, failure: null },
-        }, updatedAt);
-    }
-    persistWorkspaceAgentRecord(record, updatedAt = new Date().toISOString()) {
-        assertManagedAgentDescriptor(record.agent);
-        assertWorkspaceAgentPresentation(record.presentation);
-        this.#upsertWorkspaceAgentRecord(record, updatedAt);
-    }
-    replaceWorkspaceAgentRecords(records, selectedAgentId, revision, updatedAt = new Date().toISOString()) {
-        if (!Number.isSafeInteger(revision) || revision < 0)
-            throw new RangeError("workspace revision must be a non-negative safe integer");
-        const ids = new Set();
-        for (const record of records) {
-            assertManagedAgentDescriptor(record.agent);
-            assertWorkspaceAgentPresentation(record.presentation);
-            if (ids.has(record.agent.id))
-                throw new TypeError(`duplicate workspace agent id: ${record.agent.id}`);
-            ids.add(record.agent.id);
-        }
-        if (selectedAgentId !== null && !ids.has(selectedAgentId))
-            throw new TypeError("selected workspace agent must exist in the replacement set");
-        this.#transaction(() => {
-            if (records.length === 0)
-                this.database.prepare("DELETE FROM workspace_agents").run();
-            else {
-                const placeholders = records.map(() => "?").join(", ");
-                this.database.prepare(`DELETE FROM workspace_agents WHERE id NOT IN (${placeholders})`).run(...records.map(record => record.agent.id));
-            }
-            for (const record of records)
-                this.#upsertWorkspaceAgentRecord(record, updatedAt);
-            this.database.prepare("UPDATE workspaces SET selected_agent_id = ?, revision = ? WHERE id = ?").run(selectedAgentId, revision, INITIAL_WORKSPACE_ID);
-        });
-    }
-    loadWorkspaceAgents() {
-        return this.loadWorkspaceAgentRecords().map(record => record.agent);
-    }
-    loadWorkspaceAgentRecord(agentId) {
-        const row = this.database.prepare("SELECT * FROM workspace_agents WHERE id = ?").get(agentId);
-        return row ? workspaceAgentFromRow(row) : null;
-    }
-    loadWorkspaceAgentRecords() {
-        const rows = this.database.prepare("SELECT * FROM workspace_agents ORDER BY created_at, id").all();
-        return rows.map(workspaceAgentFromRow);
-    }
-    loadSelectedWorkspaceAgentId() {
-        const row = this.database.prepare("SELECT selected_agent_id FROM workspaces WHERE id = ?").get(INITIAL_WORKSPACE_ID);
-        return row?.selected_agent_id ?? null;
-    }
-    loadWorkspaceRevision() {
-        const row = this.database.prepare("SELECT revision FROM workspaces WHERE id = ?").get(INITIAL_WORKSPACE_ID);
-        return row?.revision ?? 0;
-    }
-    #upsertWorkspaceAgentRecord(record, updatedAt) {
-        const agent = record.agent;
-        this.database.prepare(`INSERT INTO workspace_agents
-      (id, workspace_id, display_name, adapter_id, runtime_kind, lifecycle, capability_json, recovery_reference_id, unread_count, attention, failure_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        workspace_id = excluded.workspace_id,
-        display_name = excluded.display_name,
-        adapter_id = excluded.adapter_id,
-        runtime_kind = excluded.runtime_kind,
-        lifecycle = excluded.lifecycle,
-        capability_json = excluded.capability_json,
-        recovery_reference_id = excluded.recovery_reference_id,
-        unread_count = excluded.unread_count,
-        attention = excluded.attention,
-        failure_json = excluded.failure_json,
-        updated_at = excluded.updated_at`)
-            .run(agent.id, INITIAL_WORKSPACE_ID, agent.displayName, agent.adapterId, agent.runtime, agent.lifecycle, JSON.stringify(agent.capability), agent.recoveryReferenceId, record.presentation.unreadActivity, record.presentation.attention ? 1 : 0, record.presentation.failure === null ? null : JSON.stringify(record.presentation.failure), agent.createdAt, updatedAt);
-    }
-    saveNativeHostTopology(topology, rollbackTopology, updatedAt = new Date().toISOString()) {
-        assertTerminalTopologySnapshot(topology);
-        if (rollbackTopology !== null)
-            assertTerminalTopologySnapshot(rollbackTopology);
-        if (rollbackTopology !== null && rollbackTopology.hostInstanceId !== topology.hostInstanceId) {
-            throw new TypeError("topology rollback metadata must identify the same native host");
-        }
-        const prior = this.loadNativeHostTopology(topology.hostInstanceId);
-        if (prior !== null && topology.revision < prior.topology.revision) {
-            throw new RangeError(`stale native-host topology revision ${topology.revision}; persisted revision is ${prior.topology.revision}`);
-        }
-        if (rollbackTopology !== null && rollbackTopology.revision > topology.revision) {
-            throw new RangeError("topology rollback revision cannot be newer than the persisted topology");
-        }
-        const rollbackJson = rollbackTopology === null
-            ? JSON.stringify({ contractVersion: 1, reason: "initial native-host topology", topology: null })
-            : JSON.stringify({ contractVersion: 1, reason: "backward-readable prior authoritative topology", topology: rollbackTopology });
-        this.database.prepare(`INSERT INTO native_host_topology
-      (host_instance_id, protocol_version, revision, topology_json, rollback_json, updated_at)
-      VALUES (?, 1, ?, ?, ?, ?)
-      ON CONFLICT(host_instance_id) DO UPDATE SET
-        revision = excluded.revision,
-        topology_json = excluded.topology_json,
-        rollback_json = excluded.rollback_json,
-        updated_at = excluded.updated_at`)
-            .run(topology.hostInstanceId, topology.revision, JSON.stringify(topology), rollbackJson, updatedAt);
-    }
-    loadNativeHostTopology(hostInstanceId) {
-        const row = this.database.prepare("SELECT * FROM native_host_topology WHERE host_instance_id = ?").get(hostInstanceId);
-        if (!row)
-            return null;
-        const topology = JSON.parse(row.topology_json);
-        assertTerminalTopologySnapshot(topology);
-        return { topology, rollback: JSON.parse(row.rollback_json), updatedAt: row.updated_at };
-    }
-    persistTerminalSession(session, hostInstanceId, paneId, lifecycle, recoveryReferenceId, updatedAt = new Date().toISOString()) {
-        assertTerminalSessionLaunch(session);
-        this.database.prepare(`INSERT INTO terminal_sessions
-      (id, host_instance_id, pane_id, lifecycle, launch_json, recovery_reference_id, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        host_instance_id = excluded.host_instance_id,
-        pane_id = excluded.pane_id,
-        lifecycle = excluded.lifecycle,
-        launch_json = excluded.launch_json,
-        recovery_reference_id = excluded.recovery_reference_id,
-        updated_at = excluded.updated_at`)
-            .run(session.id, hostInstanceId, paneId, lifecycle, JSON.stringify(session), recoveryReferenceId, updatedAt);
-    }
-    loadTerminalSessions() {
-        const rows = this.database.prepare("SELECT * FROM terminal_sessions ORDER BY id").all();
-        return rows.map(row => {
-            const session = JSON.parse(row.launch_json);
-            assertTerminalSessionLaunch(session);
-            return { session, hostInstanceId: row.host_instance_id, paneId: row.pane_id, lifecycle: row.lifecycle, recoveryReferenceId: row.recovery_reference_id };
-        });
-    }
-    persistRecoveryReference(authority, status, rollbackMetadata, updatedAt = new Date().toISOString()) {
-        assertRecoveryAuthority(authority);
-        const createdAt = typeof rollbackMetadata.createdAt === "string" ? rollbackMetadata.createdAt : updatedAt;
-        const rollbackJson = JSON.stringify({ contractVersion: 1, ...rollbackMetadata });
-        this.database.prepare(`INSERT INTO recovery_references
-      (id, agent_id, authority_json, status, rollback_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        agent_id = excluded.agent_id,
-        authority_json = excluded.authority_json,
-        status = excluded.status,
-        rollback_json = excluded.rollback_json,
-        updated_at = excluded.updated_at`)
-            .run(authority.referenceId, authority.agentId, JSON.stringify(authority), status, rollbackJson, createdAt, updatedAt);
-    }
-    loadRecoveryReference(id) {
-        const row = this.database.prepare("SELECT * FROM recovery_references WHERE id = ?").get(id);
-        if (!row)
-            return null;
-        const authority = JSON.parse(row.authority_json);
-        assertRecoveryAuthority(authority);
-        return { authority, status: row.status, rollback: JSON.parse(row.rollback_json), updatedAt: row.updated_at };
-    }
-    close() {
-        this.database.close();
-    }
-    #transaction(operation) {
-        this.database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = operation();
-            this.database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            this.database.exec("ROLLBACK");
-            throw error;
-        }
-    }
-}
-function workspaceAgentFromRow(row) {
-    const descriptor = {
-        id: row.id,
-        displayName: row.display_name,
-        adapterId: row.adapter_id,
-        runtime: row.runtime_kind,
-        lifecycle: row.lifecycle,
-        capability: JSON.parse(row.capability_json),
-        createdAt: row.created_at,
-        recoveryReferenceId: row.recovery_reference_id,
-    };
-    assertManagedAgentDescriptor(descriptor);
-    const failure = row.failure_json === null ? null : JSON.parse(row.failure_json);
-    const presentation = {
-        unreadActivity: row.unread_count,
-        attention: row.attention === 1,
-        failure,
-    };
-    assertWorkspaceAgentPresentation(presentation);
-    return { agent: descriptor, presentation };
-}
-function assertWorkspaceAgentPresentation(presentation) {
-    if (!Number.isSafeInteger(presentation.unreadActivity) || presentation.unreadActivity < 0) {
-        throw new RangeError("workspace unread activity must be a non-negative safe integer");
-    }
-    if (typeof presentation.attention !== "boolean")
-        throw new TypeError("workspace attention must be boolean");
-    if (presentation.failure !== null) {
-        if (!presentation.failure.code || presentation.failure.code.length > 128 || presentation.failure.code.includes("\0")) {
-            throw new TypeError("workspace failure code is invalid");
-        }
-        if (!presentation.failure.message || presentation.failure.message.length > 4_096 || presentation.failure.message.includes("\0")) {
-            throw new TypeError("workspace failure message is invalid");
-        }
-    }
-}
-function launchInstanceFromRow(row) {
-    const instance = {
-        id: row.id,
-        ownerClientId: row.owner_client_id,
-        profileId: row.profile_id,
-        state: row.state,
-        shutdownPolicy: row.shutdown_policy,
-        guardianIdentity: JSON.parse(row.guardian_identity_json),
-        rootIdentity: row.root_identity_json ? JSON.parse(row.root_identity_json) : null,
-        containmentIdentity: row.containment_identity_json ? JSON.parse(row.containment_identity_json) : null,
-        createdAt: row.created_at,
-        activatedAt: row.activated_at,
-        stoppingAt: row.stopping_at,
-        completedAt: row.completed_at,
-        outcome: row.outcome_json ? JSON.parse(row.outcome_json) : null,
-    };
-    assertLaunchInstance(instance);
-    return instance;
-}

package/dist/src/foundation/storage/index.d.ts

@@ -1 +0,0 @@
-export * from "./control-store.js";

package/dist/src/foundation/storage/index.js

@@ -1 +0,0 @@
-export * from "./control-store.js";

package/dist/src/foundation/structured-agent-runtime/backpressure.d.ts

@@ -1,46 +0,0 @@
-import { type StructuredCapabilityContract } from "../workspace-contracts/index.js";
-export type StructuredBackpressureResource = "events" | "commands" | "snapshots" | "attachments" | "reconnect-replay";
-export type StructuredBackpressureAction = "none" | "reject-payload" | "pause-adapter" | "reject-request" | "disconnect-adapter";
-export interface StructuredResourceLease {
-    readonly id: string;
-    readonly resource: StructuredBackpressureResource;
-    readonly units: number;
-    readonly bytes: number;
-}
-export interface StructuredResourceUsage {
-    readonly resource: StructuredBackpressureResource;
-    readonly units: number;
-    readonly bytes: number;
-    readonly unitLimit: number;
-    readonly byteLimit: number;
-}
-export type StructuredBackpressureAcquireResult = {
-    readonly kind: "accepted";
-    readonly lease: StructuredResourceLease;
-    readonly usage: StructuredResourceUsage;
-} | {
-    readonly kind: "rejected";
-    readonly code: "invalid-request" | "payload-too-large" | "resource-exhausted" | "replay-exhausted";
-    readonly action: Exclude<StructuredBackpressureAction, "none">;
-    readonly usage: StructuredResourceUsage;
-    readonly diagnostic: string;
-};
-export type StructuredBackpressureReleaseResult = {
-    readonly kind: "released";
-    readonly usage: StructuredResourceUsage;
-} | {
-    readonly kind: "rejected";
-    readonly code: "unknown-lease" | "invalid-request";
-    readonly diagnostic: string;
-};
-export declare class StructuredBackpressureController {
-    #private;
-    readonly adapterId: string;
-    constructor(adapterId: string, capability: StructuredCapabilityContract);
-    acquire(resource: StructuredBackpressureResource, units?: number, bytes?: number): StructuredBackpressureAcquireResult;
-    release(lease: StructuredResourceLease): StructuredBackpressureReleaseResult;
-    resetReconnectReplay(): void;
-    usage(resource: StructuredBackpressureResource): StructuredResourceUsage;
-    leaseCount(): number;
-    replayExhausted(): boolean;
-}