forge-openclaw-plugin 0.2.24 → 0.2.26

package/dist/server/{services → server/src/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/server/src/services/google-calendar-oauth-config.js

@@ -0,0 +1,176 @@
+import { createDecipheriv, createHash } from "node:crypto";
+const GOOGLE_CALLBACK_PATH = "/api/v1/calendar/oauth/google/callback";
+const DEFAULT_APP_PORT = "4317";
+const DEFAULT_APP_BASE_URL = `http://127.0.0.1:${DEFAULT_APP_PORT}`;
+const PACKAGED_DEFAULT_GOOGLE_CREDENTIAL_KEY_MATERIAL = [
+    "forge",
+    "desktop",
+    "oauth",
+    "default",
+    "google",
+    "bundle",
+    "2026",
+    "local"
+];
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_ID_ENCRYPTED = {
+    iv: "2fc1a6723312a10b7d176f13",
+    data: "9fbdf9dfcd1cc8674fa46150dd0f4678df8ce1ba52cdf0ceb4d4a76c9c5df01b3d8a21f194201c827524a6e06b0d4a55c7002edb3fa20b76b67f540e46ba28f506a73edaf6559a1d",
+    tag: "1965dfe1213ecd888e46ea59241d03a9"
+};
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET_ENCRYPTED = {
+    iv: "5a6ca66625e0ff5559b34f99",
+    data: "b80dec231f029d92a13426ad3f0b851e20a5b35ec6691e517744fd65349144e75005f1",
+    tag: "9d2cfd8a153d91f60d8c628bbe1c2f25"
+};
+const DEFAULT_DEV_WEB_ORIGINS = [
+    "http://127.0.0.1:3027",
+    "http://localhost:3027"
+];
+function decryptPackagedGoogleOauthValue(payload) {
+    const key = createHash("sha256")
+        .update(PACKAGED_DEFAULT_GOOGLE_CREDENTIAL_KEY_MATERIAL.join(":"))
+        .digest();
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(payload.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(payload.tag, "hex"));
+    const decrypted = Buffer.concat([
+        decipher.update(Buffer.from(payload.data, "hex")),
+        decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+}
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_ID = decryptPackagedGoogleOauthValue(PACKAGED_DEFAULT_GOOGLE_CLIENT_ID_ENCRYPTED);
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET = decryptPackagedGoogleOauthValue(PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET_ENCRYPTED);
+function runtimeOriginFromEnv(env) {
+    const port = env.PORT?.trim() || DEFAULT_APP_PORT;
+    return `http://127.0.0.1:${port}`;
+}
+function normalizeOrigin(value, fieldLabel) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`${fieldLabel} must be a full URL.`);
+    }
+    if (url.protocol !== "http:") {
+        throw new Error(`${fieldLabel} must use http in local Forge mode.`);
+    }
+    if (url.pathname !== "/" && url.pathname !== "") {
+        throw new Error(`${fieldLabel} must not include a path.`);
+    }
+    return url.origin;
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "127.0.0.1" || hostname === "localhost";
+}
+function normalizeLoopbackOrigin(value, fieldLabel) {
+    const origin = normalizeOrigin(value, fieldLabel);
+    const url = new URL(origin);
+    if (!isLoopbackHostname(url.hostname)) {
+        throw new Error(`${fieldLabel} must use localhost or 127.0.0.1 in local Forge mode.`);
+    }
+    return origin;
+}
+function normalizeRedirectUri(value, appBaseUrl) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("GOOGLE_REDIRECT_URI must be a full URL.");
+    }
+    if (url.protocol !== "http:") {
+        throw new Error("GOOGLE_REDIRECT_URI must use http in local Forge mode.");
+    }
+    if (!isLoopbackHostname(url.hostname)) {
+        throw new Error("GOOGLE_REDIRECT_URI must use localhost or 127.0.0.1 in local Forge mode.");
+    }
+    if (url.pathname !== GOOGLE_CALLBACK_PATH) {
+        throw new Error(`GOOGLE_REDIRECT_URI must end with ${GOOGLE_CALLBACK_PATH}.`);
+    }
+    if (url.origin !== appBaseUrl) {
+        throw new Error(`GOOGLE_REDIRECT_URI must use the same origin as APP_BASE_URL (${appBaseUrl}).`);
+    }
+    return url.toString();
+}
+function normalizeAllowedOrigins(value, appBaseUrl) {
+    const rawValues = value && value.trim().length > 0
+        ? value
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : [appBaseUrl, ...DEFAULT_DEV_WEB_ORIGINS];
+    const normalized = rawValues.map((entry) => normalizeLoopbackOrigin(entry, "GOOGLE_ALLOWED_ORIGINS"));
+    return Array.from(new Set(normalized));
+}
+export function getGoogleCalendarOauthCallbackPath() {
+    return GOOGLE_CALLBACK_PATH;
+}
+export function resolveGoogleCalendarOauthPublicConfig(env = process.env, overrides) {
+    const runtimeOrigin = runtimeOriginFromEnv(env);
+    const appBaseUrl = normalizeLoopbackOrigin(env.APP_BASE_URL?.trim() ||
+        env.APP_URL?.trim() ||
+        DEFAULT_APP_BASE_URL, env.APP_BASE_URL?.trim() ? "APP_BASE_URL" : "APP_URL");
+    const redirectUri = normalizeRedirectUri(env.GOOGLE_REDIRECT_URI?.trim() || `${appBaseUrl}${GOOGLE_CALLBACK_PATH}`, appBaseUrl);
+    const allowedOrigins = normalizeAllowedOrigins(env.GOOGLE_ALLOWED_ORIGINS, appBaseUrl);
+    const storedClientId = overrides?.clientId?.trim() || "";
+    const storedClientSecret = overrides?.clientSecret?.trim() || "";
+    const envClientId = env.GOOGLE_CLIENT_ID?.trim() || "";
+    const envClientSecret = env.GOOGLE_CLIENT_SECRET?.trim() || "";
+    const hasStoredOverride = storedClientId.length > 0 || storedClientSecret.length > 0;
+    const hasEnvOverride = envClientId.length > 0 || envClientSecret.length > 0;
+    const clientId = hasStoredOverride
+        ? storedClientId
+        : hasEnvOverride
+            ? envClientId
+            : PACKAGED_DEFAULT_GOOGLE_CLIENT_ID.trim();
+    const clientSecret = hasStoredOverride
+        ? storedClientSecret
+        : hasEnvOverride
+            ? envClientSecret
+            : PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET.trim();
+    const isConfigured = clientId.length > 0;
+    const hasIncompleteStoredOverride = storedClientId.length > 0 !== storedClientSecret.length > 0;
+    const setupMessage = hasIncompleteStoredOverride
+        ? "Google OAuth override is incomplete for this Forge install. Save both the client ID and client secret together, or clear both fields to use the packaged default."
+        : isConfigured
+            ? "Google Calendar sign-in is configured for local Forge. Open Forge on localhost or 127.0.0.1 on the same machine that is running Forge, because Google will redirect back to the local callback on that machine."
+            : "Google client ID is not set for this Forge install.";
+    return {
+        clientId,
+        clientSecret,
+        storedClientId,
+        storedClientSecret,
+        appBaseUrl,
+        redirectUri,
+        allowedOrigins,
+        usesPkce: true,
+        requiresServerClientSecret: false,
+        oauthClientType: "desktop_app",
+        authMode: "localhost_pkce",
+        isConfigured,
+        isReadyForPairing: isConfigured && !hasIncompleteStoredOverride,
+        isLocalOnly: true,
+        runtimeOrigin,
+        setupMessage
+    };
+}
+export function resolveGoogleCalendarOauthPrivateConfig(env = process.env, overrides) {
+    return resolveGoogleCalendarOauthPublicConfig(env, overrides);
+}
+export function isGoogleCalendarOriginAllowed(origin, allowedOrigins) {
+    try {
+        return allowedOrigins.includes(new URL(origin).origin);
+    }
+    catch {
+        return false;
+    }
+}
+export function isGoogleCalendarLoopbackOrigin(origin) {
+    try {
+        return isLoopbackHostname(new URL(origin).hostname);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/server/src/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/server/src/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)
+    });
+}