@pasko70/pibo 1.1.0 → 1.3.0

package/dist/apps/chat/data/project-service.js

@@ -0,0 +1,844 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { piboHomePath } from "../../../core/pibo-home.js";
+export class ChatProjectService {
+    path;
+    db;
+    constructor(path = piboHomePath("web-projects.sqlite")) {
+        this.path = resolve(path);
+        mkdirSync(dirname(this.path), { recursive: true });
+        this.db = new DatabaseSync(this.path);
+        this.db.exec("PRAGMA busy_timeout = 5000");
+        this.db.exec("PRAGMA foreign_keys = ON");
+        this.db.exec("PRAGMA journal_mode = WAL");
+        this.applySchema();
+    }
+    close() {
+        this.db.close();
+    }
+    ensureSharedDefaultProject(input = {}) {
+        const id = sharedDefaultProjectId();
+        const existing = this.getProject(id, { includeArchived: true });
+        if (existing)
+            return existing;
+        const folder = resolve(input.projectFolder ?? piboHomePath("projects/workspace"));
+        mkdirSync(folder, { recursive: true });
+        const now = new Date().toISOString();
+        this.db.prepare(`INSERT INTO projects (id, name, description, project_folder, configuration_status, metadata_json, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, "Shared Project", null, folder, "configured", JSON.stringify({ default: true }), now, now);
+        return this.requireProject(id);
+    }
+    listProjects(options = {}) {
+        const rows = this.db.prepare(`SELECT * FROM projects WHERE json_extract(metadata_json, '$.personal') IS NOT 1 ${options.includeArchived ? "" : "AND archived_at IS NULL"} ORDER BY lower(name), created_at`).all();
+        return rows.map(projectFromRow);
+    }
+    getProject(id, options = {}) {
+        const row = this.db.prepare(`SELECT * FROM projects WHERE id = ? ${options.includeArchived ? "" : "AND archived_at IS NULL"}`).get(id);
+        return row ? projectFromRow(row) : undefined;
+    }
+    requireProject(id, options = {}) {
+        const project = this.getProject(id, options);
+        if (!project)
+            throw new Error("Project not found");
+        return project;
+    }
+    createProject(input) {
+        const name = normalizeProjectName(input.name);
+        const projectFolder = resolve(normalizeProjectFolder(input.projectFolder));
+        this.assertNameAvailable(name);
+        this.assertFolderAvailable(projectFolder);
+        if (input.createFolder)
+            mkdirSync(projectFolder, { recursive: true });
+        const now = new Date().toISOString();
+        const id = `prj_${randomUUID()}`;
+        this.db.prepare(`INSERT INTO projects (id, name, description, project_folder, configuration_status, metadata_json, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, name, normalizeOptionalString(input.description) ?? null, projectFolder, "configured", "{}", now, now);
+        return this.requireProject(id);
+    }
+    updateProject(id, input) {
+        const existing = this.getProject(id, { includeArchived: true });
+        if (!existing)
+            return undefined;
+        const name = input.name === undefined ? existing.name : normalizeProjectName(input.name);
+        if (name !== existing.name)
+            this.assertNameAvailable(name, id);
+        const description = input.description === undefined ? existing.description : normalizeOptionalString(input.description ?? undefined);
+        const archivedAt = input.archived === undefined ? existing.archivedAt : input.archived ? (existing.archivedAt ?? new Date().toISOString()) : undefined;
+        const now = new Date().toISOString();
+        this.db.prepare(`UPDATE projects SET name = ?, description = ?, archived_at = ?, updated_at = ? WHERE id = ?`).run(name, description ?? null, archivedAt ?? null, now, id);
+        return this.getProject(id, { includeArchived: true });
+    }
+    deleteProject(id, options) {
+        const project = this.requireProject(id, { includeArchived: true });
+        if (!project.archivedAt)
+            throw new Error("Archive the project before permanently deleting it.");
+        if (options.confirmName !== project.name)
+            throw new Error(`Type \"${project.name}\" to permanently delete this project.`);
+        this.db.prepare("DELETE FROM project_sessions WHERE project_id = ?").run(id);
+        this.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+        if (options.deleteFiles)
+            rmSync(project.projectFolder, { recursive: true, force: true });
+        return { deletedProjectId: id };
+    }
+    listProjectSessions(projectId, options = {}) {
+        const rows = this.db.prepare(`SELECT * FROM project_sessions WHERE project_id = ? ${options.includeArchived ? "" : "AND archived = 0"} ORDER BY created_at`).all(projectId);
+        return rows.map(projectSessionFromRow);
+    }
+    getProjectSession(piboSessionId) {
+        const row = this.db.prepare("SELECT * FROM project_sessions WHERE pibo_session_id = ?").get(piboSessionId);
+        return row ? projectSessionFromRow(row) : undefined;
+    }
+    addProjectSession(input) {
+        const existing = this.getProjectSession(input.piboSessionId);
+        const now = new Date().toISOString();
+        const kind = input.kind ?? existing?.kind ?? "main";
+        const workflowId = input.workflowId ?? existing?.workflowId ?? "simple-chat";
+        const workflowVersion = input.workflowVersion === undefined ? existing?.workflowVersion : normalizeOptionalString(input.workflowVersion);
+        const workflowRunId = input.workflowRunId ?? existing?.workflowRunId;
+        const parentMainSessionId = input.parentMainSessionId ?? existing?.parentMainSessionId;
+        const title = input.title === undefined ? existing?.title : input.title;
+        const state = input.state === undefined ? (existing?.state ?? "simple_chat") : normalizeProjectSessionState(input.state);
+        const configuration = input.configuration ?? existing?.configuration;
+        if (existing) {
+            assertProjectSessionImmutableFields(existing, {
+                projectId: input.projectId,
+                kind,
+                workflowId,
+                workflowVersion,
+                workflowRunId,
+                configuration,
+            });
+        }
+        this.db.prepare(`INSERT INTO project_sessions (project_id, pibo_session_id, kind, workflow_id, workflow_version, workflow_run_id, parent_main_session_id, title, state, configuration_json, archived, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+			ON CONFLICT(pibo_session_id) DO UPDATE SET project_id = excluded.project_id, kind = excluded.kind, workflow_id = excluded.workflow_id, workflow_version = excluded.workflow_version, workflow_run_id = excluded.workflow_run_id, parent_main_session_id = excluded.parent_main_session_id, title = excluded.title, state = excluded.state, configuration_json = excluded.configuration_json, updated_at = excluded.updated_at`)
+            .run(input.projectId, input.piboSessionId, kind, workflowId, workflowVersion ?? null, workflowRunId ?? null, parentMainSessionId ?? null, title ?? null, state, serializeProjectSessionConfiguration(configuration), now, now);
+        if (kind === "main") {
+            this.db.prepare("UPDATE projects SET current_main_session_id = ?, updated_at = ? WHERE id = ?").run(input.piboSessionId, now, input.projectId);
+        }
+        return this.getProjectSession(input.piboSessionId);
+    }
+    linkWorkflowRunSession(input) {
+        return this.addProjectSession({
+            projectId: input.projectId,
+            piboSessionId: input.piboSessionId,
+            kind: input.parentMainSessionId ? "sub" : "main",
+            workflowId: input.workflowId,
+            workflowVersion: input.workflowVersion,
+            workflowRunId: input.workflowRunId,
+            parentMainSessionId: input.parentMainSessionId,
+            title: input.title,
+            state: "workflow",
+        });
+    }
+    saveWorkflowSessionSnapshot(snapshot) {
+        const existing = this.getWorkflowSessionSnapshot(snapshot.id);
+        if (existing) {
+            if (existing.piboSessionId !== snapshot.piboSessionId || existing.workflow.effectiveDefinitionHash !== snapshot.workflow.effectiveDefinitionHash) {
+                throw new Error("Workflow session snapshots are immutable");
+            }
+            return existing;
+        }
+        const existingForSession = this.getWorkflowSessionSnapshotForSession(snapshot.piboSessionId);
+        if (existingForSession)
+            throw new Error(`Project workflow session '${snapshot.piboSessionId}' already has a configuration snapshot`);
+        this.db.prepare(`INSERT INTO project_workflow_session_snapshots (id, schema_version, project_id, pibo_session_id, workflow_id, workflow_version, base_definition_hash, effective_definition_hash, snapshot_json, created_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(snapshot.id, snapshot.schemaVersion, snapshot.projectId, snapshot.piboSessionId, snapshot.workflow.id, snapshot.workflow.version, snapshot.workflow.baseDefinitionHash, snapshot.workflow.effectiveDefinitionHash, JSON.stringify(snapshot), snapshot.createdAt);
+        return this.getWorkflowSessionSnapshot(snapshot.id);
+    }
+    getWorkflowSessionSnapshot(id) {
+        const row = this.db.prepare("SELECT * FROM project_workflow_session_snapshots WHERE id = ?").get(id);
+        return row ? workflowSessionSnapshotFromRow(row) : undefined;
+    }
+    getWorkflowSessionSnapshotForSession(piboSessionId) {
+        const row = this.db.prepare("SELECT * FROM project_workflow_session_snapshots WHERE pibo_session_id = ?").get(piboSessionId);
+        return row ? workflowSessionSnapshotFromRow(row) : undefined;
+    }
+    getProjectWorkflowRun(runId) {
+        const row = this.db.prepare("SELECT * FROM project_workflow_runs WHERE id = ?").get(runId);
+        return row ? projectWorkflowRunFromRow(row) : undefined;
+    }
+    getProjectWorkflowRunForSession(piboSessionId) {
+        const row = this.db.prepare("SELECT * FROM project_workflow_runs WHERE pibo_session_id = ?").get(piboSessionId);
+        return row ? projectWorkflowRunFromRow(row) : undefined;
+    }
+    listProjectWorkflowRuns(filter = {}) {
+        const clauses = [];
+        const values = [];
+        if (filter.projectId) {
+            clauses.push("project_id = ?");
+            values.push(filter.projectId);
+        }
+        if (filter.piboSessionId) {
+            clauses.push("pibo_session_id = ?");
+            values.push(filter.piboSessionId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(filter.limit ?? 100, 500));
+        const rows = this.db.prepare(`SELECT * FROM project_workflow_runs ${where} ORDER BY created_at DESC, id DESC LIMIT ?`).all(...values, limit);
+        return rows.map(projectWorkflowRunFromRow);
+    }
+    saveProjectWorkflowWaitToken(token) {
+        this.db.prepare(`INSERT INTO project_workflow_wait_tokens (
+			id,
+			project_id,
+			pibo_session_id,
+			workflow_run_id,
+			node_attempt_id,
+			human_node_id,
+			actions_json,
+			prompt,
+			schema_json,
+			status,
+			resume_payload_json,
+			resume_payload_present,
+			expires_at,
+			created_at,
+			resolved_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			project_id = excluded.project_id,
+			pibo_session_id = excluded.pibo_session_id,
+			workflow_run_id = excluded.workflow_run_id,
+			node_attempt_id = excluded.node_attempt_id,
+			human_node_id = excluded.human_node_id,
+			actions_json = excluded.actions_json,
+			prompt = excluded.prompt,
+			schema_json = excluded.schema_json,
+			status = excluded.status,
+			resume_payload_json = excluded.resume_payload_json,
+			resume_payload_present = excluded.resume_payload_present,
+			expires_at = excluded.expires_at,
+			resolved_at = excluded.resolved_at`).run(token.id, token.projectId, token.piboSessionId, token.workflowRunId, token.nodeAttemptId ?? null, token.humanNodeId ?? null, JSON.stringify(token.actions), token.prompt, token.schema ? JSON.stringify(token.schema) : null, token.status, token.resumePayload === undefined ? null : JSON.stringify(token.resumePayload), token.resumePayload === undefined ? 0 : 1, token.expiresAt ?? null, token.createdAt, token.resolvedAt ?? null);
+        if (token.status === "pending") {
+            const now = new Date().toISOString();
+            this.db.prepare("UPDATE project_workflow_runs SET status = 'waiting', updated_at = ? WHERE id = ? AND project_id = ? AND pibo_session_id = ?").run(now, token.workflowRunId, token.projectId, token.piboSessionId);
+            this.db.prepare("UPDATE project_sessions SET state = 'waiting', updated_at = ? WHERE pibo_session_id = ? AND project_id = ?").run(now, token.piboSessionId, token.projectId);
+        }
+        return this.getProjectWorkflowWaitToken(token.id);
+    }
+    getProjectWorkflowWaitToken(waitTokenId) {
+        const row = this.db.prepare("SELECT * FROM project_workflow_wait_tokens WHERE id = ?").get(waitTokenId);
+        return row ? projectWorkflowWaitTokenFromRow(row) : undefined;
+    }
+    listProjectWorkflowWaitTokens(filter = {}) {
+        const clauses = [];
+        const values = [];
+        if (filter.projectId) {
+            clauses.push("project_id = ?");
+            values.push(filter.projectId);
+        }
+        if (filter.piboSessionId) {
+            clauses.push("pibo_session_id = ?");
+            values.push(filter.piboSessionId);
+        }
+        if (filter.workflowRunId) {
+            clauses.push("workflow_run_id = ?");
+            values.push(filter.workflowRunId);
+        }
+        if (filter.status) {
+            clauses.push("status = ?");
+            values.push(filter.status);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(filter.limit ?? 100, 500));
+        const rows = this.db.prepare(`SELECT * FROM project_workflow_wait_tokens ${where} ORDER BY created_at DESC, id DESC LIMIT ?`).all(...values, limit);
+        return rows.map(projectWorkflowWaitTokenFromRow);
+    }
+    listProjectWorkflowHumanActions(filter = {}) {
+        const clauses = [];
+        const values = [];
+        if (filter.projectId) {
+            clauses.push("project_id = ?");
+            values.push(filter.projectId);
+        }
+        if (filter.piboSessionId) {
+            clauses.push("pibo_session_id = ?");
+            values.push(filter.piboSessionId);
+        }
+        if (filter.workflowRunId) {
+            clauses.push("workflow_run_id = ?");
+            values.push(filter.workflowRunId);
+        }
+        if (filter.waitTokenId) {
+            clauses.push("wait_token_id = ?");
+            values.push(filter.waitTokenId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(filter.limit ?? 100, 500));
+        const rows = this.db.prepare(`SELECT * FROM project_workflow_human_actions ${where} ORDER BY created_at ASC, id ASC LIMIT ?`).all(...values, limit);
+        return rows.map(projectWorkflowHumanActionFromRow);
+    }
+    resolveProjectWorkflowHumanAction(input) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const token = this.getProjectWorkflowWaitToken(input.waitTokenId);
+            if (!token)
+                throw new Error("Workflow wait token not found");
+            if (token.projectId !== input.projectId || token.piboSessionId !== input.piboSessionId || token.workflowRunId !== input.workflowRunId) {
+                throw new Error("Workflow wait token does not belong to this Project workflow session");
+            }
+            if (token.status !== "pending")
+                throw new Error(`Workflow wait token is ${token.status} and cannot be resolved again`);
+            const actedAt = input.actedAt ?? new Date().toISOString();
+            if (token.expiresAt && Date.parse(token.expiresAt) <= Date.parse(actedAt)) {
+                this.db.prepare("UPDATE project_workflow_wait_tokens SET status = 'expired', resolved_at = ? WHERE id = ?").run(actedAt, token.id);
+                this.db.exec("COMMIT");
+                throw new Error(`Workflow wait token expired at ${token.expiresAt}`);
+            }
+            const actionRef = input.actionId
+                ? token.actions.find((action) => action.id === input.actionId)
+                : token.actions.find((action) => action.kind === input.kind);
+            if (!actionRef)
+                throw new Error("Workflow wait token does not offer the requested human action");
+            if (actionRef.kind && actionRef.kind !== input.kind)
+                throw new Error("Workflow wait token action kind does not match the requested kind");
+            const nextStatus = input.kind === "cancel" ? "cancelled" : "resumed";
+            const nextRunStatus = input.kind === "cancel" ? "cancelled" : "running";
+            const action = {
+                id: input.actionRecordId ?? `wha_${randomUUID()}`,
+                projectId: input.projectId,
+                piboSessionId: input.piboSessionId,
+                workflowRunId: input.workflowRunId,
+                waitTokenId: input.waitTokenId,
+                ...(actionRef.id ? { actionId: actionRef.id } : {}),
+                kind: input.kind,
+                ...(input.actor ? { actor: input.actor } : {}),
+                ...(input.payload !== undefined ? { payload: input.payload } : {}),
+                createdAt: actedAt,
+            };
+            this.db.prepare(`INSERT INTO project_workflow_human_actions (
+				id,
+				project_id,
+				pibo_session_id,
+				workflow_run_id,
+				wait_token_id,
+				action_id,
+				kind,
+				actor_json,
+				payload_json,
+				payload_present,
+				created_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(action.id, action.projectId, action.piboSessionId, action.workflowRunId, action.waitTokenId, action.actionId ?? null, action.kind, action.actor ? JSON.stringify(action.actor) : null, action.payload === undefined ? null : JSON.stringify(action.payload), action.payload === undefined ? 0 : 1, action.createdAt);
+            this.db.prepare("UPDATE project_workflow_wait_tokens SET status = ?, resume_payload_json = ?, resume_payload_present = ?, resolved_at = ? WHERE id = ?")
+                .run(nextStatus, input.payload === undefined ? null : JSON.stringify(input.payload), input.payload === undefined ? 0 : 1, actedAt, token.id);
+            this.db.prepare("UPDATE project_workflow_runs SET status = ?, updated_at = ?, cancelled_at = CASE WHEN ? = 'cancelled' THEN ? ELSE cancelled_at END WHERE id = ? AND project_id = ? AND pibo_session_id = ?")
+                .run(nextRunStatus, actedAt, nextRunStatus, actedAt, input.workflowRunId, input.projectId, input.piboSessionId);
+            this.db.prepare("UPDATE project_sessions SET state = ?, updated_at = ? WHERE pibo_session_id = ? AND project_id = ?")
+                .run(nextRunStatus, actedAt, input.piboSessionId, input.projectId);
+            const waitToken = this.getProjectWorkflowWaitToken(input.waitTokenId);
+            const run = this.getProjectWorkflowRun(input.workflowRunId);
+            const projectSession = this.getProjectSession(input.piboSessionId);
+            this.db.exec("COMMIT");
+            return { waitToken, action, run, projectSession };
+        }
+        catch (error) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch {
+                // Transaction may already be committed when an expired token is recorded.
+            }
+            throw error;
+        }
+    }
+    startWorkflowSessionRun(input) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const existingSessionRow = this.db.prepare("SELECT * FROM project_sessions WHERE pibo_session_id = ?").get(input.piboSessionId);
+            if (!existingSessionRow || existingSessionRow.project_id !== input.projectId)
+                throw new Error("Project workflow session not found");
+            if (existingSessionRow.workflow_id !== input.workflowId || existingSessionRow.workflow_version !== input.workflowVersion) {
+                throw new Error("Project workflow session selection is immutable");
+            }
+            const snapshotRow = this.db.prepare("SELECT workflow_id, workflow_version, effective_definition_hash FROM project_workflow_session_snapshots WHERE id = ? AND pibo_session_id = ?")
+                .get(input.snapshotId, input.piboSessionId);
+            if (!snapshotRow)
+                throw new Error("Project workflow session snapshot not found");
+            if (snapshotRow.workflow_id !== input.workflowId || snapshotRow.workflow_version !== input.workflowVersion || snapshotRow.effective_definition_hash !== input.effectiveDefinitionHash) {
+                throw new Error("Project workflow session snapshot does not match selected workflow");
+            }
+            if (existingSessionRow.workflow_run_id) {
+                const existingRun = this.getProjectWorkflowRun(existingSessionRow.workflow_run_id)
+                    ?? this.insertProjectWorkflowRunForExistingSession(existingSessionRow, input);
+                this.db.exec("COMMIT");
+                return {
+                    projectSession: projectSessionFromRow(existingSessionRow),
+                    run: existingRun,
+                    alreadyStarted: true,
+                };
+            }
+            const now = new Date().toISOString();
+            const run = {
+                id: input.runId,
+                projectId: input.projectId,
+                piboSessionId: input.piboSessionId,
+                workflowId: input.workflowId,
+                workflowVersion: input.workflowVersion,
+                snapshotId: input.snapshotId,
+                effectiveDefinitionHash: input.effectiveDefinitionHash,
+                status: "running",
+                current: input.current,
+                inputValues: input.inputValues,
+                ...(input.validation ? { validation: input.validation } : {}),
+                createdAt: now,
+                updatedAt: now,
+            };
+            this.insertProjectWorkflowRun(run);
+            this.db.prepare("UPDATE project_sessions SET workflow_run_id = ?, state = 'running', updated_at = ? WHERE pibo_session_id = ? AND workflow_run_id IS NULL")
+                .run(run.id, now, input.piboSessionId);
+            const updatedSessionRow = this.db.prepare("SELECT * FROM project_sessions WHERE pibo_session_id = ?").get(input.piboSessionId);
+            this.db.exec("COMMIT");
+            return {
+                projectSession: projectSessionFromRow(updatedSessionRow),
+                run,
+                alreadyStarted: false,
+            };
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    setProjectSessionArchived(piboSessionId, archived) {
+        const now = new Date().toISOString();
+        this.db.prepare("UPDATE project_sessions SET archived = ?, updated_at = ? WHERE pibo_session_id = ?").run(archived ? 1 : 0, now, piboSessionId);
+        return this.getProjectSession(piboSessionId);
+    }
+    insertProjectWorkflowRunForExistingSession(row, input) {
+        const now = new Date().toISOString();
+        const run = {
+            id: row.workflow_run_id,
+            projectId: row.project_id,
+            piboSessionId: row.pibo_session_id,
+            workflowId: row.workflow_id,
+            workflowVersion: row.workflow_version ?? input.workflowVersion,
+            snapshotId: input.snapshotId,
+            effectiveDefinitionHash: input.effectiveDefinitionHash,
+            status: normalizeWorkflowRunStatus(row.state) ?? "running",
+            current: input.current,
+            inputValues: input.inputValues,
+            ...(input.validation ? { validation: input.validation } : {}),
+            createdAt: row.updated_at ?? now,
+            updatedAt: row.updated_at ?? now,
+        };
+        this.insertProjectWorkflowRun(run);
+        return run;
+    }
+    insertProjectWorkflowRun(run) {
+        this.db.prepare(`INSERT INTO project_workflow_runs (
+			id,
+			project_id,
+			pibo_session_id,
+			workflow_id,
+			workflow_version,
+			snapshot_id,
+			effective_definition_hash,
+			status,
+			current_json,
+			input_json,
+			validation_json,
+			created_at,
+			updated_at,
+			completed_at,
+			failed_at,
+			cancelled_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(run.id, run.projectId, run.piboSessionId, run.workflowId, run.workflowVersion, run.snapshotId, run.effectiveDefinitionHash, run.status, JSON.stringify(run.current), JSON.stringify(run.inputValues), run.validation ? JSON.stringify(run.validation) : null, run.createdAt, run.updatedAt, run.completedAt ?? null, run.failedAt ?? null, run.cancelledAt ?? null);
+    }
+    applySchema() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS projects (
+				id TEXT PRIMARY KEY,
+				name TEXT NOT NULL,
+				description TEXT,
+				project_folder TEXT NOT NULL,
+				configuration_status TEXT NOT NULL DEFAULT 'configured',
+				current_main_session_id TEXT,
+				archived_at TEXT,
+				metadata_json TEXT NOT NULL DEFAULT '{}',
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			);
+			CREATE UNIQUE INDEX IF NOT EXISTS projects_name_unique ON projects (lower(name));
+			CREATE UNIQUE INDEX IF NOT EXISTS projects_folder_unique ON projects (project_folder);
+			CREATE TABLE IF NOT EXISTS project_sessions (
+				project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+				pibo_session_id TEXT PRIMARY KEY,
+				kind TEXT NOT NULL DEFAULT 'main',
+				workflow_id TEXT NOT NULL DEFAULT 'simple-chat',
+				workflow_version TEXT,
+				workflow_run_id TEXT,
+				parent_main_session_id TEXT,
+				title TEXT,
+				state TEXT,
+				configuration_json TEXT,
+				retry_count INTEGER,
+				max_retries INTEGER,
+				archived INTEGER NOT NULL DEFAULT 0,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS project_sessions_project_id_idx ON project_sessions(project_id, archived, created_at);
+			CREATE TABLE IF NOT EXISTS project_workflow_session_snapshots (
+				id TEXT PRIMARY KEY,
+				schema_version INTEGER NOT NULL,
+				project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+				pibo_session_id TEXT NOT NULL REFERENCES project_sessions(pibo_session_id) ON DELETE CASCADE,
+				workflow_id TEXT NOT NULL,
+				workflow_version TEXT NOT NULL,
+				base_definition_hash TEXT NOT NULL,
+				effective_definition_hash TEXT NOT NULL,
+				snapshot_json TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				UNIQUE(pibo_session_id)
+			);
+			CREATE INDEX IF NOT EXISTS project_workflow_session_snapshots_project_idx ON project_workflow_session_snapshots(project_id, created_at);
+			CREATE TABLE IF NOT EXISTS project_workflow_runs (
+				id TEXT PRIMARY KEY,
+				project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+				pibo_session_id TEXT NOT NULL REFERENCES project_sessions(pibo_session_id) ON DELETE CASCADE,
+				workflow_id TEXT NOT NULL,
+				workflow_version TEXT NOT NULL,
+				snapshot_id TEXT NOT NULL REFERENCES project_workflow_session_snapshots(id) ON DELETE RESTRICT,
+				effective_definition_hash TEXT NOT NULL,
+				status TEXT NOT NULL,
+				current_json TEXT NOT NULL,
+				input_json TEXT NOT NULL,
+				validation_json TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				completed_at TEXT,
+				failed_at TEXT,
+				cancelled_at TEXT,
+				UNIQUE(pibo_session_id)
+			);
+			CREATE INDEX IF NOT EXISTS project_workflow_runs_project_idx ON project_workflow_runs(project_id, created_at);
+			CREATE INDEX IF NOT EXISTS project_workflow_runs_session_idx ON project_workflow_runs(pibo_session_id);
+			CREATE TABLE IF NOT EXISTS project_workflow_wait_tokens (
+				id TEXT PRIMARY KEY,
+				project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+				pibo_session_id TEXT NOT NULL REFERENCES project_sessions(pibo_session_id) ON DELETE CASCADE,
+				workflow_run_id TEXT NOT NULL REFERENCES project_workflow_runs(id) ON DELETE CASCADE,
+				node_attempt_id TEXT,
+				human_node_id TEXT,
+				actions_json TEXT NOT NULL,
+				prompt TEXT NOT NULL,
+				schema_json TEXT,
+				status TEXT NOT NULL,
+				resume_payload_json TEXT,
+				resume_payload_present INTEGER NOT NULL DEFAULT 0,
+				expires_at TEXT,
+				created_at TEXT NOT NULL,
+				resolved_at TEXT
+			);
+			CREATE INDEX IF NOT EXISTS project_workflow_wait_tokens_run_idx ON project_workflow_wait_tokens(workflow_run_id, status, created_at);
+			CREATE INDEX IF NOT EXISTS project_workflow_wait_tokens_session_idx ON project_workflow_wait_tokens(project_id, pibo_session_id, status, created_at);
+			CREATE TABLE IF NOT EXISTS project_workflow_human_actions (
+				id TEXT PRIMARY KEY,
+				project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+				pibo_session_id TEXT NOT NULL REFERENCES project_sessions(pibo_session_id) ON DELETE CASCADE,
+				workflow_run_id TEXT NOT NULL REFERENCES project_workflow_runs(id) ON DELETE CASCADE,
+				wait_token_id TEXT NOT NULL REFERENCES project_workflow_wait_tokens(id) ON DELETE CASCADE,
+				action_id TEXT,
+				kind TEXT NOT NULL,
+				actor_json TEXT,
+				payload_json TEXT,
+				payload_present INTEGER NOT NULL DEFAULT 0,
+				created_at TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS project_workflow_human_actions_run_idx ON project_workflow_human_actions(workflow_run_id, created_at);
+			CREATE INDEX IF NOT EXISTS project_workflow_human_actions_wait_token_idx ON project_workflow_human_actions(wait_token_id, created_at);
+		`);
+        this.ensureProjectSessionWorkflowVersionColumn();
+        this.ensureProjectSessionConfigurationColumn();
+    }
+    ensureProjectSessionWorkflowVersionColumn() {
+        const columns = this.db.prepare("PRAGMA table_info(project_sessions)").all();
+        if (!columns.some((column) => column.name === "workflow_version")) {
+            this.db.exec("ALTER TABLE project_sessions ADD COLUMN workflow_version TEXT");
+        }
+    }
+    ensureProjectSessionConfigurationColumn() {
+        const columns = this.db.prepare("PRAGMA table_info(project_sessions)").all();
+        if (!columns.some((column) => column.name === "configuration_json")) {
+            this.db.exec("ALTER TABLE project_sessions ADD COLUMN configuration_json TEXT");
+        }
+    }
+    assertNameAvailable(name, exceptId) {
+        const existing = this.db.prepare("SELECT id FROM projects WHERE lower(name) = lower(?) AND (? IS NULL OR id != ?)").get(name, exceptId ?? null, exceptId ?? null);
+        if (existing)
+            throw new Error("Project name already exists");
+    }
+    assertFolderAvailable(folder, exceptId) {
+        const existing = this.db.prepare("SELECT id FROM projects WHERE project_folder = ? AND (? IS NULL OR id != ?)").get(folder, exceptId ?? null, exceptId ?? null);
+        if (existing)
+            throw new Error("Project folder already exists");
+    }
+}
+function projectFromRow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        ...(row.description ? { description: row.description } : {}),
+        projectFolder: row.project_folder,
+        configurationStatus: "configured",
+        ...(row.current_main_session_id ? { currentMainSessionId: row.current_main_session_id } : {}),
+        ...(row.archived_at ? { archivedAt: row.archived_at } : {}),
+        metadata: safeJsonObject(row.metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function projectSessionFromRow(row) {
+    const configuration = safeWorkflowSessionConfiguration(row.configuration_json);
+    return {
+        projectId: row.project_id,
+        piboSessionId: row.pibo_session_id,
+        kind: row.kind,
+        workflowId: row.workflow_id,
+        ...(row.workflow_version ? { workflowVersion: row.workflow_version } : {}),
+        ...(row.workflow_run_id ? { workflowRunId: row.workflow_run_id } : {}),
+        ...(row.parent_main_session_id ? { parentMainSessionId: row.parent_main_session_id } : {}),
+        ...(row.title ? { title: row.title } : {}),
+        ...(row.state ? { state: row.state } : {}),
+        ...(configuration ? { configuration } : {}),
+        ...(row.retry_count !== null ? { retryCount: row.retry_count } : {}),
+        ...(row.max_retries !== null ? { maxRetries: row.max_retries } : {}),
+        archived: row.archived === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function workflowSessionSnapshotFromRow(row) {
+    const snapshot = safeJsonObject(row.snapshot_json);
+    return {
+        ...snapshot,
+        id: row.id,
+        schemaVersion: 1,
+        projectId: row.project_id,
+        piboSessionId: row.pibo_session_id,
+        workflow: {
+            ...(snapshot.workflow ?? {}),
+            id: row.workflow_id,
+            version: row.workflow_version,
+            baseDefinitionHash: row.base_definition_hash,
+            effectiveDefinitionHash: row.effective_definition_hash,
+            source: snapshot.workflow?.source ?? "code",
+            tags: snapshot.workflow?.tags ?? [],
+        },
+        baseDefinition: isPlainJsonObject(snapshot.baseDefinition) ? snapshot.baseDefinition : {},
+        effectiveDefinition: isPlainJsonObject(snapshot.effectiveDefinition) ? snapshot.effectiveDefinition : {},
+        inputValues: isPlainJsonObject(snapshot.inputValues) ? snapshot.inputValues : {},
+        promptOverrides: isStringRecord(snapshot.promptOverrides) ? snapshot.promptOverrides : {},
+        overridePolicy: snapshot.overridePolicy ?? {
+            promptEligibility: "metadata.sessionOverrides.prompt===true-and-direct-promptTemplate",
+            eligiblePromptNodeIds: [],
+            modelScope: "workflow",
+            thinkingLevelScope: "workflow",
+            fastModeScope: "workflow",
+        },
+        promptAssetPins: snapshot.promptAssetPins ?? [],
+        validation: isPlainJsonObject(snapshot.validation) ? snapshot.validation : {},
+        deletedDefinitionFallback: snapshot.deletedDefinitionFallback ?? {
+            workflowId: row.workflow_id,
+            workflowVersion: row.workflow_version,
+            effectiveDefinitionHash: row.effective_definition_hash,
+        },
+        createdAt: typeof snapshot.createdAt === "string" ? snapshot.createdAt : row.created_at,
+        createdBy: typeof snapshot.createdBy === "string" ? snapshot.createdBy : "unknown",
+        ...(snapshot.model ? { model: snapshot.model } : {}),
+        ...(snapshot.thinkingLevel ? { thinkingLevel: snapshot.thinkingLevel } : {}),
+        ...(snapshot.fastMode !== undefined ? { fastMode: snapshot.fastMode } : {}),
+    };
+}
+function projectWorkflowRunFromRow(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        piboSessionId: row.pibo_session_id,
+        workflowId: row.workflow_id,
+        workflowVersion: row.workflow_version,
+        snapshotId: row.snapshot_id,
+        effectiveDefinitionHash: row.effective_definition_hash,
+        status: normalizeWorkflowRunStatus(row.status) ?? "running",
+        current: safeJsonObject(row.current_json),
+        inputValues: safeJsonObject(row.input_json),
+        ...(row.validation_json ? { validation: safeJsonObject(row.validation_json) } : {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...(row.completed_at ? { completedAt: row.completed_at } : {}),
+        ...(row.failed_at ? { failedAt: row.failed_at } : {}),
+        ...(row.cancelled_at ? { cancelledAt: row.cancelled_at } : {}),
+    };
+}
+function projectWorkflowWaitTokenFromRow(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        piboSessionId: row.pibo_session_id,
+        workflowRunId: row.workflow_run_id,
+        ...(row.node_attempt_id ? { nodeAttemptId: row.node_attempt_id } : {}),
+        ...(row.human_node_id ? { humanNodeId: row.human_node_id } : {}),
+        actions: safeJsonArray(row.actions_json).filter(isProjectWorkflowWaitActionRef),
+        prompt: row.prompt,
+        ...(row.schema_json ? { schema: safeJsonObject(row.schema_json) } : {}),
+        status: row.status,
+        ...(row.resume_payload_present ? { resumePayload: safeJsonValue(row.resume_payload_json ?? "null") } : {}),
+        createdAt: row.created_at,
+        ...(row.expires_at ? { expiresAt: row.expires_at } : {}),
+        ...(row.resolved_at ? { resolvedAt: row.resolved_at } : {}),
+    };
+}
+function projectWorkflowHumanActionFromRow(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        piboSessionId: row.pibo_session_id,
+        workflowRunId: row.workflow_run_id,
+        waitTokenId: row.wait_token_id,
+        ...(row.action_id ? { actionId: row.action_id } : {}),
+        kind: row.kind,
+        ...(row.actor_json ? { actor: safeJsonObject(row.actor_json) } : {}),
+        ...(row.payload_present ? { payload: safeJsonValue(row.payload_json ?? "null") } : {}),
+        createdAt: row.created_at,
+    };
+}
+function isProjectWorkflowWaitActionRef(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.id === "string" && record.id.trim().length > 0
+        && (record.kind === undefined || typeof record.kind === "string");
+}
+function normalizeProjectName(value) {
+    if (typeof value !== "string")
+        throw new Error("Project name is required");
+    const name = value.replace(/\s+/g, " ").trim();
+    if (!name)
+        throw new Error("Project name is required");
+    if (name.length > 120)
+        throw new Error("Project name is too long");
+    return name;
+}
+function normalizeProjectFolder(value) {
+    if (typeof value !== "string")
+        throw new Error("Project folder is required");
+    let folder = value.trim();
+    if (!folder)
+        throw new Error("Project folder is required");
+    if (folder === "~")
+        folder = process.env.HOME ?? folder;
+    else if (folder.startsWith("~/"))
+        folder = `${process.env.HOME ?? ""}${folder.slice(1)}`;
+    if (!isAbsolute(folder))
+        throw new Error("Project folder must be an absolute path, e.g. ~/code/my-project or /home/me/code/my-project");
+    return folder;
+}
+const PROJECT_SESSION_STATES = new Set([
+    "simple_chat",
+    "workflow",
+    "configured",
+    "running",
+    "waiting",
+    "completed",
+    "failed",
+    "cancelled",
+]);
+function normalizeProjectSessionState(value) {
+    const state = value ?? "simple_chat";
+    if (!PROJECT_SESSION_STATES.has(state))
+        throw new Error(`Unsupported project session state: ${state}`);
+    return state;
+}
+function normalizeWorkflowRunStatus(value) {
+    if (value === "running" || value === "waiting" || value === "completed" || value === "failed" || value === "cancelled")
+        return value;
+    return undefined;
+}
+function assertProjectSessionImmutableFields(existing, next) {
+    if (existing.projectId !== next.projectId)
+        throw new Error("Project session project is immutable");
+    if (existing.kind !== next.kind)
+        throw new Error("Project session kind is immutable");
+    if (existing.workflowId !== next.workflowId || existing.workflowVersion !== next.workflowVersion) {
+        throw new Error("Project workflow session selection is immutable");
+    }
+    if (existing.workflowRunId && next.workflowRunId && existing.workflowRunId !== next.workflowRunId) {
+        throw new Error("Project workflow session run id is immutable");
+    }
+    if (serializeProjectSessionConfiguration(existing.configuration) !== serializeProjectSessionConfiguration(next.configuration)) {
+        throw new Error("Project workflow session configuration is immutable");
+    }
+}
+function serializeProjectSessionConfiguration(configuration) {
+    return configuration ? JSON.stringify(configuration) : null;
+}
+function safeWorkflowSessionConfiguration(value) {
+    if (!value)
+        return undefined;
+    const parsed = safeJsonObject(value);
+    if (!parsed.inputValues || typeof parsed.inputValues !== "object" || Array.isArray(parsed.inputValues))
+        return undefined;
+    if (!parsed.promptOverrides || typeof parsed.promptOverrides !== "object" || Array.isArray(parsed.promptOverrides))
+        return undefined;
+    return parsed;
+}
+function normalizeOptionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error("Value must be a string");
+    const text = value.trim();
+    return text || undefined;
+}
+function safeJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function safeJsonArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function safeJsonValue(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isJsonValue(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (value && typeof value === "object")
+        return Object.values(value).every(isJsonValue);
+    return false;
+}
+function isPlainJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value)
+        && Object.values(value).every((entry) => typeof entry === "string");
+}
+export function sharedDefaultProjectId() {
+    return "prj_default";
+}