forge-openclaw-plugin 0.2.24 → 0.2.25

package/dist/server/repositories/settings.js

@@ -2,7 +2,8 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { getDatabase, runInTransaction } from "../db.js";
 import { recordActivityEvent } from "./activity-events.js";
 import { recordEventLog } from "./event-log.js";
-import { createAgentTokenSchema, agentIdentitySchema, settingsPayloadSchema, updateSettingsSchema } from "../types.js";
+import { buildConnectionAgentIdentity, FORGE_DEFAULT_AGENT_ID, listAiModelConnections, syncForgeManagedWikiProfile } from "./model-settings.js";
+import { createAgentTokenSchema, agentIdentitySchema, customThemeSchema, settingsPayloadSchema, updateSettingsSchema } from "../types.js";
 function boolFromInt(value) {
     return value === 1;
 }
@@ -24,9 +25,25 @@ function normalizeMicrosoftRedirectUri(value) {
     const trimmed = value?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : defaultMicrosoftRedirectUri();
 }
+function normalizeModelConnectionId(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : "";
+}
 function buildTokenSecret() {
     return `fg_live_${randomBytes(18).toString("hex")}`;
 }
+function parseCustomThemeJson(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        return customThemeSchema.parse(JSON.parse(trimmed));
+    }
+    catch {
+        return null;
+    }
+}
 function mapAgent(row) {
     return agentIdentitySchema.parse({
         id: row.id,
@@ -118,9 +135,10 @@ function readSettingsRow() {
     ensureSettingsRow();
     return getDatabase()
         .prepare(`SELECT
-        operator_name, operator_email, operator_title, theme_preference, locale_preference,
+        operator_name, operator_email, operator_title, theme_preference, custom_theme_json, locale_preference,
         goal_drift_alerts, daily_quest_reminders, achievement_celebrations, max_active_tasks, time_accounting_mode,
-        integrity_score, last_audit_at, psyche_auth_required, microsoft_client_id, microsoft_tenant_id, microsoft_redirect_uri, created_at, updated_at
+        integrity_score, last_audit_at, psyche_auth_required, microsoft_client_id, microsoft_tenant_id, microsoft_redirect_uri,
+        forge_basic_chat_connection_id, forge_basic_chat_model, forge_wiki_connection_id, forge_wiki_model, created_at, updated_at
        FROM app_settings
        WHERE id = 1`)
         .get();
@@ -167,7 +185,23 @@ export function listAgentIdentities() {
        GROUP BY agent_identities.id
        ORDER BY agent_identities.created_at DESC`)
         .all();
-    return rows.map(mapAgent);
+    const manualAgents = rows.map(mapAgent);
+    const modelAgents = listAiModelConnections().map(buildConnectionAgentIdentity);
+    const settings = readSettingsRow();
+    const forgeAgent = agentIdentitySchema.parse({
+        id: FORGE_DEFAULT_AGENT_ID,
+        label: "Forge Agent",
+        agentType: "forge_default",
+        trustLevel: "trusted",
+        autonomyMode: "approval_required",
+        approvalMode: "approval_by_default",
+        description: "Built-in Forge operator agent. Owns Forge-native task flows, prompts, and orchestration.",
+        tokenCount: 0,
+        activeTokenCount: 0,
+        createdAt: settings.created_at,
+        updatedAt: settings.updated_at
+    });
+    return [forgeAgent, ...modelAgents, ...manualAgents];
 }
 export function isPsycheAuthRequired() {
     ensureSettingsRow();
@@ -178,9 +212,15 @@ export function isPsycheAuthRequired() {
 }
 export function getSettings() {
     const row = readSettingsRow();
+    const connections = listAiModelConnections();
     const microsoftClientId = row.microsoft_client_id?.trim() ?? "";
     const microsoftTenantId = normalizeMicrosoftTenantId(row.microsoft_tenant_id);
     const microsoftRedirectUri = normalizeMicrosoftRedirectUri(row.microsoft_redirect_uri);
+    const basicChatConnectionId = normalizeModelConnectionId(row.forge_basic_chat_connection_id);
+    const wikiConnectionId = normalizeModelConnectionId(row.forge_wiki_connection_id);
+    const basicChatConnection = connections.find((entry) => entry.id === basicChatConnectionId) ?? null;
+    const wikiConnection = connections.find((entry) => entry.id === wikiConnectionId) ?? null;
+    const customTheme = parseCustomThemeJson(row.custom_theme_json);
     return settingsPayloadSchema.parse({
         profile: {
             operatorName: row.operator_name,
@@ -197,6 +237,7 @@ export function getSettings() {
             timeAccountingMode: row.time_accounting_mode
         },
         themePreference: row.theme_preference,
+        customTheme,
         localePreference: row.locale_preference,
         security: {
             integrityScore: row.integrity_score,
@@ -221,11 +262,37 @@ export function getSettings() {
                     : "Save the Microsoft client ID and the Forge callback redirect URI here before you try to sign in."
             }
         },
+        modelSettings: {
+            forgeAgent: {
+                basicChat: {
+                    connectionId: basicChatConnection?.id ?? null,
+                    connectionLabel: basicChatConnection?.label ?? null,
+                    provider: basicChatConnection?.provider ?? null,
+                    baseUrl: basicChatConnection?.baseUrl ?? null,
+                    model: row.forge_basic_chat_model?.trim() || basicChatConnection?.model || "gpt-5.4-mini"
+                },
+                wiki: {
+                    connectionId: wikiConnection?.id ?? null,
+                    connectionLabel: wikiConnection?.label ?? null,
+                    provider: wikiConnection?.provider ?? null,
+                    baseUrl: wikiConnection?.baseUrl ?? null,
+                    model: row.forge_wiki_model?.trim() || wikiConnection?.model || "gpt-5.4-mini"
+                }
+            },
+            connections,
+            oauth: {
+                openAiCodex: {
+                    authorizeUrl: "https://auth.openai.com/oauth/authorize",
+                    callbackUrl: "http://127.0.0.1:1455/auth/callback",
+                    setupMessage: "Forge mirrors OpenClaw's local OpenAI Codex PKCE flow. The browser returns to localhost:1455, and Forge can also accept a pasted redirect URL when the callback cannot bind."
+                }
+            }
+        },
         agents: listAgentIdentities(),
         agentTokens: listAgentTokens()
     });
 }
-export function updateSettings(input, activity) {
+export function updateSettings(input, options = {}) {
     const parsed = updateSettingsSchema.parse(input);
     return runInTransaction(() => {
         const current = getSettings();
@@ -246,6 +313,7 @@ export function updateSettings(input, activity) {
                 timeAccountingMode: parsed.execution?.timeAccountingMode ?? current.execution.timeAccountingMode
             },
             themePreference: parsed.themePreference ?? current.themePreference,
+            customTheme: parsed.customTheme === undefined ? (current.customTheme ?? null) : parsed.customTheme,
             localePreference: parsed.localePreference ?? current.localePreference,
             psycheAuthRequired: parsed.security?.psycheAuthRequired ?? current.security.psycheAuthRequired,
             calendarProviders: {
@@ -257,33 +325,61 @@ export function updateSettings(input, activity) {
                     redirectUri: normalizeMicrosoftRedirectUri(parsed.calendarProviders?.microsoft?.redirectUri ??
                         current.calendarProviders.microsoft.redirectUri)
                 }
+            },
+            modelSettings: {
+                forgeAgent: {
+                    basicChat: {
+                        connectionId: parsed.modelSettings?.forgeAgent?.basicChat?.connectionId !==
+                            undefined
+                            ? normalizeModelConnectionId(parsed.modelSettings.forgeAgent.basicChat.connectionId)
+                            : current.modelSettings.forgeAgent.basicChat.connectionId ?? "",
+                        model: parsed.modelSettings?.forgeAgent?.basicChat?.model?.trim() ||
+                            current.modelSettings.forgeAgent.basicChat.model
+                    },
+                    wiki: {
+                        connectionId: parsed.modelSettings?.forgeAgent?.wiki?.connectionId !== undefined
+                            ? normalizeModelConnectionId(parsed.modelSettings.forgeAgent.wiki.connectionId)
+                            : current.modelSettings.forgeAgent.wiki.connectionId ?? "",
+                        model: parsed.modelSettings?.forgeAgent?.wiki?.model?.trim() ||
+                            current.modelSettings.forgeAgent.wiki.model
+                    }
+                }
             }
         };
         getDatabase()
             .prepare(`UPDATE app_settings
-         SET operator_name = ?, operator_email = ?, operator_title = ?, theme_preference = ?, locale_preference = ?,
+         SET operator_name = ?, operator_email = ?, operator_title = ?, theme_preference = ?, custom_theme_json = ?, locale_preference = ?,
              goal_drift_alerts = ?, daily_quest_reminders = ?, achievement_celebrations = ?, max_active_tasks = ?, time_accounting_mode = ?,
-             psyche_auth_required = ?, microsoft_client_id = ?, microsoft_tenant_id = ?, microsoft_redirect_uri = ?, updated_at = ?
+             psyche_auth_required = ?, microsoft_client_id = ?, microsoft_tenant_id = ?, microsoft_redirect_uri = ?,
+             forge_basic_chat_connection_id = ?, forge_basic_chat_model = ?, forge_wiki_connection_id = ?, forge_wiki_model = ?, updated_at = ?
          WHERE id = 1`)
-            .run(next.profile.operatorName, next.profile.operatorEmail, next.profile.operatorTitle, next.themePreference, next.localePreference, toInt(next.notifications.goalDriftAlerts), toInt(next.notifications.dailyQuestReminders), toInt(next.notifications.achievementCelebrations), next.execution.maxActiveTasks, next.execution.timeAccountingMode, toInt(next.psycheAuthRequired), next.calendarProviders.microsoft.clientId, next.calendarProviders.microsoft.tenantId, next.calendarProviders.microsoft.redirectUri, now);
-        if (activity) {
+            .run(next.profile.operatorName, next.profile.operatorEmail, next.profile.operatorTitle, next.themePreference, next.customTheme ? JSON.stringify(next.customTheme) : "", next.localePreference, toInt(next.notifications.goalDriftAlerts), toInt(next.notifications.dailyQuestReminders), toInt(next.notifications.achievementCelebrations), next.execution.maxActiveTasks, next.execution.timeAccountingMode, toInt(next.psycheAuthRequired), next.calendarProviders.microsoft.clientId, next.calendarProviders.microsoft.tenantId, next.calendarProviders.microsoft.redirectUri, next.modelSettings.forgeAgent.basicChat.connectionId, next.modelSettings.forgeAgent.basicChat.model, next.modelSettings.forgeAgent.wiki.connectionId, next.modelSettings.forgeAgent.wiki.model, now);
+        if (options.secrets) {
+            syncForgeManagedWikiProfile(options.secrets);
+        }
+        if (options.activity) {
             recordActivityEvent({
                 entityType: "system",
                 entityId: "app_settings",
                 eventType: "settings_updated",
                 title: "Forge settings updated",
                 description: `Theme is now ${next.themePreference}. Language is ${next.localePreference}.`,
-                actor: activity.actor ?? null,
-                source: activity.source,
+                actor: options.activity.actor ?? null,
+                source: options.activity.source,
                 metadata: {
                     themePreference: next.themePreference,
+                    customThemeLabel: next.customTheme?.label ?? null,
                     localePreference: next.localePreference,
                     goalDriftAlerts: next.notifications.goalDriftAlerts,
                     dailyQuestReminders: next.notifications.dailyQuestReminders,
                     maxActiveTasks: next.execution.maxActiveTasks,
                     timeAccountingMode: next.execution.timeAccountingMode,
                     microsoftConfigured: next.calendarProviders.microsoft.clientId.trim().length > 0,
-                    microsoftTenantId: next.calendarProviders.microsoft.tenantId
+                    microsoftTenantId: next.calendarProviders.microsoft.tenantId,
+                    forgeBasicChatModel: next.modelSettings.forgeAgent.basicChat.model,
+                    forgeWikiModel: next.modelSettings.forgeAgent.wiki.model,
+                    forgeBasicChatConnectionId: next.modelSettings.forgeAgent.basicChat.connectionId || null,
+                    forgeWikiConnectionId: next.modelSettings.forgeAgent.wiki.connectionId || null
                 }
             });
         }

package/dist/server/repositories/surface-layouts.js

@@ -0,0 +1,76 @@
+import { getDatabase } from "../db.js";
+import { surfaceLayoutPayloadSchema } from "../types.js";
+function parseLayout(row) {
+    const parsed = JSON.parse(row.payload_json);
+    const legacy = "layouts" in parsed ? parsed : null;
+    const legacyOrder = Array.isArray(legacy?.layouts?.lg)
+        ? [...legacy.layouts.lg]
+            .sort((left, right) => {
+            const leftY = typeof left.y === "number" ? left.y : 0;
+            const rightY = typeof right.y === "number" ? right.y : 0;
+            if (leftY !== rightY) {
+                return leftY - rightY;
+            }
+            const leftX = typeof left.x === "number" ? left.x : 0;
+            const rightX = typeof right.x === "number" ? right.x : 0;
+            return leftX - rightX;
+        })
+            .map((item) => item.i)
+            .filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+    const widgets = Object.fromEntries(Object.entries(parsed.widgets ?? {}).map(([widgetId, rawValue]) => {
+        const value = rawValue && typeof rawValue === "object"
+            ? rawValue
+            : {};
+        const legacyLg = legacy?.layouts?.lg?.find((entry) => entry.i === widgetId);
+        return [
+            widgetId,
+            {
+                hidden: value.hidden === true,
+                fullWidth: value.fullWidth === true ||
+                    (typeof legacyLg?.w === "number" && legacyLg.w >= 10),
+                titleVisible: value.titleVisible !== false,
+                descriptionVisible: value.descriptionVisible !== false
+            }
+        ];
+    }));
+    return surfaceLayoutPayloadSchema.parse({
+        ...parsed,
+        surfaceId: row.surface_id,
+        order: Array.isArray(parsed.order) && parsed.order.length > 0
+            ? parsed.order
+            : legacyOrder,
+        widgets,
+        updatedAt: row.updated_at
+    });
+}
+export function getSurfaceLayout(surfaceId) {
+    const row = getDatabase()
+        .prepare(`SELECT surface_id, payload_json, updated_at
+       FROM surface_layouts
+       WHERE surface_id = ?`)
+        .get(surfaceId);
+    return row ? parseLayout(row) : null;
+}
+export function saveSurfaceLayout(surfaceId, payload) {
+    const now = new Date().toISOString();
+    const next = surfaceLayoutPayloadSchema.parse({
+        surfaceId,
+        updatedAt: now,
+        ...payload
+    });
+    getDatabase()
+        .prepare(`INSERT INTO surface_layouts (surface_id, payload_json, updated_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(surface_id) DO UPDATE SET
+         payload_json = excluded.payload_json,
+         updated_at = excluded.updated_at`)
+        .run(surfaceId, JSON.stringify(next), now);
+    return getSurfaceLayout(surfaceId);
+}
+export function resetSurfaceLayout(surfaceId) {
+    getDatabase()
+        .prepare(`DELETE FROM surface_layouts WHERE surface_id = ?`)
+        .run(surfaceId);
+    return null;
+}

package/dist/server/repositories/wiki-memory.js

@@ -274,6 +274,7 @@ export const upsertWikiLlmProfileSchema = z.object({
     baseUrl: z.string().trim().default("https://api.openai.com/v1"),
     model: z.string().trim().min(1),
     apiKey: z.string().trim().optional(),
+    secretId: z.string().trim().nullable().optional(),
     systemPrompt: z.string().trim().default(""),
     reasoningEffort: wikiLlmReasoningEffortSchema.optional(),
     verbosity: wikiLlmVerbositySchema.optional(),
@@ -737,6 +738,7 @@ function getNoteStoragePath(note, space) {
 }
 function buildNoteFrontmatter(note) {
     return {
+        ...note.frontmatter,
         id: note.id,
         kind: note.kind,
         title: note.title,
@@ -2058,7 +2060,9 @@ export function upsertWikiLlmProfile(input, secrets) {
     const now = nowIso();
     const id = parsed.id?.trim() ||
         `wiki_llm_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
-    let secretId = listWikiLlmProfiles().find((entry) => entry.id === id)?.secretId ?? null;
+    let secretId = parsed.secretId ??
+        listWikiLlmProfiles().find((entry) => entry.id === id)?.secretId ??
+        null;
     if (parsed.apiKey?.trim()) {
         secretId =
             secretId ??

package/dist/server/services/entity-crud.js

@@ -3,16 +3,20 @@ import { createInsight, deleteInsight, getInsightById, listInsights, updateInsig
 import { createCalendarEvent, createTaskTimebox, createWorkBlockTemplate, deleteCalendarEvent, deleteTaskTimebox, deleteWorkBlockTemplate, getCalendarEventById, getTaskTimeboxById, getWorkBlockTemplateById, listCalendarEvents, listTaskTimeboxes, listWorkBlockTemplates, updateCalendarEvent, updateTaskTimebox, updateWorkBlockTemplate } from "../repositories/calendar.js";
 import { createNote, deleteNote, getNoteById, listNotes, unlinkNotesForEntity, updateNote } from "../repositories/notes.js";
 import { clearEntityOwner, filterOwnedEntities } from "../repositories/entity-ownership.js";
+import { createPreferenceCatalog, createPreferenceCatalogItem, createPreferenceContext, createPreferenceItem, deletePreferenceCatalog, deletePreferenceCatalogItem, deletePreferenceContext, deletePreferenceItem, getPreferenceCatalogById, getPreferenceCatalogItemById, getPreferenceContextById, getPreferenceItemById, listPreferenceCatalogItems, listPreferenceCatalogs, listPreferenceContexts, listPreferenceItems, updatePreferenceCatalog, updatePreferenceCatalogItem, updatePreferenceContext, updatePreferenceItem } from "../repositories/preferences.js";
 import { createBehaviorPatternSchema, createBehaviorSchema, createBeliefEntrySchema, createEmotionDefinitionSchema, createEventTypeSchema, createModeGuideSessionSchema, createModeProfileSchema, createPsycheValueSchema, createTriggerReportSchema, updateBehaviorPatternSchema, updateBehaviorSchema, updateBeliefEntrySchema, updateEmotionDefinitionSchema, updateEventTypeSchema, updateModeGuideSessionSchema, updateModeProfileSchema, updatePsycheValueSchema, updateTriggerReportSchema } from "../psyche-types.js";
 import { buildSettingsBinPayload, cascadeSoftDeleteAnchoredCollaboration, clearDeletedEntityRecord, getDeletedEntityRecord, listDeletedEntities, restoreAnchoredCollaboration, restoreDeletedEntityRecord, upsertDeletedEntityRecord } from "../repositories/deleted-entities.js";
 import { createGoal, deleteGoal, getGoalById, listGoals, updateGoal } from "../repositories/goals.js";
 import { createHabit, deleteHabit, getHabitById, listHabits, updateHabit } from "../repositories/habits.js";
+import { createQuestionnaireInstrument, deleteQuestionnaireInstrument, getQuestionnaireInstrumentEntityById, listQuestionnaireInstrumentEntities, updateQuestionnaireInstrument, updateQuestionnaireInstrumentSchema } from "../repositories/questionnaires.js";
 import { createBehavior, createBehaviorPattern, createBeliefEntry, createEmotionDefinition, createEventType, createModeGuideSession, createModeProfile, createPsycheValue, createTriggerReport, deleteBehavior, deleteBehaviorPattern, deleteBeliefEntry, deleteEmotionDefinition, deleteEventType, deleteModeGuideSession, deleteModeProfile, deletePsycheValue, deleteTriggerReport, getBehaviorById, getBehaviorPatternById, getBeliefEntryById, getEmotionDefinitionById, getEventTypeById, getModeGuideSessionById, getModeProfileById, getPsycheValueById, getTriggerReportById, listBehaviors, listBehaviorPatterns, listBeliefEntries, listEmotionDefinitions, listEventTypes, listModeGuideSessions, listModeProfiles, listPsycheValues, listTriggerReports, updateBehavior, updateBehaviorPattern, updateBeliefEntry, updateEmotionDefinition, updateEventType, updateModeGuideSession, updateModeProfile, updatePsycheValue, updateTriggerReport } from "../repositories/psyche.js";
 import { createProject, deleteProject, getProjectById, listProjects, updateProject } from "../repositories/projects.js";
 import { createStrategy, deleteStrategy, getStrategyById, listStrategies, updateStrategy } from "../repositories/strategies.js";
 import { createTag, deleteTag, getTagById, listTags, updateTag } from "../repositories/tags.js";
 import { createTask, deleteTask, getTaskById, listTasks, updateTask } from "../repositories/tasks.js";
 import { createCalendarEventSchema, createGoalSchema, createHabitSchema, createInsightSchema, createNoteSchema, createProjectSchema, createStrategySchema, createTaskTimeboxSchema, createTagSchema, createTaskSchema, createWorkBlockTemplateSchema, updateCalendarEventSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateNoteSchema, updateProjectSchema, updateStrategySchema, updateTaskTimeboxSchema, updateTagSchema, updateTaskSchema, updateWorkBlockTemplateSchema } from "../types.js";
+import { createPreferenceCatalogItemSchema, createPreferenceCatalogSchema, createPreferenceContextSchema, createPreferenceItemSchema, updatePreferenceCatalogItemSchema, updatePreferenceCatalogSchema, updatePreferenceContextSchema, updatePreferenceItemSchema } from "../preferences-types.js";
+import { createQuestionnaireInstrumentSchema } from "../questionnaire-types.js";
 const ENTITY_CALENDAR_LIST_RANGE = {
     from: "1970-01-01T00:00:00.000Z",
     to: "2100-01-01T00:00:00.000Z"
@@ -249,6 +253,62 @@ const CRUD_ENTITY_CAPABILITIES = {
         create: (data, context) => createTriggerReport(data, context),
         update: (id, patch, context) => updateTriggerReport(id, patch, context),
         hardDelete: (id, context) => deleteTriggerReport(id, context)
+    },
+    preference_catalog: {
+        entityType: "preference_catalog",
+        routeBase: "/api/v1/preferences/catalogs",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listPreferenceCatalogs(),
+        get: (id) => getPreferenceCatalogById(id),
+        create: (data) => createPreferenceCatalog(data),
+        update: (id, patch) => updatePreferenceCatalog(id, patch),
+        hardDelete: (id) => deletePreferenceCatalog(id)
+    },
+    preference_catalog_item: {
+        entityType: "preference_catalog_item",
+        routeBase: "/api/v1/preferences/catalog-items",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listPreferenceCatalogItems(),
+        get: (id) => getPreferenceCatalogItemById(id),
+        create: (data) => createPreferenceCatalogItem(data),
+        update: (id, patch) => updatePreferenceCatalogItem(id, patch),
+        hardDelete: (id) => deletePreferenceCatalogItem(id)
+    },
+    preference_context: {
+        entityType: "preference_context",
+        routeBase: "/api/v1/preferences/contexts",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listPreferenceContexts(),
+        get: (id) => getPreferenceContextById(id),
+        create: (data) => createPreferenceContext(data),
+        update: (id, patch) => updatePreferenceContext(id, patch),
+        hardDelete: (id) => deletePreferenceContext(id)
+    },
+    preference_item: {
+        entityType: "preference_item",
+        routeBase: "/api/v1/preferences/items",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listPreferenceItems(),
+        get: (id) => getPreferenceItemById(id),
+        create: (data) => createPreferenceItem(data),
+        update: (id, patch) => updatePreferenceItem(id, patch),
+        hardDelete: (id) => deletePreferenceItem(id)
+    },
+    questionnaire_instrument: {
+        entityType: "questionnaire_instrument",
+        routeBase: "/api/v1/psyche/questionnaires",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listQuestionnaireInstrumentEntities(),
+        get: (id) => getQuestionnaireInstrumentEntityById(id),
+        create: (data, context) => createQuestionnaireInstrument(data, context)
+            .instrument,
+        update: (id, patch, context) => updateQuestionnaireInstrument(id, patch, context),
+        hardDelete: (id, context) => deleteQuestionnaireInstrument(id, context)
     }
 };
 export function getCrudEntityCapabilityMatrix() {
@@ -283,7 +343,12 @@ const CREATE_ENTITY_SCHEMAS = {
     mode_guide_session: createModeGuideSessionSchema,
     event_type: createEventTypeSchema,
     emotion_definition: createEmotionDefinitionSchema,
-    trigger_report: createTriggerReportSchema
+    trigger_report: createTriggerReportSchema,
+    preference_catalog: createPreferenceCatalogSchema,
+    preference_catalog_item: createPreferenceCatalogItemSchema,
+    preference_context: createPreferenceContextSchema,
+    preference_item: createPreferenceItemSchema,
+    questionnaire_instrument: createQuestionnaireInstrumentSchema
 };
 const UPDATE_ENTITY_SCHEMAS = {
     goal: updateGoalSchema,
@@ -305,7 +370,12 @@ const UPDATE_ENTITY_SCHEMAS = {
     mode_guide_session: updateModeGuideSessionSchema,
     event_type: updateEventTypeSchema,
     emotion_definition: updateEmotionDefinitionSchema,
-    trigger_report: updateTriggerReportSchema
+    trigger_report: updateTriggerReportSchema,
+    preference_catalog: updatePreferenceCatalogSchema,
+    preference_catalog_item: updatePreferenceCatalogItemSchema,
+    preference_context: updatePreferenceContextSchema,
+    preference_item: updatePreferenceItemSchema,
+    questionnaire_instrument: updateQuestionnaireInstrumentSchema
 };
 function parseCreateInput(entityType, data) {
     return CREATE_ENTITY_SCHEMAS[entityType].parse(data);
@@ -476,6 +546,15 @@ function matchesLinkedTo(entityType, entity, linkedTo) {
                 (linkedTo.entityType === "behavior" && Array.isArray(entity.linkedBehaviorIds) && entity.linkedBehaviorIds.includes(linkedTo.id)) ||
                 (linkedTo.entityType === "belief_entry" && Array.isArray(entity.linkedBeliefIds) && entity.linkedBeliefIds.includes(linkedTo.id)) ||
                 (linkedTo.entityType === "mode_profile" && Array.isArray(entity.linkedModeIds) && entity.linkedModeIds.includes(linkedTo.id)));
+        case "preference_catalog_item":
+            return linkedTo.entityType === "preference_catalog" && entity.catalogId === linkedTo.id;
+        case "preference_item":
+            return (typeof entity.sourceEntityType === "string" &&
+                typeof entity.sourceEntityId === "string" &&
+                entity.sourceEntityType === linkedTo.entityType &&
+                entity.sourceEntityId === linkedTo.id);
+        case "questionnaire_instrument":
+            return false;
         default:
             return false;
     }

package/dist/server/services/openai-codex-oauth.js

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+import { loginOpenAICodex } from "@mariozechner/pi-ai/oauth";
+import { openAiCodexOauthSessionSchema } from "../types.js";
+const sessions = new Map();
+const SESSION_TTL_MS = 15 * 60 * 1000;
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((nextResolve, nextReject) => {
+        resolve = nextResolve;
+        reject = nextReject;
+    });
+    return { promise, resolve, reject };
+}
+function updateSession(sessionId, patch) {
+    const existing = sessions.get(sessionId);
+    if (!existing) {
+        throw new Error(`Unknown OpenAI Codex OAuth session ${sessionId}`);
+    }
+    existing.publicSession = openAiCodexOauthSessionSchema.parse({
+        ...existing.publicSession,
+        ...patch
+    });
+    return existing.publicSession;
+}
+function requireRecord(sessionId) {
+    const record = sessions.get(sessionId);
+    if (!record) {
+        throw new Error(`Unknown OpenAI Codex OAuth session ${sessionId}`);
+    }
+    const expiresAt = new Date(record.publicSession.expiresAt).getTime();
+    if (Date.now() >= expiresAt && record.publicSession.status !== "authorized") {
+        record.publicSession = openAiCodexOauthSessionSchema.parse({
+            ...record.publicSession,
+            status: "expired"
+        });
+    }
+    return record;
+}
+function parseError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export async function startOpenAiCodexOauthSession(options = {}) {
+    const id = `ocx_${randomUUID().replaceAll("-", "").slice(0, 8)}`;
+    const now = new Date();
+    const record = {
+        publicSession: openAiCodexOauthSessionSchema.parse({
+            id,
+            status: "starting",
+            authUrl: null,
+            accountLabel: null,
+            error: null,
+            createdAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + SESSION_TTL_MS).toISOString(),
+            credentialExpiresAt: null
+        }),
+        manualInput: createDeferred(),
+        authReady: createDeferred(),
+        credentials: null
+    };
+    sessions.set(id, record);
+    const login = options.login ?? loginOpenAICodex;
+    void login({
+        onAuth: ({ url }) => {
+            updateSession(id, {
+                status: "awaiting_browser",
+                authUrl: url,
+                error: null
+            });
+            record.authReady.resolve();
+        },
+        onPrompt: async () => {
+            updateSession(id, {
+                status: "awaiting_manual_input"
+            });
+            record.authReady.resolve();
+            return await record.manualInput.promise;
+        },
+        onManualCodeInput: async () => {
+            updateSession(id, {
+                status: "awaiting_manual_input"
+            });
+            record.authReady.resolve();
+            return await record.manualInput.promise;
+        }
+    })
+        .then((credentials) => {
+        record.credentials = credentials;
+        updateSession(id, {
+            status: "authorized",
+            accountLabel: typeof credentials.accountId === "string"
+                ? credentials.accountId
+                : null,
+            credentialExpiresAt: typeof credentials.expires === "number"
+                ? new Date(credentials.expires).toISOString()
+                : null
+        });
+    })
+        .catch((error) => {
+        updateSession(id, {
+            status: "error",
+            error: parseError(error)
+        });
+        try {
+            record.authReady.resolve();
+        }
+        catch {
+            return;
+        }
+    });
+    await Promise.race([
+        record.authReady.promise,
+        new Promise((resolve) => setTimeout(resolve, 250))
+    ]);
+    return record.publicSession;
+}
+export function getOpenAiCodexOauthSession(sessionId) {
+    return requireRecord(sessionId).publicSession;
+}
+export function submitOpenAiCodexOauthManualInput(sessionId, codeOrUrl) {
+    const record = requireRecord(sessionId);
+    if (record.publicSession.status !== "awaiting_browser" &&
+        record.publicSession.status !== "awaiting_manual_input" &&
+        record.publicSession.status !== "starting") {
+        throw new Error("OpenAI Codex OAuth session is not waiting for input.");
+    }
+    record.manualInput.resolve(codeOrUrl);
+    return updateSession(sessionId, {
+        status: "awaiting_manual_input"
+    });
+}
+export function consumeOpenAiCodexOauthCredentials(sessionId) {
+    const record = requireRecord(sessionId);
+    if (record.publicSession.status !== "authorized" || !record.credentials) {
+        throw new Error("OpenAI Codex OAuth session is not authorized yet.");
+    }
+    updateSession(sessionId, {
+        status: "consumed"
+    });
+    return {
+        kind: "oauth",
+        provider: "openai-codex",
+        access: String(record.credentials.access),
+        refresh: String(record.credentials.refresh),
+        expires: Number(record.credentials.expires),
+        accountId: typeof record.credentials.accountId === "string"
+            ? record.credentials.accountId
+            : ""
+    };
+}

package/dist/server/services/psyche-observation-calendar.js

@@ -0,0 +1,46 @@
+import { psycheObservationCalendarPayloadSchema } from "../psyche-types.js";
+import { listNotesByObservedAtRange, resolveNoteObservedAt } from "../repositories/notes.js";
+import { filterOwnedEntities } from "../repositories/entity-ownership.js";
+import { listBehaviorPatterns, listTriggerReports } from "../repositories/psyche.js";
+function collectAvailableTags(observations) {
+    const seen = new Set();
+    const tags = [];
+    for (const observation of observations) {
+        for (const tag of observation.note.tags ?? []) {
+            const normalized = tag.trim().toLowerCase();
+            if (!normalized || seen.has(normalized)) {
+                continue;
+            }
+            seen.add(normalized);
+            tags.push(tag);
+        }
+    }
+    return tags.sort((left, right) => left.localeCompare(right));
+}
+export function getPsycheObservationCalendar({ from, to, userIds }) {
+    const patterns = filterOwnedEntities("behavior_pattern", listBehaviorPatterns(), userIds);
+    const reports = filterOwnedEntities("trigger_report", listTriggerReports(200), userIds);
+    const notes = listNotesByObservedAtRange({ from, to, userIds, limit: 600 });
+    const patternsById = new Map(patterns.map((pattern) => [pattern.id, pattern]));
+    const reportsById = new Map(reports.map((report) => [report.id, report]));
+    const observations = notes.map((note) => ({
+        id: note.id,
+        observedAt: resolveNoteObservedAt(note),
+        note,
+        linkedPatterns: note.links
+            .filter((link) => link.entityType === "behavior_pattern")
+            .map((link) => patternsById.get(link.entityId) ?? null)
+            .filter((pattern) => pattern !== null),
+        linkedReports: note.links
+            .filter((link) => link.entityType === "trigger_report")
+            .map((link) => reportsById.get(link.entityId) ?? null)
+            .filter((report) => report !== null)
+    }));
+    return psycheObservationCalendarPayloadSchema.parse({
+        generatedAt: new Date().toISOString(),
+        from,
+        to,
+        observations,
+        availableTags: collectAvailableTags(observations)
+    });
+}