@pasko70/pibo 3.2.7 → 3.4.0

package/dist/apps/chat/chat-request-normalizers.js

@@ -1,12 +1,12 @@
 import { existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute } from "node:path";
 import { savePiboModelDefaults } from "../../core/model-defaults.js";
 import { DEFAULT_AGENT_RUNTIME_INSTANCE_ID } from "../../core/profiles.js";
 import { isPiboThinkingLevel } from "../../core/thinking.js";
 import { PiboWebHttpError } from "../../web/http.js";
 import { listPiPackages } from "../../pi-packages/store.js";
-import { withChatWebArchived } from "./session-metadata.js";
-import { isDefaultPiboRoom, withPiboRoomArchived, withPiboRoomWorkspace } from "./types/rooms.js";
+import { withChatWebArchived, withChatWebSessionPinned } from "./session-metadata.js";
+import { isDefaultPiboRoom, withPiboRoomArchived, withPiboRoomPinned, withPiboRoomWorkspace } from "./types/rooms.js";
 import { isValidCustomAgentName } from "./agent-store.js";
 export function normalizeRoomName(value, fallback = "New Chat") {
     if (value === undefined)
@@ -595,52 +595,6 @@ export function updateChatModelDefaults(body, cwd = process.cwd()) {
         subagentFast: normalizeOptionalBoolean(body.subagentFast, "subagentFast"),
     }, cwd);
 }
-const PROJECT_SESSION_PATCH_FIELDS = new Set([
-    "title",
-    "archived",
-]);
-export function assertProjectSessionPatchFields(body) {
-    if (!body || typeof body !== "object" || Array.isArray(body))
-        throw new PiboWebHttpError("Invalid JSON body", 400);
-    for (const key of Object.keys(body)) {
-        if (!PROJECT_SESSION_PATCH_FIELDS.has(key)) {
-            throw new PiboWebHttpError(`Unsupported project session update field: ${key}. Project workflow selection and configuration are immutable; create a new configured session to change workflow, input, prompt, model, thinking, or fast-mode values.`, 400);
-        }
-    }
-}
-export function normalizeProjectPath(value) {
-    if (typeof value !== "string" || !value.trim())
-        throw new PiboWebHttpError("Project folder is required", 400);
-    let projectPath = value.trim();
-    if (projectPath === "~")
-        projectPath = process.env.HOME ?? projectPath;
-    else if (projectPath.startsWith("~/"))
-        projectPath = `${process.env.HOME ?? ""}${projectPath.slice(1)}`;
-    if (!isAbsolute(projectPath))
-        throw new PiboWebHttpError("Project folder must be an absolute path, e.g. ~/code/my-project or /home/me/code/my-project", 400);
-    return resolve(projectPath);
-}
-export function normalizeProjectDescription(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "string")
-        throw new PiboWebHttpError("Project description must be a string", 400);
-    return value.trim() || undefined;
-}
-export function normalizeProjectArchived(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "boolean")
-        throw new PiboWebHttpError("Project archived flag must be boolean", 400);
-    return value;
-}
-export function normalizeProjectSessionArchived(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "boolean")
-        throw new PiboWebHttpError("Project session archived flag must be boolean", 400);
-    return value;
-}
 export function normalizeSessionTitle(value) {
     if (value === undefined)
         return undefined;
@@ -670,7 +624,12 @@ export function createSessionUpdate(context, session, body) {
     const title = normalizeSessionTitle(body.title);
     if (title !== undefined)
         update.title = title;
-    const metadata = metadataWithArchiveState(session, body.archived);
+    let metadata = metadataWithArchiveState(session, body.archived);
+    if (body.pinned !== undefined) {
+        if (typeof body.pinned !== "boolean")
+            throw new PiboWebHttpError("Session pinned flag must be boolean", 400);
+        metadata = withChatWebSessionPinned(metadata ?? session.metadata, body.pinned);
+    }
     if (metadata)
         update.metadata = metadata;
     if (body.profile !== undefined) {
@@ -707,6 +666,12 @@ export function createRoomUpdate(room, body) {
         metadata = withPiboRoomWorkspace(metadata, workspace ?? undefined);
         metadataChanged = true;
     }
+    if (body.pinned !== undefined) {
+        if (typeof body.pinned !== "boolean")
+            throw new PiboWebHttpError("Room pinned flag must be boolean", 400);
+        metadata = withPiboRoomPinned(metadata, body.pinned);
+        metadataChanged = true;
+    }
     if (metadataChanged)
         update.metadata = metadata;
     if (Object.keys(update).length === 0) {

package/dist/apps/chat/data/legacy-project-migration.js

@@ -0,0 +1,492 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+const MIGRATION_ID = "remove-legacy-containers-v1";
+const CATALOG_TABLES = ["workflow_ui_drafts", "workflow_published_versions", "workflow_archive_states", "workflow_delete_tombstones", "workflow_prompt_assets", "workflow_prompt_asset_revisions", "workflow_lifecycle_events"];
+const LEGACY_TABLES = [
+    "projects", "project_sessions", "project_workflow_session_snapshots", "project_workflow_runs",
+    "project_workflow_wait_tokens", "project_workflow_human_actions",
+];
+export function migrateLegacyProjects(input) {
+    if (input.dataStore.path === ":memory:" || input.workflowService.path === ":memory:") {
+        throw new Error("Legacy data migration requires file-backed Pibo and Workflow databases");
+    }
+    const sourcePath = resolve(input.legacyProjectPath ?? join(dirname(input.dataStore.path), "web-projects.sqlite"));
+    const archiveDirectory = resolve(input.archiveDirectory ?? join(dirname(input.dataStore.path), "backups"));
+    ensureReceiptTables(input.dataStore.db, input.workflowService.runtimeStore.db);
+    const dataReceipt = readReceipt(input.dataStore.db, "feature_migration_receipts");
+    const workflowReceipt = readReceipt(input.workflowService.runtimeStore.db, "workflow_migration_receipts");
+    if (dataReceipt && workflowReceipt) {
+        assertReceiptsEqual(dataReceipt, workflowReceipt);
+        if (dataReceipt.source_path)
+            completeSourceArchiveWithoutOpening(dataReceipt.source_path, dataReceipt.archive_path);
+        else if (existsSync(sourcePath))
+            throw new Error("A legacy source appeared after a catalog-only migration; preserve it for explicit recovery");
+        removeMigratedCatalogTables(input.dataStore);
+        return emptyResult("already-migrated", dataReceipt.archive_path || undefined);
+    }
+    const hasSource = existsSync(sourcePath);
+    const hasCatalog = CATALOG_TABLES.some((table) => input.dataStore.db.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table));
+    if (!hasSource && (dataReceipt?.source_path || workflowReceipt?.source_path))
+        throw new Error("Legacy migration is partially committed but its recoverable source database is missing");
+    if (!hasSource && !hasCatalog) {
+        if (dataReceipt || workflowReceipt)
+            throw new Error("Catalog migration is partially committed but its recoverable source tables are missing");
+        return emptyResult("not-needed");
+    }
+    const db = input.dataStore.db;
+    const dataUserVersion = pragmaUserVersion(db);
+    const dataSynchronous = Number(db.prepare("PRAGMA main.synchronous").get().synchronous);
+    let sourceAttached = false;
+    let workflowAttached = false;
+    try {
+        if (hasSource) {
+            db.prepare("ATTACH DATABASE ? AS legacy_source").run(`${pathToFileURL(sourcePath).href}?mode=ro`);
+            sourceAttached = true;
+        }
+        db.prepare("ATTACH DATABASE ? AS workflow_target").run(input.workflowService.path);
+        workflowAttached = true;
+        if (hasSource)
+            validateLegacySchema(db);
+        // FULL makes each WAL commit durable before retiring recoverable sources.
+        // Matching receipts still detect a crash between the two database commits.
+        db.exec("PRAGMA main.synchronous = FULL; PRAGMA workflow_target.synchronous = FULL");
+        db.exec("BEGIN IMMEDIATE");
+        const digest = legacySourceDigest(db, hasSource);
+        if (dataReceipt && dataReceipt.source_digest !== digest)
+            throw new Error("Pibo migration receipt does not match the recoverable legacy source");
+        if (workflowReceipt && workflowReceipt.source_digest !== digest)
+            throw new Error("Workflow migration receipt does not match the recoverable legacy source");
+        const archivePath = hasSource ? join(archiveDirectory, `${basename(sourcePath)}.migrated-${digest.slice(0, 16)}`) : "";
+        const counts = hasSource ? legacyCounts(db) : { rooms: 0, sessions: 0, workflowSessions: 0, runs: 0 };
+        try {
+            if (hasSource) {
+                validateLegacyFacts(db);
+                migrateRoomsAndSessions(db);
+                migrateWorkflowFacts(db);
+            }
+            migrateCatalogFacts(db);
+            input.hooks?.beforeReceipts?.();
+            writeReceipt(db, "main", "feature_migration_receipts", digest, hasSource ? sourcePath : "", archivePath);
+            input.hooks?.afterDataReceipt?.();
+            writeReceipt(db, "workflow_target", "workflow_migration_receipts", digest, hasSource ? sourcePath : "", archivePath);
+            if (pragmaUserVersion(db) !== dataUserVersion)
+                throw new Error("Legacy migration attempted to change the Pibo data schema version");
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            if (db.isTransaction)
+                db.exec("ROLLBACK");
+            throw error;
+        }
+        db.exec("DETACH DATABASE workflow_target");
+        workflowAttached = false;
+        if (sourceAttached)
+            db.exec("DETACH DATABASE legacy_source");
+        sourceAttached = false;
+        // Both WAL commits returned successfully before removing any recoverable
+        // catalog source. Partial commits retain those source tables for replay.
+        removeMigratedCatalogTables(input.dataStore);
+        if (hasSource)
+            completeSourceArchiveWithoutOpening(sourcePath, archivePath);
+        return {
+            status: "migrated",
+            roomsMigrated: counts.rooms,
+            sessionsMigrated: counts.sessions,
+            workflowSessionsMigrated: counts.workflowSessions,
+            workflowRunsMigrated: counts.runs,
+            ...(archivePath ? { archivePath } : {}),
+        };
+    }
+    finally {
+        if (db.isTransaction)
+            db.exec("ROLLBACK");
+        db.exec(`PRAGMA main.synchronous = ${dataSynchronous}`);
+        if (workflowAttached)
+            try {
+                db.exec("DETACH DATABASE workflow_target");
+            }
+            catch { /* preserve primary error */ }
+        if (sourceAttached)
+            try {
+                db.exec("DETACH DATABASE legacy_source");
+            }
+            catch { /* preserve primary error */ }
+    }
+}
+function ensureReceiptTables(dataDb, workflowDb) {
+    dataDb.exec(`CREATE TABLE IF NOT EXISTS feature_migration_receipts (
+		migration_id TEXT PRIMARY KEY, source_digest TEXT NOT NULL, source_path TEXT NOT NULL,
+		archive_path TEXT NOT NULL, completed_at TEXT NOT NULL
+	)`);
+    workflowDb.exec(`CREATE TABLE IF NOT EXISTS workflow_migration_receipts (
+		migration_id TEXT PRIMARY KEY, source_digest TEXT NOT NULL, source_path TEXT NOT NULL,
+		archive_path TEXT NOT NULL, completed_at TEXT NOT NULL
+	)`);
+}
+function readReceipt(db, table) {
+    return db.prepare(`SELECT * FROM ${table} WHERE migration_id = ?`).get(MIGRATION_ID);
+}
+function assertReceiptsEqual(left, right) {
+    for (const key of ["migration_id", "source_digest", "source_path", "archive_path"]) {
+        if (left[key] !== right[key])
+            throw new Error(`Legacy migration target receipts disagree on ${key}`);
+    }
+}
+function writeReceipt(db, schema, table, digest, sourcePath, archivePath) {
+    const existing = db.prepare(`SELECT * FROM ${schema}.${table} WHERE migration_id = ?`).get(MIGRATION_ID);
+    if (existing) {
+        if (existing.source_digest !== digest || existing.source_path !== sourcePath || existing.archive_path !== archivePath)
+            throw new Error("Legacy migration target has a conflicting receipt");
+        return;
+    }
+    db.prepare(`INSERT INTO ${schema}.${table} (migration_id, source_digest, source_path, archive_path, completed_at) VALUES (?, ?, ?, ?, ?)`)
+        .run(MIGRATION_ID, digest, sourcePath, archivePath, new Date().toISOString());
+}
+function validateLegacySchema(db) {
+    const names = new Set(db.prepare("SELECT name FROM legacy_source.sqlite_schema WHERE type = 'table'").all().map((row) => row.name));
+    const missing = LEGACY_TABLES.filter((table) => !names.has(table));
+    if (missing.length)
+        throw new Error(`Legacy database is malformed; missing table(s): ${missing.join(", ")}`);
+}
+function validateLegacyFacts(db) {
+    const missingSessions = db.prepare(`SELECT ps.pibo_session_id AS id FROM legacy_source.project_sessions ps
+		LEFT JOIN main.sessions s ON s.id = ps.pibo_session_id WHERE s.id IS NULL ORDER BY ps.pibo_session_id`).all();
+    if (missingSessions.length)
+        throw new Error(`Legacy links reference missing canonical Pibo Session(s): ${missingSessions.map((row) => row.id).join(", ")}`);
+    const missingParents = db.prepare(`SELECT ps.pibo_session_id AS id, ps.parent_main_session_id AS parent_id FROM legacy_source.project_sessions ps
+		LEFT JOIN main.sessions parent ON parent.id = ps.parent_main_session_id
+		WHERE ps.parent_main_session_id IS NOT NULL AND parent.id IS NULL`).all();
+    if (missingParents.length)
+        throw new Error(`Legacy hierarchy references missing parent Session '${missingParents[0].parent_id}' from '${missingParents[0].id}'`);
+    const hierarchyConflict = db.prepare(`SELECT ps.pibo_session_id AS id FROM legacy_source.project_sessions ps JOIN main.sessions s ON s.id = ps.pibo_session_id
+		WHERE ps.parent_main_session_id IS NOT NULL AND s.parent_id IS NOT NULL AND s.parent_id <> ps.parent_main_session_id LIMIT 1`).get();
+    if (hierarchyConflict)
+        throw new Error(`Legacy hierarchy conflicts with canonical Session '${hierarchyConflict.id}'`);
+    const missingRun = db.prepare(`SELECT ps.pibo_session_id AS id FROM legacy_source.project_sessions ps
+		LEFT JOIN legacy_source.project_workflow_runs r ON r.id = ps.workflow_run_id
+		LEFT JOIN workflow_target.workflow_runs current ON current.id = ps.workflow_run_id
+		WHERE ps.workflow_run_id IS NOT NULL AND r.id IS NULL AND current.id IS NULL LIMIT 1`).get();
+    if (missingRun)
+        throw new Error(`Legacy Workflow Session '${missingRun.id}' references a missing run`);
+    const orphanSnapshots = db.prepare(`SELECT x.id FROM legacy_source.project_workflow_session_snapshots x LEFT JOIN legacy_source.project_sessions ps ON ps.pibo_session_id = x.pibo_session_id
+		WHERE ps.pibo_session_id IS NULL OR x.project_id <> ps.project_id OR x.workflow_id <> ps.workflow_id OR x.workflow_version <> ps.workflow_version LIMIT 1`).get();
+    if (orphanSnapshots)
+        throw new Error(`Legacy Workflow snapshot '${orphanSnapshots.id}' references a missing Session link`);
+    const orphanRuns = db.prepare(`SELECT r.id FROM legacy_source.project_workflow_runs r
+		LEFT JOIN legacy_source.project_sessions ps ON ps.pibo_session_id = r.pibo_session_id
+		LEFT JOIN legacy_source.project_workflow_session_snapshots x ON x.id = r.snapshot_id
+		WHERE ps.pibo_session_id IS NULL OR x.id IS NULL OR r.project_id <> ps.project_id
+		OR x.pibo_session_id <> r.pibo_session_id OR x.workflow_id <> r.workflow_id OR x.workflow_version <> r.workflow_version OR x.effective_definition_hash <> r.effective_definition_hash LIMIT 1`).get();
+    if (orphanRuns)
+        throw new Error(`Legacy Workflow run '${orphanRuns.id}' has a missing Session or snapshot reference`);
+    const orphanWait = db.prepare(`SELECT w.id FROM legacy_source.project_workflow_wait_tokens w LEFT JOIN legacy_source.project_workflow_runs r ON r.id = w.workflow_run_id WHERE r.id IS NULL OR w.project_id <> r.project_id OR w.pibo_session_id <> r.pibo_session_id LIMIT 1`).get();
+    if (orphanWait)
+        throw new Error(`Legacy Workflow wait '${orphanWait.id}' references a missing run`);
+    const orphanAction = db.prepare(`SELECT a.id FROM legacy_source.project_workflow_human_actions a
+		LEFT JOIN legacy_source.project_workflow_runs r ON r.id = a.workflow_run_id
+		LEFT JOIN legacy_source.project_workflow_wait_tokens w ON w.id = a.wait_token_id
+		WHERE r.id IS NULL OR w.id IS NULL OR w.workflow_run_id <> a.workflow_run_id OR a.project_id <> r.project_id OR a.pibo_session_id <> r.pibo_session_id LIMIT 1`).get();
+    if (orphanAction)
+        throw new Error(`Legacy Workflow human action '${orphanAction.id}' has a missing run or wait reference`);
+    for (const [table, columns] of [
+        ["projects", ["metadata_json"]], ["project_sessions", ["configuration_json"]],
+        ["project_workflow_session_snapshots", ["snapshot_json"]],
+        ["project_workflow_runs", ["current_json", "input_json", "validation_json"]],
+        ["project_workflow_wait_tokens", ["actions_json", "schema_json", "resume_payload_json"]],
+        ["project_workflow_human_actions", ["actor_json", "payload_json"]],
+    ])
+        validateJsonColumns(db, `legacy_source.${table}`, columns);
+    for (const [table, columns] of [
+        ["projects", ["metadata_json"]], ["project_sessions", ["configuration_json"]],
+        ["project_workflow_session_snapshots", ["snapshot_json"]], ["project_workflow_runs", ["current_json", "input_json", "validation_json"]],
+        ["project_workflow_wait_tokens", ["schema_json"]], ["project_workflow_human_actions", ["actor_json"]],
+    ]) {
+        for (const column of columns)
+            if (db.prepare(`SELECT 1 FROM legacy_source.${table} WHERE ${column} IS NOT NULL AND json_type(${column}) <> 'object' LIMIT 1`).get())
+                throw new Error(`Legacy ${table}.${column} must contain JSON objects`);
+    }
+    if (db.prepare("SELECT 1 FROM legacy_source.project_workflow_wait_tokens WHERE json_type(actions_json) <> 'array' LIMIT 1").get())
+        throw new Error("Legacy wait actions must contain a JSON array");
+}
+function validateJsonColumns(db, table, columns) {
+    for (const column of columns) {
+        const bad = db.prepare(`SELECT rowid AS id FROM ${table} WHERE ${column} IS NOT NULL AND json_valid(${column}) = 0 LIMIT 1`).get();
+        if (bad)
+            throw new Error(`Legacy database contains malformed JSON in ${table}.${column} at row ${bad.id}`);
+    }
+}
+function migrateRoomsAndSessions(db) {
+    const projects = db.prepare("SELECT * FROM legacy_source.projects ORDER BY id").all();
+    for (const source of projects) {
+        const roomId = migratedRoomId(source.id);
+        const sourceMetadata = parseObject(source.metadata_json, `Legacy container '${source.id}' metadata`);
+        delete sourceMetadata.default;
+        const metadata = { ...sourceMetadata, workspace: source.project_folder, migration: { kind: "legacy-container", sourceId: source.id }, ...(source.archived_at ? { chatRoomArchivedAt: source.archived_at } : {}) };
+        insertOrAssert(db, "main.rooms", "id", {
+            id: roomId, name: source.name, topic: source.description, type: "chat", parent_room_id: null,
+            workspace: source.project_folder, retention_policy_id: null,
+            metadata_json: JSON.stringify(metadata), created_at: source.created_at, updated_at: source.updated_at,
+        });
+    }
+    const links = db.prepare("SELECT * FROM legacy_source.project_sessions ORDER BY created_at, pibo_session_id").all();
+    for (const link of links) {
+        const sourceProject = projects.find((project) => project.id === link.project_id);
+        if (!sourceProject)
+            throw new Error(`Legacy Session '${link.pibo_session_id}' references missing container '${link.project_id}'`);
+        const session = db.prepare("SELECT * FROM main.sessions WHERE id = ?").get(link.pibo_session_id);
+        const metadata = parseObject(session.metadata_json, `Session '${session.id}' metadata`);
+        delete metadata.projectId;
+        delete metadata.projectSessionKind;
+        metadata.chatRoomId = migratedRoomId(link.project_id);
+        const workflowBacked = isWorkflowBacked(link);
+        if (workflowBacked) {
+            if (!["main_workflow", "nested_workflow", "agent_node"].includes(String(metadata.workflowSessionKind)))
+                metadata.workflowSessionKind = link.kind === "main" ? "main_workflow" : "agent_node";
+            metadata.workflowId = link.workflow_id;
+            if (link.workflow_version)
+                metadata.workflowVersion = link.workflow_version;
+            if (link.workflow_run_id)
+                metadata.workflowRunId = link.workflow_run_id;
+        }
+        else {
+            delete metadata.workflowId;
+            delete metadata.workflowVersion;
+            delete metadata.workflowSessionKind;
+        }
+        const parentId = session.parent_id ?? link.parent_main_session_id;
+        const rootId = parentId ? canonicalRootId(db, parentId) : session.id;
+        if (parentId)
+            metadata.rootSessionId = rootId;
+        const archivedAt = session.archived_at ?? (typeof metadata.chatWebArchivedAt === "string" ? metadata.chatWebArchivedAt : link.archived ? link.updated_at : null);
+        if (archivedAt)
+            metadata.chatWebArchivedAt = archivedAt;
+        db.prepare(`UPDATE main.sessions SET kind = 'chat', room_id = ?, root_session_id = ?, parent_id = ?, workspace = COALESCE(NULLIF(workspace, ''), ?),
+			archived_at = ?, metadata_json = ? WHERE id = ?`).run(migratedRoomId(link.project_id), rootId, parentId, sourceProject.project_folder, archivedAt, JSON.stringify(metadata), session.id);
+        const updated = db.prepare("SELECT * FROM main.sessions WHERE id = ?").get(session.id);
+        const childCount = Number(db.prepare("SELECT COUNT(*) AS count FROM main.sessions WHERE parent_id = ? AND deleted_at IS NULL").get(session.id).count);
+        insertOrUpdateNavigation(db, updated, childCount);
+    }
+}
+function migrateWorkflowFacts(db) {
+    const links = db.prepare("SELECT * FROM legacy_source.project_sessions ORDER BY pibo_session_id").all();
+    for (const link of links.filter(isWorkflowBacked)) {
+        if (!link.workflow_version)
+            throw new Error(`Legacy Workflow Session '${link.pibo_session_id}' has no workflow version`);
+        const state = normalizeLinkState(link.state);
+        insertOrAssert(db, "workflow_target.workflow_session_links", "pibo_session_id", {
+            pibo_session_id: link.pibo_session_id, workflow_id: link.workflow_id, workflow_version: link.workflow_version,
+            workflow_run_id: link.workflow_run_id, state, configuration_json: link.configuration_json,
+            created_at: link.created_at, updated_at: link.updated_at,
+        });
+    }
+    const snapshots = db.prepare("SELECT * FROM legacy_source.project_workflow_session_snapshots ORDER BY id").all();
+    for (const row of snapshots) {
+        const snapshot = parseObject(row.snapshot_json, `Workflow snapshot '${row.id}'`);
+        delete snapshot.projectId;
+        snapshot.piboSessionId = row.pibo_session_id;
+        insertOrAssert(db, "workflow_target.workflow_session_snapshots", "id", {
+            id: row.id, pibo_session_id: row.pibo_session_id, workflow_id: row.workflow_id, workflow_version: row.workflow_version,
+            base_definition_hash: row.base_definition_hash, effective_definition_hash: row.effective_definition_hash,
+            snapshot_json: JSON.stringify(snapshot), created_at: row.created_at,
+        });
+        const effectiveDefinition = requireObject(snapshot.effectiveDefinition, `Workflow snapshot '${row.id}' effective definition`);
+        const existingDefinition = db.prepare("SELECT compiled_definition_json FROM workflow_target.workflow_definition_snapshots WHERE workflow_id = ? AND workflow_version = ? AND definition_hash = ?").get(row.workflow_id, row.workflow_version, row.effective_definition_hash);
+        if (existingDefinition) {
+            if (JSON.stringify(JSON.parse(existingDefinition.compiled_definition_json)) !== JSON.stringify(effectiveDefinition))
+                throw new Error(`Migration conflict in executable Workflow snapshot '${row.id}'`);
+        }
+        else
+            insertOrAssert(db, "workflow_target.workflow_definition_snapshots", "id", {
+                id: row.id, workflow_id: row.workflow_id, workflow_version: row.workflow_version,
+                definition_hash: row.effective_definition_hash, compiled_definition_json: JSON.stringify(effectiveDefinition), created_at: row.created_at,
+            });
+    }
+    const runs = db.prepare("SELECT * FROM legacy_source.project_workflow_runs ORDER BY id").all();
+    for (const run of runs) {
+        const executable = db.prepare("SELECT id FROM workflow_target.workflow_definition_snapshots WHERE workflow_id = ? AND workflow_version = ? AND definition_hash = ?").get(run.workflow_id, run.workflow_version, run.effective_definition_hash);
+        if (!executable)
+            throw new Error(`Legacy Workflow run '${run.id}' is missing its executable snapshot`);
+        insertOrAssert(db, "workflow_target.workflow_runs", "id", {
+            id: run.id, workflow_id: run.workflow_id, workflow_version: run.workflow_version,
+            workflow_definition_hash: run.effective_definition_hash, definition_snapshot_id: executable.id,
+            parent_run_id: null, parent_node_attempt_id: null, pibo_session_id: run.pibo_session_id, environment_json: null,
+            status: run.status, current_node_id: null, current_edge_id: null, current_status: run.status,
+            current_json: run.current_json, input_json: run.input_json, output_json: null, output_present: 0,
+            state_json: "{\"global\":{}}", checkpoint_json: null, validation_json: run.validation_json,
+            created_at: run.created_at, updated_at: run.updated_at, completed_at: run.completed_at, failed_at: run.failed_at, cancelled_at: run.cancelled_at,
+        });
+    }
+    const waits = db.prepare("SELECT * FROM legacy_source.project_workflow_wait_tokens ORDER BY id").all();
+    for (const wait of waits)
+        insertOrAssert(db, "workflow_target.workflow_wait_tokens", "id", {
+            id: wait.id, workflow_run_id: wait.workflow_run_id, node_attempt_id: wait.node_attempt_id, human_node_id: wait.human_node_id,
+            kind: null, available_actions_json: wait.actions_json, prompt: wait.prompt, schema_json: wait.schema_json, status: wait.status,
+            resume_payload_json: wait.resume_payload_json, resume_payload_present: wait.resume_payload_present, expires_at: wait.expires_at,
+            created_at: wait.created_at, resolved_at: wait.resolved_at,
+        });
+    const actions = db.prepare("SELECT * FROM legacy_source.project_workflow_human_actions ORDER BY id").all();
+    for (const action of actions)
+        insertOrAssert(db, "workflow_target.workflow_human_actions", "id", {
+            id: action.id, workflow_run_id: action.workflow_run_id, wait_token_id: action.wait_token_id, action_id: action.action_id,
+            kind: action.kind, actor_json: action.actor_json, payload_json: action.payload_present ? action.payload_json : null, created_at: action.created_at,
+        });
+}
+function migrateCatalogFacts(db) {
+    const tables = new Set(db.prepare("SELECT name FROM main.sqlite_schema WHERE type = 'table' AND name LIKE 'workflow_%'").all().map((row) => row.name));
+    if (tables.has("workflow_ui_drafts")) {
+        validateJsonColumns(db, "main.workflow_ui_drafts", ["definition_json", "diagnostics_json", "validation_json"]);
+        for (const row of db.prepare("SELECT * FROM main.workflow_ui_drafts ORDER BY draft_id").all()) {
+            insertOrAssert(db, "workflow_target.workflow_drafts", "draft_id", {
+                draft_id: row.draft_id, workflow_id: row.workflow_id, source: row.source, status: row.status,
+                base_workflow_id: row.base_workflow_id, base_workflow_version: row.base_workflow_version, base_definition_hash: row.base_definition_hash,
+                target_workflow_version: row.target_workflow_version, version_intent: row.version_intent, definition_json: row.definition_json,
+                diagnostics_json: row.diagnostics_json, validation_json: row.validation_json, validation_state: row.validation_state,
+                revision: row.revision, created_by: null, created_at: row.created_at, updated_by: null, updated_at: row.updated_at,
+            });
+        }
+    }
+    copySameShape(db, tables, "workflow_published_versions", ["workflow_id", "version"]);
+    copySameShape(db, tables, "workflow_archive_states", ["workflow_id"]);
+    copySameShape(db, tables, "workflow_prompt_assets", ["asset_id"]);
+    copySameShape(db, tables, "workflow_prompt_asset_revisions", ["revision_id"]);
+    if (tables.has("workflow_delete_tombstones")) {
+        for (const row of db.prepare("SELECT * FROM main.workflow_delete_tombstones ORDER BY workflow_id").all())
+            insertOrAssert(db, "workflow_target.workflow_delete_tombstones", "workflow_id", {
+                workflow_id: row.workflow_id, source: row.source, deleted: row.deleted, deleted_at: row.deleted_at, deleted_by: row.deleted_by,
+                last_known_title: row.last_known_title, last_known_version: row.last_known_version, last_definition_hash: row.last_definition_hash, created_at: row.updated_at,
+            });
+    }
+    if (tables.has("workflow_lifecycle_events")) {
+        for (const row of db.prepare("SELECT * FROM main.workflow_lifecycle_events ORDER BY id").all())
+            insertOrAssert(db, "workflow_target.workflow_lifecycle_events", "id", {
+                id: row.id, type: normalizeLifecycleType(String(row.type)), actor_id: row.actor_id, workflow_id: row.workflow_id, workflow_version: row.workflow_version,
+                draft_id: row.draft_id, pibo_session_id: row.pibo_session_id, workflow_run_id: row.workflow_run_id, status: row.status,
+                validation_json: row.validation_json, diagnostics_json: row.diagnostics_json, payload_json: row.payload_json, created_at: row.created_at,
+            });
+    }
+    migrateDerivedWorkflowIdentities(db);
+}
+function migrateDerivedWorkflowIdentities(db) {
+    const rows = db.prepare(`SELECT workflow_id, MIN(created_at) AS created_at, MAX(updated_at) AS updated_at FROM (
+		SELECT workflow_id, created_at, updated_at FROM workflow_target.workflow_drafts
+		UNION ALL SELECT workflow_id, created_at, published_at FROM workflow_target.workflow_published_versions
+	) GROUP BY workflow_id ORDER BY workflow_id`).all();
+    for (const row of rows) {
+        const draft = db.prepare("SELECT draft_id, definition_json FROM workflow_target.workflow_drafts WHERE workflow_id = ? ORDER BY updated_at DESC LIMIT 1").get(row.workflow_id);
+        const published = db.prepare("SELECT version, definition_json FROM workflow_target.workflow_published_versions WHERE workflow_id = ? ORDER BY published_at DESC LIMIT 1").get(row.workflow_id);
+        const definition = parseObject(draft?.definition_json ?? published?.definition_json ?? "{}", `Workflow identity '${row.workflow_id}' definition`);
+        insertOrAssert(db, "workflow_target.workflow_identities", "workflow_id", {
+            workflow_id: row.workflow_id, source: "ui", title: typeof definition.title === "string" ? definition.title : row.workflow_id,
+            description: typeof definition.description === "string" ? definition.description : null,
+            tags_json: JSON.stringify(Array.isArray(definition.metadata) ? [] : requireObjectOrEmpty(definition.metadata).tags ?? []),
+            current_draft_id: draft?.draft_id ?? null, latest_version: published?.version ?? null, created_by: null,
+            created_at: row.created_at, updated_by: null, updated_at: row.updated_at,
+        });
+    }
+}
+function copySameShape(db, tables, table, keyColumns) {
+    if (!tables.has(table))
+        return;
+    const targetColumns = db.prepare(`PRAGMA workflow_target.table_info(${table})`).all().map((row) => row.name);
+    const sourceColumns = new Set(db.prepare(`PRAGMA main.table_info(${table})`).all().map((row) => row.name));
+    const columns = targetColumns.filter((column) => sourceColumns.has(column));
+    const rows = db.prepare(`SELECT ${columns.join(", ")} FROM main.${table} ORDER BY ${keyColumns.join(", ")}`).all();
+    for (const row of rows)
+        insertOrAssert(db, `workflow_target.${table}`, keyColumns, row);
+}
+function insertOrAssert(db, table, key, values) {
+    const keys = Array.isArray(key) ? key : [key];
+    const where = keys.map((column) => `${column} = ?`).join(" AND ");
+    const existing = db.prepare(`SELECT * FROM ${table} WHERE ${where}`).get(...keys.map((column) => values[column]));
+    if (existing) {
+        for (const [column, value] of Object.entries(values)) {
+            if (!sqliteValuesEqual(existing[column], value))
+                throw new Error(`Migration conflict in ${table} for ${keys.map((column) => `${column}=${String(values[column])}`).join(", ")} at ${column}`);
+        }
+        return;
+    }
+    const columns = Object.keys(values);
+    db.prepare(`INSERT INTO ${table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`).run(...columns.map((column) => (values[column] ?? null)));
+}
+function insertOrUpdateNavigation(db, session, childCount) {
+    db.prepare(`INSERT INTO main.session_navigation (
+		room_id, session_id, root_session_id, parent_id, origin_id, title, profile, status, archived_at,
+		last_activity_at, last_message_preview, child_count, sort_key, updated_at
+	) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+	ON CONFLICT(session_id) DO UPDATE SET room_id=excluded.room_id, root_session_id=excluded.root_session_id,
+		parent_id=excluded.parent_id, origin_id=excluded.origin_id, title=excluded.title, profile=excluded.profile,
+		status=excluded.status, archived_at=excluded.archived_at, last_activity_at=excluded.last_activity_at,
+		child_count=excluded.child_count, updated_at=excluded.updated_at`).run(session.room_id, session.id, session.root_session_id, session.parent_id, session.origin_id, session.title, session.profile, session.status, session.archived_at, session.last_activity_at, session.first_message_preview, childCount, session.last_activity_at, session.updated_at);
+}
+function removeMigratedCatalogTables(dataStore) {
+    dataStore.transaction(() => {
+        for (const table of CATALOG_TABLES)
+            dataStore.db.exec(`DROP TABLE IF EXISTS ${table}`);
+    });
+}
+function legacySourceDigest(db, hasSource) {
+    const facts = {};
+    if (hasSource)
+        for (const table of LEGACY_TABLES)
+            facts[table] = db.prepare(`SELECT * FROM legacy_source.${table} ORDER BY rowid`).all();
+    for (const table of CATALOG_TABLES) {
+        if (db.prepare("SELECT 1 FROM main.sqlite_schema WHERE type='table' AND name=?").get(table))
+            facts[`catalog:${table}`] = db.prepare(`SELECT * FROM main.${table} ORDER BY rowid`).all();
+    }
+    return createHash("sha256").update(JSON.stringify(facts)).digest("hex");
+}
+function legacyCounts(db) {
+    const count = (table, where = "") => Number(db.prepare(`SELECT COUNT(*) AS count FROM legacy_source.${table} ${where}`).get().count);
+    return { rooms: count("projects"), sessions: count("project_sessions"), workflowSessions: count("project_sessions", "WHERE workflow_id <> 'simple-chat' OR state NOT IN ('simple_chat', '')"), runs: count("project_workflow_runs") };
+}
+function migratedRoomId(sourceId) { return `room_migrated_${createHash("sha256").update(sourceId).digest("hex").slice(0, 24)}`; }
+function canonicalRootId(db, parentId) {
+    const visited = new Set();
+    let id = parentId;
+    while (true) {
+        if (visited.has(id))
+            throw new Error(`Canonical Session hierarchy contains a cycle at '${id}'`);
+        visited.add(id);
+        const row = db.prepare("SELECT parent_id FROM main.sessions WHERE id = ?").get(id);
+        if (!row)
+            throw new Error(`Missing canonical parent Session '${id}'`);
+        if (!row.parent_id)
+            return id;
+        id = row.parent_id;
+    }
+}
+function isWorkflowBacked(row) { return row.workflow_id !== "simple-chat" || (row.state !== null && row.state !== "simple_chat"); }
+function normalizeLinkState(value) { if (value === "running" || value === "waiting" || value === "completed" || value === "failed" || value === "cancelled" || value === "configured")
+    return value; if (value === "workflow")
+    return "configured"; throw new Error(`Unsupported legacy Workflow Session state '${String(value)}'`); }
+function normalizeLifecycleType(value) { return value.replace(/^project\.workflow_session\.created$/, "workflow.session.created").replace(/^project\.workflow_start\./, "workflow.start."); }
+function parseObject(value, label) { const parsed = typeof value === "string" ? JSON.parse(value) : value; if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error(`${label} is not a JSON object`); return parsed; }
+function requireObject(value, label) { return parseObject(value, label); }
+function requireObjectOrEmpty(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : {}; }
+function sqliteValuesEqual(left, right) { return (left ?? null) === (right ?? null); }
+function pragmaUserVersion(db) { return Number(db.prepare("PRAGMA main.user_version").get().user_version); }
+function completeSourceArchiveWithoutOpening(sourcePath, archivePath) {
+    const sourceExists = existsSync(sourcePath);
+    const archiveExists = existsSync(archivePath);
+    const sidecars = ["-wal", "-shm"].filter((suffix) => existsSync(`${sourcePath}${suffix}`));
+    if (!sourceExists && !archiveExists) {
+        if (sidecars.length)
+            throw new Error("Legacy archive has orphaned sidecars; preserve them for recovery");
+        return;
+    }
+    if (sourceExists && archiveExists)
+        throw new Error(`Cannot archive legacy source because '${archivePath}' already exists`);
+    for (const suffix of sidecars)
+        if (existsSync(`${archivePath}${suffix}`))
+            throw new Error(`Legacy archive sidecar conflicts at '${archivePath}${suffix}'`);
+    mkdirSync(dirname(archivePath), { recursive: true });
+    if (sourceExists)
+        renameSync(sourcePath, archivePath);
+    // A restart can arrive after the base rename but before its WAL/SHM rename.
+    for (const suffix of sidecars)
+        renameSync(`${sourcePath}${suffix}`, `${archivePath}${suffix}`);
+}
+function emptyResult(status, archivePath) { return { status, roomsMigrated: 0, sessionsMigrated: 0, workflowSessionsMigrated: 0, workflowRunsMigrated: 0, ...(archivePath ? { archivePath } : {}) }; }

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { roomWorkspaceFromMetadata } from "../types/rooms.js";
+import { comparePiboRoomsBySidebarOrder, roomWorkspaceFromMetadata } from "../types/rooms.js";
 import { roomFromRow } from "./chat-data-mappers.js";
 export class PiboRoomHierarchyCycleError extends Error {
     constructor() {
@@ -39,7 +39,7 @@ export class ChatRoomService {
         return Number(result.changes ?? 0);
     }
     getRoom(id) { const row = this.store.db.prepare("SELECT * FROM rooms WHERE id = ?").get(id); return row ? roomFromRow(row) : undefined; }
-    listRooms() { return this.store.db.prepare("SELECT * FROM rooms ORDER BY updated_at DESC, id ASC").all().map(roomFromRow); }
+    listRooms() { return this.store.db.prepare("SELECT * FROM rooms").all().map(roomFromRow).sort(comparePiboRoomsBySidebarOrder); }
     listRoomTree() { const byId = new Map(this.listRooms().map((room) => [room.id, { ...room, children: [] }])); const roots = []; for (const node of byId.values()) {
         const parent = node.parentRoomId ? byId.get(node.parentRoomId) : undefined;
         if (parent)

package/dist/apps/chat/data/workflow-session-model.js

@@ -0,0 +1 @@
+export {};