@pasko70/pibo 1.4.5 → 1.5.0

package/dist/apps/chat/agent-profiles.js

@@ -3,7 +3,7 @@ export function createCustomAgentProfileDefinition(agent, options = {}) {
     const shouldWarnMissingReferences = options.missingReferenceMode !== "silent";
     return {
         name: agent.profileName,
-        aliases: [agent.id, `custom-agent:${agent.id}`],
+        aliases: uniqueAliases([agent.id, `custom-agent:${agent.id}`, ...agent.profileAliases], agent.profileName),
         description: agent.description || agent.displayName,
         create(context) {
             const builder = new InitialSessionContextBuilder(agent.profileName)
@@ -59,6 +59,9 @@ export function createCustomAgentProfileDefinition(agent, options = {}) {
         },
     };
 }
+function uniqueAliases(aliases, profileName) {
+    return [...new Set(aliases.filter((alias) => alias && alias !== profileName))];
+}
 function isUnknownContextFileError(error, contextFileKey) {
     return error instanceof Error && error.message === `Unknown context file "${contextFileKey}"`;
 }

package/dist/apps/chat/agent-store.js

@@ -15,6 +15,7 @@ export class CustomAgentStore {
             mkdirSync(dirname(resolvedPath), { recursive: true });
         this.db = new DatabaseSync(resolvedPath);
         this.db.exec("PRAGMA busy_timeout = 5000");
+        this.db.exec("PRAGMA foreign_keys = ON");
         if (resolvedPath !== ":memory:")
             this.db.exec("PRAGMA journal_mode = WAL");
         this.db.exec(`
@@ -47,6 +48,7 @@ export class CustomAgentStore {
 			);
 
 		`);
+        this.migrateProfileAliasTable();
         this.migrateArchivedAtColumn();
         this.migrateAutoContextFilesColumn();
         this.migrateMcpServersColumn();
@@ -55,6 +57,7 @@ export class CustomAgentStore {
         this.migrateThinkingLevelColumn();
         this.migrateThinkingOptionColumns();
         this.migrateBuiltinToolNamesColumn();
+        this.migrateAgentHistory();
         this.migrateLegacyProfileNames();
         this.migrateDuplicateProfileNames();
     }
@@ -63,12 +66,13 @@ export class CustomAgentStore {
         this.migrateDuplicateProfileNames();
         const archivedClause = options.includeArchived ? "" : " AND archived_at IS NULL";
         const rows = this.db.prepare(`SELECT * FROM chat_agents WHERE 1 = 1${archivedClause} ORDER BY updated_at DESC`).all();
-        return rows.map(agentFromRow);
+        const profileAliases = this.profileAliasesByAgentId();
+        return rows.map((row) => agentFromRow(row, profileAliases.get(row.id) ?? []));
     }
     get(id) {
         this.migrateLegacyProfileNames();
         const row = this.db.prepare("SELECT * FROM chat_agents WHERE id = ?").get(id);
-        return row ? agentFromRow(row) : undefined;
+        return row ? agentFromRow(row, this.profileAliasesByAgentId().get(row.id) ?? []) : undefined;
     }
     create(input) {
         this.migrateLegacyProfileNames();
@@ -80,6 +84,7 @@ export class CustomAgentStore {
             id,
             profileName,
             displayName: input.displayName,
+            profileAliases: [],
             description: input.description,
             nativeTools: [...(input.nativeTools ?? [])],
             skills: [...(input.skills ?? [])],
@@ -182,6 +187,7 @@ export class CustomAgentStore {
         return this.get(id);
     }
     delete(id) {
+        this.db.prepare("DELETE FROM chat_agent_profile_aliases WHERE agent_id = ?").run(id);
         const result = this.db.prepare("DELETE FROM chat_agents WHERE id = ?").run(id);
         return Number(result.changes ?? 0) > 0;
     }
@@ -225,6 +231,20 @@ export class CustomAgentStore {
         const row = this.db.prepare("SELECT id FROM chat_agents WHERE profile_name = ?").get(profileName);
         if (row && row.id !== currentId)
             throw new Error(`Agent name "${profileName}" already exists`);
+        const alias = this.db.prepare("SELECT agent_id FROM chat_agent_profile_aliases WHERE old_profile_name = ?").get(profileName);
+        if (alias && alias.agent_id !== currentId)
+            throw new Error(`Agent name "${profileName}" already exists`);
+    }
+    profileAliasesByAgentId() {
+        const rows = this.db.prepare("SELECT agent_id, old_profile_name FROM chat_agent_profile_aliases ORDER BY created_at ASC, old_profile_name ASC").all();
+        const aliases = new Map();
+        for (const row of rows) {
+            const values = aliases.get(row.agent_id) ?? [];
+            if (!values.includes(row.old_profile_name))
+                values.push(row.old_profile_name);
+            aliases.set(row.agent_id, values);
+        }
+        return aliases;
     }
     migrateLegacyProfileNames() {
         const rows = this.db.prepare("SELECT id, profile_name, display_name FROM chat_agents ORDER BY created_at ASC").all();
@@ -255,6 +275,45 @@ export class CustomAgentStore {
                 .run(nextName, nextName, row.id);
         }
     }
+    migrateProfileAliasTable() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS chat_agent_profile_aliases (
+				id TEXT PRIMARY KEY,
+				agent_id TEXT NOT NULL,
+				old_profile_name TEXT NOT NULL UNIQUE,
+				new_profile_name TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				FOREIGN KEY(agent_id) REFERENCES chat_agents(id) ON DELETE CASCADE
+			);
+
+			CREATE TRIGGER IF NOT EXISTS chat_agents_profile_alias_insert
+			AFTER UPDATE OF profile_name ON chat_agents
+			WHEN OLD.profile_name IS NOT NEW.profile_name
+			BEGIN
+				INSERT INTO chat_agent_profile_aliases (
+					id,
+					agent_id,
+					old_profile_name,
+					new_profile_name,
+					created_at
+				) VALUES (
+					'alias_' || lower(hex(randomblob(16))),
+					NEW.id,
+					OLD.profile_name,
+					NEW.profile_name,
+					strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+				)
+				ON CONFLICT(old_profile_name) DO UPDATE SET
+					agent_id = excluded.agent_id,
+					new_profile_name = excluded.new_profile_name,
+					created_at = excluded.created_at
+				WHERE chat_agent_profile_aliases.agent_id = excluded.agent_id;
+
+				DELETE FROM chat_agent_profile_aliases
+				WHERE agent_id = NEW.id AND old_profile_name = NEW.profile_name;
+			END;
+		`);
+    }
     tableColumns() {
         return new Set(this.db.prepare("PRAGMA table_info(chat_agents)").all().map((column) => column.name));
     }
@@ -321,15 +380,149 @@ export class CustomAgentStore {
             this.db.prepare("ALTER TABLE chat_agents ADD COLUMN builtin_tool_names_json TEXT NOT NULL DEFAULT '[\"read\",\"bash\",\"edit\",\"write\"]'").run();
         }
     }
+    migrateAgentHistory() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS chat_agent_events (
+				id TEXT PRIMARY KEY,
+				agent_id TEXT NOT NULL,
+				event_type TEXT NOT NULL CHECK (event_type IN ('updated', 'deleted')),
+				field_name TEXT,
+				old_value TEXT,
+				new_value TEXT,
+				old_profile_name TEXT,
+				new_profile_name TEXT,
+				old_display_name TEXT,
+				new_display_name TEXT,
+				recorded_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+			);
+
+			CREATE INDEX IF NOT EXISTS chat_agent_events_agent_id_idx
+				ON chat_agent_events(agent_id, recorded_at);
+
+			CREATE INDEX IF NOT EXISTS chat_agent_events_profile_name_idx
+				ON chat_agent_events(old_profile_name, new_profile_name, recorded_at);
+
+			CREATE TRIGGER IF NOT EXISTS chat_agents_profile_name_history_update
+			AFTER UPDATE OF profile_name ON chat_agents
+			FOR EACH ROW
+			WHEN OLD.profile_name IS NOT NEW.profile_name
+			BEGIN
+				INSERT INTO chat_agent_events (
+					id,
+					agent_id,
+					event_type,
+					field_name,
+					old_value,
+					new_value,
+					old_profile_name,
+					new_profile_name,
+					old_display_name,
+					new_display_name,
+					recorded_at
+				) VALUES (
+					'agent_event_' || lower(hex(randomblob(16))),
+					NEW.id,
+					'updated',
+					'profile_name',
+					OLD.profile_name,
+					NEW.profile_name,
+					OLD.profile_name,
+					NEW.profile_name,
+					OLD.display_name,
+					NEW.display_name,
+					strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+				);
+			END;
+
+			CREATE TRIGGER IF NOT EXISTS chat_agents_display_name_history_update
+			AFTER UPDATE OF display_name ON chat_agents
+			FOR EACH ROW
+			WHEN OLD.display_name IS NOT NEW.display_name
+			BEGIN
+				INSERT INTO chat_agent_events (
+					id,
+					agent_id,
+					event_type,
+					field_name,
+					old_value,
+					new_value,
+					old_profile_name,
+					new_profile_name,
+					old_display_name,
+					new_display_name,
+					recorded_at
+				) VALUES (
+					'agent_event_' || lower(hex(randomblob(16))),
+					NEW.id,
+					'updated',
+					'display_name',
+					OLD.display_name,
+					NEW.display_name,
+					OLD.profile_name,
+					NEW.profile_name,
+					OLD.display_name,
+					NEW.display_name,
+					strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+				);
+			END;
+
+			CREATE TRIGGER IF NOT EXISTS chat_agents_history_delete
+			AFTER DELETE ON chat_agents
+			FOR EACH ROW
+			BEGIN
+				INSERT INTO chat_agent_events (
+					id,
+					agent_id,
+					event_type,
+					field_name,
+					old_value,
+					new_value,
+					old_profile_name,
+					new_profile_name,
+					old_display_name,
+					new_display_name,
+					recorded_at
+				) VALUES (
+					'agent_event_' || lower(hex(randomblob(16))),
+					OLD.id,
+					'deleted',
+					NULL,
+					OLD.profile_name,
+					NULL,
+					OLD.profile_name,
+					NULL,
+					OLD.display_name,
+					NULL,
+					strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+				);
+			END;
+
+			CREATE VIEW IF NOT EXISTS chat_agent_history AS
+			SELECT
+				id,
+				agent_id,
+				event_type,
+				field_name,
+				old_value,
+				new_value,
+				old_profile_name,
+				new_profile_name,
+				old_display_name,
+				new_display_name,
+				recorded_at
+			FROM chat_agent_events;
+		`);
+    }
 }
 export function createDefaultCustomAgentStore(_cwd) {
     return new CustomAgentStore(piboHomePath("chat-agents.sqlite"));
 }
-function agentFromRow(row) {
+function agentFromRow(row, profileAliases) {
     return {
         id: row.id,
         profileName: row.profile_name,
         displayName: row.display_name,
+        profileAliases: profileAliases.filter((alias) => alias !== row.profile_name),
         description: row.description ?? undefined,
         nativeTools: parseStringArray(row.native_tools_json),
         skills: parseStringArray(row.skills_json),

package/dist/apps/chat/chat-settings-routes.js

@@ -1,9 +1,11 @@
 import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
 import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
-import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings } from "../../core/user-settings.js";
+import { sanitizeTelemetryRetentionDays, sanitizeTelemetryRetentionSettings } from "../../core/telemetry-retention-settings.js";
+import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { CHAT_WEB_API_PREFIX } from "./chat-api-routes.js";
 import { normalizeBasePromptMarkdown, normalizeBasePromptMode, normalizeCompactionPromptMarkdown, normalizeCompactionPromptMode, updateChatModelDefaults, } from "./chat-request-normalizers.js";
+import { pruneTelemetryOlderThan } from "./telemetry-retention-service.js";
 export function chatSettingsRoute(pathname, method) {
     if (pathname === `${CHAT_WEB_API_PREFIX}/model-defaults` && method === "PATCH")
         return { kind: "model-defaults" };
@@ -11,6 +13,8 @@ export function chatSettingsRoute(pathname, method) {
         return { kind: "user-settings", action: "read" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/user-settings` && method === "PATCH")
         return { kind: "user-settings", action: "update" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/telemetry-retention/prune` && method === "POST")
+        return { kind: "telemetry-retention", action: "prune" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "GET")
         return { kind: "base-prompt", action: "read" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "PATCH")
@@ -44,6 +48,18 @@ export async function handleChatSettingsRoute(input) {
         const body = await readJsonBody(request);
         return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body)) });
     }
+    if (route.kind === "telemetry-retention") {
+        if (!input.dataStore)
+            throw new PiboWebHttpError("Telemetry retention store unavailable", 503);
+        const body = await readJsonBody(request);
+        const days = sanitizeTelemetryRetentionDays(body.days);
+        if (!days)
+            throw new PiboWebHttpError("Invalid telemetry retention days", 400);
+        const result = pruneTelemetryOlderThan({ dataStore: input.dataStore, days, apply: body.dryRun !== true });
+        if (result.applied)
+            updateTelemetryRetentionLastPrunedAt(new Date().toISOString());
+        return responseJson({ telemetryRetention: result });
+    }
     if (route.kind === "base-prompt") {
         if (route.action === "read")
             return responseJson({ basePrompt: await readPiboBasePrompt(cwd) });
@@ -71,5 +87,12 @@ function userSettingsPatch(body) {
     }
     if (body.shortcuts !== undefined)
         patch.shortcuts = sanitizeShortcutSettings(body.shortcuts);
+    if (body.telemetryRetention !== undefined) {
+        const current = loadPiboUserSettings().telemetryRetention;
+        patch.telemetryRetention = {
+            ...sanitizeTelemetryRetentionSettings(body.telemetryRetention),
+            ...(current.lastPrunedAt ? { lastPrunedAt: current.lastPrunedAt } : {}),
+        };
+    }
     return patch;
 }

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { piboHomePath } from "../../../core/pibo-home.js";
@@ -49,8 +49,7 @@ export class ChatProjectService {
         const projectFolder = resolve(normalizeProjectFolder(input.projectFolder));
         this.assertNameAvailable(name);
         this.assertFolderAvailable(projectFolder);
-        if (input.createFolder)
-            mkdirSync(projectFolder, { recursive: true });
+        this.ensureProjectFolderUsable(projectFolder);
         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)
@@ -577,6 +576,17 @@ export class ChatProjectService {
         if (existing)
             throw new Error("Project folder already exists");
     }
+    ensureProjectFolderUsable(folder) {
+        try {
+            mkdirSync(folder, { recursive: true });
+            if (!statSync(folder).isDirectory())
+                throw new Error("Project folder is not a directory");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Project folder cannot be created or used: ${message}`);
+        }
+    }
 }
 function projectFromRow(row) {
     return {

package/dist/apps/chat/telemetry-retention-service.js

@@ -0,0 +1,69 @@
+import { telemetryRetentionCutoff, } from "../../core/telemetry-retention-settings.js";
+export const TELEMETRY_RETENTION_CLASSES = [
+    "live",
+    "diagnostic",
+    "provider_event",
+    "payload_preview",
+    "incident",
+];
+export const DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export function pruneTelemetryOlderThan(input) {
+    const cutoff = telemetryRetentionCutoff(input.days, input.now);
+    const results = TELEMETRY_RETENTION_CLASSES.map((retentionClass) => input.dataStore.telemetry.prune({ retentionClass, before: cutoff, apply: input.apply }));
+    return {
+        cutoff,
+        days: input.days,
+        applied: input.apply === true,
+        results,
+        rowsDeleted: results.reduce((sum, result) => sum + result.rowsDeleted, 0),
+        bytesMatched: results.reduce((sum, result) => sum + result.bytesMatched, 0),
+    };
+}
+export function isTelemetryRetentionMaintenanceDue(input) {
+    if (input.state.running)
+        return false;
+    const now = input.now ?? new Date();
+    const intervalMs = input.intervalMs ?? DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS;
+    return !(input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs);
+}
+export function maybeRunTelemetryRetentionMaintenance(input) {
+    if (!input.settings.enabled)
+        return;
+    if (input.state.running)
+        return;
+    const now = input.now ?? new Date();
+    const intervalMs = input.intervalMs ?? DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS;
+    if (input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs)
+        return;
+    if (!isPersistentRetentionDue(input.settings.lastPrunedAt, now, intervalMs)) {
+        input.state.lastCheckedAt = now.getTime();
+        return;
+    }
+    if (hasActiveRuntimeWork(input.context))
+        return;
+    input.state.lastCheckedAt = now.getTime();
+    input.state.running = true;
+    setTimeout(() => {
+        try {
+            pruneTelemetryOlderThan({ dataStore: input.dataStore, days: input.settings.days, now, apply: true });
+            input.onPruned?.(now.toISOString());
+        }
+        finally {
+            input.state.running = false;
+        }
+    }, 0).unref?.();
+}
+export function isPersistentRetentionDue(lastPrunedAt, now, intervalMs) {
+    if (!lastPrunedAt)
+        return true;
+    const lastPrunedMs = Date.parse(lastPrunedAt);
+    if (!Number.isFinite(lastPrunedMs))
+        return true;
+    return now.getTime() - lastPrunedMs >= intervalMs;
+}
+export function hasActiveRuntimeWork(context) {
+    const statuses = context.channelContext.listSessionRuntimeStatuses?.()
+        ?? context.channelContext.listSessions?.().map((session) => context.channelContext.getSessionRuntimeStatus?.(session.id)).filter((status) => status !== undefined)
+        ?? [];
+    return statuses.some((status) => Boolean(status?.processing || status?.streaming || (status?.queuedMessages ?? 0) > 0));
+}

package/dist/apps/chat/web-app.js

@@ -12,7 +12,8 @@ import { withWorkflowSessionKind } from "../../sessions/workflow-session-kind.js
 import { CustomAgentStore, createDefaultCustomAgentStore, } from "./agent-store.js";
 import { loadPiboModelDefaults, } from "../../core/model-defaults.js";
 import { inspectPiboContextBuild } from "../../core/context-build.js";
-import { loadPiboUserSettings } from "../../core/user-settings.js";
+import { loadPiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
+import { isTelemetryRetentionMaintenanceDue, maybeRunTelemetryRetentionMaintenance } from "./telemetry-retention-service.js";
 import { loadModelCatalog } from "./model-catalog.js";
 import { createCustomAgentProfileDefinition } from "./agent-profiles.js";
 import { createDefaultPiboReliabilityStore, PiboReliabilityStore } from "../../reliability/store.js";
@@ -707,7 +708,7 @@ function requireAgentProfileNameAvailable(state, context, profileName, currentAg
         }
     }
     const matchedProfile = context.channelContext.getProfiles?.().find((profile) => profile.name === profileName || profile.aliases.includes(profileName));
-    if (matchedProfile)
+    if (matchedProfile && matchedProfile.name !== currentAgent?.profileName)
         throw new PiboWebHttpError(`Agent name "${profileName}" conflicts with an existing profile`, 400);
 }
 function requireSharedAgent(agent) {
@@ -1758,13 +1759,14 @@ function normalizeAgentDeleteConfirmation(value) {
     }
     return value.trim();
 }
-function deleteSessionsForAgentProfile(state, context, webSession, profileName) {
+function deleteSessionsForAgentProfile(state, context, webSession, profileNames) {
     const deleteSession = context.channelContext.deleteSession;
     if (!deleteSession)
         throw new PiboWebHttpError("Session deletion is not available", 501);
     const ownedSessions = listSharedSessions(context);
     const sessionsById = new Map(ownedSessions.map((session) => [session.id, session]));
-    const ids = new Set(ownedSessions.filter((session) => session.profile === profileName).map((session) => session.id));
+    const profileNameSet = new Set(profileNames);
+    const ids = new Set(ownedSessions.filter((session) => profileNameSet.has(session.profile)).map((session) => session.id));
     let changed = true;
     while (changed) {
         changed = false;
@@ -2202,7 +2204,9 @@ function createEventStream(input) {
 async function buildProjectsBootstrap(input) {
     const sharedDefaultProject = input.state.projectService.ensureSharedDefaultProject();
     const selectedProject = input.projectId ? requireSharedProject(input.state, input.webSession, input.projectId, { includeArchived: true }) : sharedDefaultProject;
-    let storedProjectSessions = input.state.projectService.listProjectSessions(selectedProject.id, { includeArchived: input.includeArchived });
+    let storedProjectSessions = input.state.projectService
+        .listProjectSessions(selectedProject.id, { includeArchived: input.includeArchived })
+        .filter((projectSession) => projectSession.workflowId === "simple-chat");
     if (selectedProject.id === sharedDefaultProject.id && storedProjectSessions.length === 0) {
         const session = createProjectChatSession({
             state: input.state,
@@ -2214,7 +2218,7 @@ async function buildProjectsBootstrap(input) {
         });
         storedProjectSessions = [input.state.projectService.getProjectSession(session.id)];
     }
-    const projectSessions = storedProjectSessions.map((projectSession) => enrichProjectSessionWorkflowWaitTokens(input.state, enrichProjectSessionWorkflowDefinitionLink(input.state, projectSession)));
+    const projectSessions = storedProjectSessions;
     const rootSessions = projectSessions
         .map((projectSession) => input.context.channelContext.getSession(projectSession.piboSessionId))
         .filter((session) => Boolean(session));
@@ -2224,17 +2228,13 @@ async function buildProjectsBootstrap(input) {
     indexSharedSessions(input.state.sessionQuery, sessions);
     const nodes = await buildSessionNodes(sessions, input.state.sessionQuery.listSessions(), selectedProject.projectFolder, new Map(), { skipPiMetadataFallback: true });
     applyProjectSessionArchiveState(nodes, new Map(projectSessions.map((projectSession) => [projectSession.piboSessionId, Boolean(projectSession.archived)])));
-    const workflowLifecycleEvents = input.state.workflowLifecycleEventStore.listEvents({
-        projectId: selectedProject.id,
-        limit: 100,
-    });
     return {
         identity: input.webSession.authSession.identity,
         sharedDefaultProject,
         project: selectedProject,
         projects: listSharedProjects(input.state, input.webSession, { includeArchived: input.includeArchived }),
         projectSessions,
-        workflowLifecycleEvents,
+        workflowLifecycleEvents: [],
         ...(selectedSession ? { session: selectedSession, selectedPiboSessionId: selectedSession.id } : {}),
         selectedProjectId: selectedProject.id,
         sessions: nodes,
@@ -2688,6 +2688,7 @@ export function createChatWebApp(options = {}) {
         workflowTombstoneStore: new ChatWorkflowTombstoneStore(dataStore),
         workflowLifecycleEventStore: new ChatWorkflowLifecycleEventStore(dataStore),
         workflowPromptAssetStore: new ChatWorkflowPromptAssetStore(dataStore),
+        telemetryRetentionMaintenance: {},
     };
     const requireSession = (request, context) => context.requireSession({
         request,
@@ -2698,6 +2699,15 @@ export function createChatWebApp(options = {}) {
         apiPrefix: CHAT_WEB_API_PREFIX,
         async handleRequest(request, context) {
             const url = new URL(request.url);
+            if (isTelemetryRetentionMaintenanceDue({ state: state.telemetryRetentionMaintenance })) {
+                maybeRunTelemetryRetentionMaintenance({
+                    state: state.telemetryRetentionMaintenance,
+                    dataStore: state.dataStore,
+                    settings: loadPiboUserSettings().telemetryRetention,
+                    context,
+                    onPruned: updateTelemetryRetentionLastPrunedAt,
+                });
+            }
             ensureEventIndexing(state, context);
             ensureCustomAgentProfiles(state, context);
             syncChatUserSkills({
@@ -3417,6 +3427,7 @@ export function createChatWebApp(options = {}) {
                     route: settingsRoute,
                     request,
                     cwd: process.cwd(),
+                    dataStore: state.dataStore,
                 });
                 if (chatSettingsRouteInvalidatesBootstrapCatalog(settingsRoute))
                     invalidateBootstrapCatalogCache(state);
@@ -3504,7 +3515,7 @@ export function createChatWebApp(options = {}) {
                 if (confirmName !== agent.profileName) {
                     throw new PiboWebHttpError(`Type "${agent.profileName}" to permanently delete this agent and its sessions.`, 400);
                 }
-                const deletedSessionIds = deleteSessionsForAgentProfile(state, context, webSession, agent.profileName);
+                const deletedSessionIds = deleteSessionsForAgentProfile(state, context, webSession, [agent.profileName, ...agent.profileAliases]);
                 state.agentStore.delete(agent.id);
                 context.channelContext.removeProfile?.(agent.profileName);
                 invalidateBootstrapCatalogCache(state);