forge-openclaw-plugin 0.2.24 → 0.2.26

package/dist/server/{app.js → server/src/app.js}

@@ -1,27 +1,34 @@
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import multipart from "@fastify/multipart";
-import { ZodError } from "zod";
+import { CronExpressionParser } from "cron-parser";
+import { z, ZodError } from "zod";
 import { configureDatabase, configureDatabaseSeeding, runInTransaction } from "./db.js";
 import { HttpError, isHttpError } from "./errors.js";
 import { listActivityEvents, listActivityEventsForTask, recordActivityEvent, removeActivityEvent } from "./repositories/activity-events.js";
 import { approveApprovalRequest, createAgentAction, createInsight, createInsightFeedback, deleteInsight, getInsightById, listAgentActions, listApprovalRequests, listInsights, rejectApprovalRequest, updateInsight } from "./repositories/collaboration.js";
+import { createAiConnector, deleteAiConnector, getAiConnectorById, getAiConnectorBySlug, getAiConnectorConversationForConnector, listAiConnectorRuns, listAiConnectors, runAiConnector, updateAiConnector } from "./repositories/ai-connectors.js";
+import { createAiProcessor, createAiProcessorLink, deleteAiProcessor, deleteAiProcessorLink, getAiProcessorById, getAiProcessorBySlug, listAiProcessors, getSurfaceProcessorGraph, runAiProcessor, updateAiProcessor } from "./repositories/ai-processors.js";
 import { listEventLog } from "./repositories/event-log.js";
 import { createDiagnosticMessage, DIAGNOSTIC_LOG_RETENTION_SWEEP_INTERVAL_MS, enforceDiagnosticLogRetention, listDiagnosticLogs, normalizeDiagnosticSource, recordDiagnosticLog, serializeDiagnosticError } from "./repositories/diagnostic-logs.js";
 import { createGoal, getGoalById, listGoals, updateGoal } from "./repositories/goals.js";
+import { getSurfaceLayout, resetSurfaceLayout, saveSurfaceLayout } from "./repositories/surface-layouts.js";
+import { buildConnectorOutputCatalogEntry, listForgeBoxCatalog } from "./connectors/box-registry.js";
 import { createHabit, createHabitCheckIn, deleteHabitCheckIn, getHabitById, listHabits, updateHabit } from "./repositories/habits.js";
 import { listDomains } from "./repositories/domains.js";
 import { buildNotesSummaryByEntity, createNote, getNoteById, listNotes, updateNote } from "./repositories/notes.js";
 import { createWikiIngestJobSchema, createUploadedWikiIngestJob, createWikiSpace, createWikiSpaceSchema, deleteWikiIngestJob, deleteWikiProfile, getWikiHealth, getWikiIngestJob, getWikiHomePageDetail, getWikiPageDetail, getWikiPageDetailBySlug, getWikiSettingsPayload, ingestWikiSource, listWikiIngestJobs, listWikiLlmProfiles, listWikiPageTree, listWikiPages, listWikiSpaces, processWikiIngestJob, reindexWikiEmbeddings, reindexWikiEmbeddingsSchema, rerunWikiIngestJob, reviewWikiIngestJob, reviewWikiIngestJobSchema, searchWikiPages, syncWikiVaultFromDisk, syncWikiVaultSchema, testWikiLlmProfileSchema, upsertWikiEmbeddingProfile, upsertWikiEmbeddingProfileSchema, upsertWikiLlmProfile, upsertWikiLlmProfileSchema, wikiSearchQuerySchema } from "./repositories/wiki-memory.js";
 import { filterOwnedEntities, setEntityOwner } from "./repositories/entity-ownership.js";
 import { createBehavior, createBehaviorPattern, createBeliefEntry, createEmotionDefinition, createEventType, createModeGuideSession, createModeProfile, createPsycheValue, createTriggerReport, getBehaviorById, getBehaviorPatternById, getBeliefEntryById, getEmotionDefinitionById, getEventTypeById, getModeGuideSessionById, getModeProfileById, getPsycheValueById, getTriggerReportById, listBehaviors, listBehaviorPatterns, listBeliefEntries, listEmotionDefinitions, listEventTypes, listModeGuideSessions, listModeProfiles, listPsycheValues, listSchemaCatalog, listTriggerReports, updateBehavior, updateBehaviorPattern, updateBeliefEntry, updateEmotionDefinition, updateEventType, updateModeGuideSession, updateModeProfile, updatePsycheValue, updateTriggerReport } from "./repositories/psyche.js";
+import { cloneQuestionnaireInstrument, completeQuestionnaireRun, createQuestionnaireInstrument, ensureQuestionnaireDraftVersion, getQuestionnaireInstrumentDetail, getQuestionnaireRunDetail, listQuestionnaireInstruments, publishQuestionnaireDraftVersion, startQuestionnaireRun, updateQuestionnaireDraftVersion, updateQuestionnaireRun } from "./repositories/questionnaires.js";
 import { createProject, updateProject } from "./repositories/projects.js";
 import { createPreferenceCatalog, createPreferenceCatalogItem, createPreferenceContext, createPreferenceItem, createPreferenceItemFromEntity, deletePreferenceCatalog, deletePreferenceCatalogItem, getPreferenceWorkspace, mergePreferenceContexts, startPreferenceGame, submitAbsoluteSignal, submitPairwiseJudgment, updatePreferenceCatalog, updatePreferenceCatalogItem, updatePreferenceContext, updatePreferenceItem, updatePreferenceScore } from "./repositories/preferences.js";
 import { createStrategy, getStrategyById, listStrategies, updateStrategy } from "./repositories/strategies.js";
 import { createManualRewardGrant, getDailyAmbientXp, getRewardRuleById, listRewardLedger, listRewardRules, recordWorkAdjustmentReward, recordSessionEvent, updateRewardRule } from "./repositories/rewards.js";
 import { listAgentIdentities, getSettings, isPsycheAuthRequired, updateSettings, verifyAgentToken } from "./repositories/settings.js";
+import { deleteAiModelConnection, getAiModelConnectionById, readModelConnectionCredential, upsertAiModelConnection } from "./repositories/model-settings.js";
 import { createTag, getTagById, listTags, updateTag } from "./repositories/tags.js";
-import { createUser, ensureSystemUsers, getUserById, listUserAccessGrants, listUserOwnershipSummaries, listUserXpSummaries, listUsers, resolveUserForMutation, updateUserAccessGrant, updateUser } from "./repositories/users.js";
+import { createUser, ensureSystemUsers, getDefaultUser, getUserById, listUserAccessGrants, listUserOwnershipSummaries, listUserXpSummaries, listUsers, resolveUserForMutation, updateUserAccessGrant, updateUser } from "./repositories/users.js";
 import { claimTaskRun, completeTaskRun, focusTaskRun, heartbeatTaskRun, listTaskRuns, recoverTimedOutTaskRuns, releaseTaskRun } from "./repositories/task-runs.js";
 import { createTask, createTaskWithIdempotency, getTaskById, listTasks, uncompleteTask, updateTask } from "./repositories/tasks.js";
 import { createWorkAdjustment } from "./repositories/work-adjustments.js";
@@ -32,20 +39,25 @@ import { buildGamificationOverview, buildGamificationProfile, buildXpMomentumPul
 import { getInsightsPayload } from "./services/insights.js";
 import { createEntities, deleteEntities, deleteEntity, getSettingsBinPayload, restoreEntities, searchEntities, updateEntities } from "./services/entity-crud.js";
 import { getPsycheOverview } from "./services/psyche.js";
+import { getPsycheObservationCalendar } from "./services/psyche-observation-calendar.js";
 import { getProjectBoard, getProjectSummary, listProjectSummaries } from "./services/projects.js";
 import { getWeeklyReviewPayload } from "./services/reviews.js";
 import { finalizeWeeklyReviewClosure } from "./repositories/weekly-reviews.js";
 import { createTaskRunWatchdog } from "./services/task-run-watchdog.js";
 import { suggestTags } from "./services/tagging.js";
-import { CalendarConnectionConflictError, completeMicrosoftCalendarOauth, createCalendarConnection, deleteCalendarEventProjection, discoverCalendarConnection, discoverExistingCalendarConnection, getMicrosoftCalendarOauthSession, listConnectedCalendarConnections, removeCalendarConnection, pushCalendarEventUpdate, readCalendarOverview, syncCalendarConnection, startMicrosoftCalendarOauth, testMicrosoftCalendarOauthConfiguration, listCalendarProviderMetadata, updateCalendarConnectionSelection } from "./services/calendar-runtime.js";
+import { CalendarConnectionConflictError, completeGoogleCalendarOauth, completeMicrosoftCalendarOauth, createCalendarConnection, deleteCalendarEventProjection, discoverCalendarConnection, discoverExistingCalendarConnection, getGoogleCalendarOauthSession, getMicrosoftCalendarOauthSession, listConnectedCalendarConnections, removeCalendarConnection, pushCalendarEventUpdate, readCalendarOverview, syncCalendarConnection, startGoogleCalendarOauth, startMicrosoftCalendarOauth, testMicrosoftCalendarOauthConfiguration, listCalendarProviderMetadata, updateCalendarConnectionSelection } from "./services/calendar-runtime.js";
+import { consumeOpenAiCodexOauthCredentials, getOpenAiCodexOauthSession, startOpenAiCodexOauthSession, submitOpenAiCodexOauthManualInput } from "./services/openai-codex-oauth.js";
 import { PSYCHE_ENTITY_TYPES, createBehaviorSchema, createBeliefEntrySchema, createBehaviorPatternSchema, createEmotionDefinitionSchema, createEventTypeSchema, createModeGuideSessionSchema, createModeProfileSchema, createPsycheValueSchema, createTriggerReportSchema, updateBehaviorSchema, updateBeliefEntrySchema, updateBehaviorPatternSchema, updateEmotionDefinitionSchema, updateEventTypeSchema, updateModeGuideSessionSchema, updateModeProfileSchema, updatePsycheValueSchema, updateTriggerReportSchema } from "./psyche-types.js";
+import { createQuestionnaireInstrumentSchema, publishQuestionnaireVersionSchema, startQuestionnaireRunSchema, updateQuestionnaireRunSchema, updateQuestionnaireVersionSchema } from "./questionnaire-types.js";
 import { createPreferenceCatalogItemSchema, createPreferenceCatalogSchema, createPreferenceContextSchema, createPreferenceItemSchema, enqueueEntityPreferenceItemSchema, mergePreferenceContextsSchema, preferenceWorkspaceQuerySchema, startPreferenceGameSchema, submitAbsoluteSignalSchema, submitPairwiseJudgmentSchema, updatePreferenceCatalogItemSchema, updatePreferenceCatalogSchema, updatePreferenceContextSchema, updatePreferenceItemSchema, updatePreferenceScoreSchema } from "./preferences-types.js";
-import { activityListQuerySchema, activitySourceSchema, createAgentActionSchema, createAgentTokenSchema, batchCreateEntitiesSchema, batchDeleteEntitiesSchema, batchRestoreEntitiesSchema, batchSearchEntitiesSchema, batchUpdateEntitiesSchema, createGoalSchema, createInsightFeedbackSchema, createInsightSchema, createStrategySchema, createUserSchema, createNoteSchema, createProjectSchema, createManualRewardGrantSchema, createCalendarEventSchema, createHabitCheckInSchema, createCalendarConnectionSchema, createDiagnosticLogSchema, discoverCalendarConnectionSchema, startMicrosoftCalendarOauthSchema, testMicrosoftCalendarOauthConfigurationSchema, createHabitSchema, createTaskTimeboxSchema, createWorkBlockTemplateSchema, createSessionEventSchema, createWorkAdjustmentSchema, createTagSchema, calendarOverviewQuerySchema, notesListQuerySchema, updateTagSchema, createTaskSchema, diagnosticLogListQuerySchema, eventsListQuerySchema, operatorLogWorkSchema, projectBoardPayloadSchema, projectListQuerySchema, entityDeleteQuerySchema, removeActivityEventSchema, resolveApprovalRequestSchema, rewardsLedgerQuerySchema, habitListQuerySchema, taskContextPayloadSchema, taskRunClaimSchema, taskRunFocusSchema, taskRunFinishSchema, taskRunHeartbeatSchema, taskRunListQuerySchema, taskListQuerySchema, tagSuggestionRequestSchema, uncompleteTaskSchema, updateSettingsSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateStrategySchema, updateUserSchema, updateCalendarConnectionSchema, updateCalendarEventSchema, updateNoteSchema, updateProjectSchema, updateRewardRuleSchema, updateTaskTimeboxSchema, updateTaskSchema, updateUserAccessGrantSchema, updateWorkBlockTemplateSchema, workAdjustmentResultSchema, finalizeWeeklyReviewResultSchema, goalListQuerySchema, recommendTaskTimeboxesSchema, strategyListQuerySchema } from "./types.js";
+import { activityListQuerySchema, activitySourceSchema, createAgentActionSchema, createAgentTokenSchema, createAiConnectorSchema, createAiProcessorLinkSchema, createAiProcessorSchema, runAiConnectorSchema, writeSurfaceLayoutSchema, upsertAiModelConnectionSchema, testAiModelConnectionSchema, submitOpenAiCodexOauthManualCodeSchema, batchCreateEntitiesSchema, batchDeleteEntitiesSchema, batchRestoreEntitiesSchema, batchSearchEntitiesSchema, batchUpdateEntitiesSchema, createGoalSchema, createInsightFeedbackSchema, createInsightSchema, createStrategySchema, createUserSchema, createNoteSchema, createProjectSchema, createManualRewardGrantSchema, createCalendarEventSchema, createHabitCheckInSchema, createCalendarConnectionSchema, createDiagnosticLogSchema, discoverCalendarConnectionSchema, startGoogleCalendarOauthSchema, startMicrosoftCalendarOauthSchema, testMicrosoftCalendarOauthConfigurationSchema, createHabitSchema, createTaskTimeboxSchema, createWorkBlockTemplateSchema, createSessionEventSchema, createWorkAdjustmentSchema, createTagSchema, calendarOverviewQuerySchema, notesListQuerySchema, updateTagSchema, createTaskSchema, diagnosticLogListQuerySchema, eventsListQuerySchema, operatorLogWorkSchema, projectBoardPayloadSchema, projectListQuerySchema, entityDeleteQuerySchema, removeActivityEventSchema, resolveApprovalRequestSchema, rewardsLedgerQuerySchema, habitListQuerySchema, taskContextPayloadSchema, taskRunClaimSchema, taskRunFocusSchema, taskRunFinishSchema, taskRunHeartbeatSchema, taskRunListQuerySchema, taskListQuerySchema, tagSuggestionRequestSchema, uncompleteTaskSchema, updateSettingsSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateStrategySchema, updateUserSchema, updateCalendarConnectionSchema, updateCalendarEventSchema, updateNoteSchema, updateProjectSchema, updateRewardRuleSchema, updateTaskTimeboxSchema, updateTaskSchema, updateUserAccessGrantSchema, updateWorkBlockTemplateSchema, updateAiConnectorSchema, updateAiProcessorSchema, runAiProcessorSchema, workAdjustmentResultSchema, finalizeWeeklyReviewResultSchema, goalListQuerySchema, recommendTaskTimeboxesSchema, strategyListQuerySchema } from "./types.js";
 import { buildOpenApiDocument } from "./openapi.js";
 import { registerWebRoutes } from "./web.js";
 import { createManagerRuntime } from "./managers/runtime.js";
 import { isManagerError } from "./managers/type-guards.js";
-import { createCompanionPairingSession, createCompanionPairingSessionSchema, getCompanionOverview, getFitnessViewData, getSleepViewData, ingestMobileHealthSync, mobileHealthSyncSchema, revokeAllCompanionPairingSessions, revokeAllCompanionPairingSessionsSchema, revokeCompanionPairingSession, verifyCompanionPairing, verifyCompanionPairingSchema, updateSleepMetadata, updateSleepMetadataSchema, updateWorkoutMetadata, updateWorkoutMetadataSchema } from "./health.js";
+import { createCompanionPairingSession, createCompanionPairingSessionSchema, getCompanionOverview, getFitnessViewData, getSleepViewData, ingestMobileHealthSync, mobileHealthSyncSchema, requireValidPairing, revokeAllCompanionPairingSessions, revokeAllCompanionPairingSessionsSchema, revokeCompanionPairingSession, verifyCompanionPairing, verifyCompanionPairingSchema, updateSleepMetadata, updateSleepMetadataSchema, updateWorkoutMetadata, updateWorkoutMetadataSchema } from "./health.js";
+import { createMovementPlace, getMovementAllTimeSummary, getMovementDayDetail, getMovementMobileBootstrap, getMovementTimeline, getMovementSelectionAggregate, getMovementSettings, getMovementTripDetail, getMovementMonthSummary, listMovementPlaces, movementMobileBootstrapSchema, movementMobilePlaceMutationSchema, movementMobileStayPatchSchema, movementMobileTimelineSchema, movementMobileTripPatchSchema, movementPlaceMutationSchema, movementPlacePatchSchema, movementSelectionAggregateSchema, movementStayPatchSchema, movementSettingsPatchSchema, movementTimelineQuerySchema, movementTripPointPatchSchema, movementTripPatchSchema, deleteMovementTripPoint, deleteMovementStay, deleteMovementTrip, updateMovementPlace, updateMovementStay, updateMovementSettings, updateMovementTrip, updateMovementTripPoint } from "./movement.js";
+import { assertWatchReady, buildWatchBootstrap, ingestWatchCaptureBatch, mobileWatchBootstrapSchema, mobileWatchCaptureBatchSchema, mobileWatchHabitCheckInSchema } from "./watch-mobile.js";
 const COMPATIBILITY_SUNSET = "transitional-node";
 function markCompatibilityRoute(reply) {
     reply.header("Deprecation", "true");
@@ -116,8 +128,7 @@ function buildApiBaseUrl(request) {
     if (referer) {
         try {
             const url = new URL(referer);
-            const forgeMounted = url.pathname.startsWith("/forge/");
-            return `${url.origin}${forgeMounted ? "/forge" : ""}/api/v1`;
+            return `${url.origin}/api/v1`;
         }
         catch {
             // Fall through to host-based resolution.
@@ -1881,13 +1892,15 @@ const AGENT_ONBOARDING_CONVERSATION_RULES = [
     "Ask only for what is missing or unclear instead of walking the user through every optional field.",
     "Use a progression of concrete example or intent, working name, purpose or meaning, placement in Forge, operational details, and linked context.",
     "Ask one to three focused questions at a time. One is usually best when the user is uncertain or emotionally loaded.",
+    "If the user already answered the normal opening question, do not repeat it. Move to the next missing clarification.",
+    "Do not over-therapize logistical entities. For tasks, calendar events, work blocks, timeboxes, and task runs, one brief confirming sentence plus one question is usually enough.",
     "Before saving, briefly summarize the working formulation in the user's own language when that would reduce ambiguity.",
     "When updating an entity, start with what is changing, what should stay true, and what prompted the update now."
 ];
 const AGENT_ONBOARDING_ENTITY_CONVERSATION_PLAYBOOKS = [
     {
         focus: "goal",
-        openingQuestion: "What direction are you trying to hold onto here?",
+        openingQuestion: "What direction here feels important enough that you want to keep it in view?",
         coachingGoal: "Clarify the direction and why it matters, not just produce a title.",
         askSequence: [
             "Ask what direction or outcome the user wants to keep in view.",
@@ -1898,12 +1911,13 @@ const AGENT_ONBOARDING_ENTITY_CONVERSATION_PLAYBOOKS = [
     },
     {
         focus: "project",
-        openingQuestion: "If this becomes a project, what would you want it to be called and what should it accomplish?",
+        openingQuestion: "If this became a real project, what would you be trying to make true?",
         coachingGoal: "Turn an intention into a bounded workstream with a clear outcome.",
         askSequence: [
-            "Ask what this piece of work should be called.",
+            "Ask what this piece of work is trying to make true.",
             "Ask what outcome would make the project feel real or complete for now.",
             "Ask which goal it belongs under.",
+            "Land on a working name once the scope is clear.",
             "Clarify status, owner, and notes only after the scope is clear."
         ]
     },
@@ -1930,18 +1944,18 @@ const AGENT_ONBOARDING_ENTITY_CONVERSATION_PLAYBOOKS = [
     },
     {
         focus: "habit",
-        openingQuestion: "What is the recurring behavior you want Forge to keep track of?",
+        openingQuestion: "What recurring move are you trying to strengthen or loosen?",
         coachingGoal: "Define the recurring behavior and cadence clearly enough for honest later check-ins.",
         askSequence: [
             "Ask what the recurring behavior is in plain language.",
             "Ask whether doing it is aligned or a slip.",
-            "Ask about cadence and what counts as success in practice.",
+            "Ask about cadence and what counts as an honest check-in in practice.",
             "Ask about links only if they will help later review."
         ]
     },
     {
         focus: "note",
-        openingQuestion: "What do you want this note to preserve, and what should it stay attached to?",
+        openingQuestion: "What feels important to preserve from this?",
         coachingGoal: "Preserve the useful context and link it to the right places without turning the note into a dump.",
         askSequence: [
             "Ask what the note needs to preserve.",
@@ -1994,7 +2008,7 @@ const AGENT_ONBOARDING_ENTITY_CONVERSATION_PLAYBOOKS = [
     },
     {
         focus: "event_type",
-        openingQuestion: "What kind of incident should this category stand for?",
+        openingQuestion: "When this kind of moment happens, what would you want to call it so future reports stay consistent?",
         coachingGoal: "Create a reusable incident category that will actually help future reports stay consistent.",
         askSequence: [
             "Ask what category the label should capture.",
@@ -2004,7 +2018,7 @@ const AGENT_ONBOARDING_ENTITY_CONVERSATION_PLAYBOOKS = [
     },
     {
         focus: "emotion_definition",
-        openingQuestion: "What emotion label do you want to keep reusable in Forge?",
+        openingQuestion: "What emotion do you want Forge to help you name clearly and reuse later?",
         coachingGoal: "Create a reusable emotion label with enough clarity to use consistently later.",
         askSequence: [
             "Ask what emotion label the user wants to preserve.",
@@ -2086,7 +2100,8 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
             "A pattern is usually the best Psyche container for functional analysis.",
             "If the user is describing one specific episode rather than a repeated loop, prefer a trigger report.",
             "Reflect before the next question, and avoid interrogating through the schema fields in order.",
-            "If the user asks to understand the loop first, do not lead with a finished working diagnosis or title before asking at least one clarifying question."
+            "If the user asks to understand the loop first, do not lead with a finished working diagnosis or title before asking at least one clarifying question.",
+            "Before you ask how to change the loop, ask what it is protecting, preventing, or managing for the user."
         ]
     },
     {
@@ -2127,7 +2142,8 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
         notes: [
             "Keep the user close to observable behavior rather than jumping straight to labels.",
             "When the behavior clearly belongs inside a larger loop, suggest linking or also mapping the related behavior_pattern.",
-            "If the user asks for understanding before storage, ask about the recent example and function of the move before classifying it."
+            "If the user asks for understanding before storage, ask about the recent example and function of the move before classifying it.",
+            "Ask what the move is trying to do for the user before moving into replacement planning."
         ]
     },
     {
@@ -2157,6 +2173,7 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
         ],
         exampleQuestions: [
             "If we turned that reaction into one sentence, what would it sound like?",
+            "When that reaction hits, what does it start telling you?",
             "Is it more of an always/never belief, or an if-then rule?",
             "How true does it feel right now from 0 to 100?",
             "What seems to support it, and what weakens it?",
@@ -2166,7 +2183,8 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
         notes: [
             "Schema catalog entries are reference concepts; belief_entry is the user-owned record.",
             "If no schema catalog match is known, omit schemaId rather than inventing one.",
-            "Do not argue the user out of the belief. Reflect it, understand its function, and then collaboratively test for flexibility."
+            "Do not argue the user out of the belief. Reflect it, understand its function, and then collaboratively test for flexibility.",
+            "When the wording is nearly there, ask whether it feels true enough before you move into confidence, evidence, or alternative-belief details."
         ]
     },
     {
@@ -2199,6 +2217,7 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
         ],
         exampleQuestions: [
             "When this part shows up, what is it like from the inside?",
+            "When this part takes over, what is it trying to protect?",
             "What kind of part does this feel like: coping, child, critic-parent, healthy-adult, or happy-child?",
             "If you gave this mode a name, what would it be?",
             "What is it afraid would happen if it stopped doing its job?",
@@ -2227,6 +2246,7 @@ const AGENT_ONBOARDING_PSYCHE_PLAYBOOKS = [
         highValueOptionalFields: [],
         exampleQuestions: [
             "What just happened that brought this up right now?",
+            "What just happened before this part came online?",
             "If this part had a voice, what would it be saying?",
             "What is it trying to protect you from?",
             "What does it seem to need from you or from someone else?",
@@ -2322,7 +2342,8 @@ const AGENT_ONBOARDING_TOOL_INPUT_CATALOG = [
             "entityType alone is never enough; full data is required.",
             "Batch multiple related creates together when they come from one user ask.",
             "Goal, project, and task creates can include notes: [{ contentMarkdown, author?, tags?, destroyAt?, links? }] and Forge will auto-link those notes to the newly created entity.",
-            "The same batch create route also handles calendar_event, work_block_template, and task_timebox. Calendar-event creates still trigger downstream projection sync when a writable provider calendar is selected."
+            "The same batch create route also handles calendar_event, work_block_template, task_timebox, preference_catalog, preference_catalog_item, preference_context, preference_item, and questionnaire_instrument.",
+            "Calendar-event creates still trigger downstream projection sync when a writable provider calendar is selected."
         ],
         example: '{"operations":[{"entityType":"task","data":{"title":"Write the public release notes","projectId":"project_123","status":"focus","notes":[{"contentMarkdown":"Starting from the changelog draft and the last QA pass."}]},"clientRef":"task-1"}]}'
     },
@@ -2342,7 +2363,7 @@ const AGENT_ONBOARDING_TOOL_INPUT_CATALOG = [
             "Project lifecycle is status-driven: patch project.status to active, paused, or completed instead of looking for separate suspend, restart, or finish routes.",
             "Setting project.status to completed finishes the project and auto-completes linked unfinished tasks through the normal task completion path.",
             "Task and project scheduling rules stay on these same entity patches. Update task.schedulingRules, task.plannedDurationSeconds, or project.schedulingRules here.",
-            "Use this same route to move or relink calendar_event records and to edit work_block_template or task_timebox records without switching to narrower calendar CRUD tools."
+            "Use this same route to move or relink calendar_event records, edit work_block_template or task_timebox records, and do normal field updates on preference_catalog, preference_catalog_item, preference_context, preference_item, and questionnaire_instrument."
         ],
         example: '{"operations":[{"entityType":"project","id":"project_123","patch":{"status":"completed"},"clientRef":"project-finish-1"}]}'
     },
@@ -2548,10 +2569,10 @@ const AGENT_ONBOARDING_TOOL_INPUT_CATALOG = [
         toolName: "forge_connect_calendar_provider",
         summary: "Create a Forge calendar connection for Google, Apple, Exchange Online, or custom CalDAV.",
         whenToUse: "Use only when the operator explicitly wants Forge connected to an external calendar provider.",
-        inputShape: '{ provider: "google"|"apple"|"caldav"|"microsoft", label: string, username?: string, clientId?: string, clientSecret?: string, refreshToken?: string, password?: string, serverUrl?: string, authSessionId?: string, selectedCalendarUrls: string[], forgeCalendarUrl?: string, createForgeCalendar?: boolean }',
+        inputShape: '{ provider: "google"|"apple"|"caldav"|"microsoft", label: string, username?: string, password?: string, serverUrl?: string, authSessionId?: string, selectedCalendarUrls: string[], forgeCalendarUrl?: string, createForgeCalendar?: boolean }',
         requiredFields: ["provider", "label", "provider-specific credentials"],
         notes: [
-            "Google uses OAuth client credentials plus a refresh token.",
+            "Google now uses an interactive localhost Authorization Code + PKCE flow. The user signs in interactively on the same machine running Forge, Forge exchanges the authorization code on the backend, and forge_connect_calendar_provider should only be used after a completed Google authSessionId exists.",
             "Apple starts from https://caldav.icloud.com and autodiscovers the principal plus calendars after authentication.",
             "Exchange Online uses Microsoft Graph. In the current Forge implementation it is read-only: Forge mirrors the selected calendars but does not publish work blocks or timeboxes back to Microsoft.",
             "In the current self-hosted local runtime, Exchange Online now uses an interactive Microsoft public-client sign-in flow with PKCE after the operator has saved the Microsoft client ID, tenant, and redirect URI in Settings -> Calendar. Non-interactive callers should treat Microsoft connection setup as a Settings-owned operator action unless a completed authSessionId already exists.",
@@ -2777,6 +2798,9 @@ function buildAgentOnboardingPayload(request) {
             wiki: "Forge Wiki is the file-first memory layer: local Markdown pages plus media, backlinks, optional embeddings, explicit spaces, and structured links back to Forge entities.",
             sleepSession: "A sleep session is a first-class health record with timing, sleep and bed duration, stage breakdown, recovery metrics, annotations, and Forge links back to planning or Psyche context.",
             workoutSession: "A workout session is a first-class sports record imported from HealthKit or generated from a habit. It holds workout type, timing, energy or distance when available, subjective effort, narrative context, and Forge links.",
+            preferences: "Forge Preferences is the explicit taste-modeling domain. It has workspaces, contexts, concept libraries, direct items, pairwise judgments, direct signals, and inferred scores.",
+            questionnaire: "Forge Psyche questionnaires are structured reusable instruments with provenance, scoring, draft and published versions, and user-owned answer runs.",
+            selfObservation: "Forge self-observation is a dedicated Psyche calendar view backed by observed notes timestamped by frontmatter.observedAt, including deliberate reflection notes and rolling movement notes from the companion.",
             insight: "An agent-authored observation or recommendation grounded in Forge data.",
             calendar: "A connected calendar source mirrored into Forge. Calendar state combines provider events, recurring work blocks, and task timeboxes.",
             workBlock: "A recurring half-day or custom time window such as Main Activity, Secondary Activity, Third Activity, Rest, Holiday, or Custom. Work blocks can allow or block work by default, can define active date bounds, and remain editable through the calendar surface.",
@@ -2814,6 +2838,94 @@ function buildAgentOnboardingPayload(request) {
             "Behavior patterns, behaviors, beliefs, modes, and trigger reports cross-link to describe one reflective model rather than isolated records.",
             "Insights can point at one entity, but they exist to capture interpretation or advice rather than raw work items."
         ],
+        entityRouteModel: {
+            batchCrudEntities: [
+                "goal",
+                "project",
+                "task",
+                "strategy",
+                "habit",
+                "tag",
+                "note",
+                "insight",
+                "calendar_event",
+                "work_block_template",
+                "task_timebox",
+                "psyche_value",
+                "behavior_pattern",
+                "behavior",
+                "belief_entry",
+                "mode_profile",
+                "mode_guide_session",
+                "event_type",
+                "emotion_definition",
+                "trigger_report",
+                "preference_catalog",
+                "preference_catalog_item",
+                "preference_context",
+                "preference_item",
+                "questionnaire_instrument"
+            ],
+            batchRoutes: {
+                search: "/api/v1/entities/search",
+                create: "/api/v1/entities/create",
+                update: "/api/v1/entities/update",
+                delete: "/api/v1/entities/delete",
+                restore: "/api/v1/entities/restore"
+            },
+            actionEntities: {
+                task_run: {
+                    readModel: "/api/v1/operator/context",
+                    actions: {
+                        start: "/api/v1/tasks/:taskId/runs",
+                        heartbeat: "/api/v1/task-runs/:id/heartbeat",
+                        focus: "/api/v1/task-runs/:id/focus",
+                        complete: "/api/v1/task-runs/:id/complete",
+                        release: "/api/v1/task-runs/:id/release"
+                    }
+                },
+                questionnaire_run: {
+                    read: "/api/v1/psyche/questionnaire-runs/:id",
+                    actions: {
+                        start: "/api/v1/psyche/questionnaires/:id/runs",
+                        update: "/api/v1/psyche/questionnaire-runs/:id",
+                        complete: "/api/v1/psyche/questionnaire-runs/:id/complete"
+                    }
+                },
+                preferences: {
+                    workspace: "/api/v1/preferences/workspace",
+                    actions: {
+                        startGame: "/api/v1/preferences/game/start",
+                        mergeContexts: "/api/v1/preferences/contexts/merge",
+                        enqueueFromEntity: "/api/v1/preferences/items/from-entity",
+                        submitJudgment: "/api/v1/preferences/judgments",
+                        submitSignal: "/api/v1/preferences/signals",
+                        overrideScore: "/api/v1/preferences/items/:id/score"
+                    }
+                },
+                questionnaires: {
+                    list: "/api/v1/psyche/questionnaires",
+                    detail: "/api/v1/psyche/questionnaires/:id",
+                    actions: {
+                        clone: "/api/v1/psyche/questionnaires/:id/clone",
+                        ensureDraft: "/api/v1/psyche/questionnaires/:id/draft",
+                        publishDraft: "/api/v1/psyche/questionnaires/:id/publish"
+                    }
+                },
+                selfObservation: {
+                    read: "/api/v1/psyche/self-observation/calendar",
+                    writeModel: "Create or update an observed note with frontmatter.observedAt. Manual reflections usually carry the Self-observation tag, while movement sync can also publish rolling observed notes tagged movement."
+                },
+                sleep_session: {
+                    read: "/api/v1/health/sleep",
+                    update: "/api/v1/health/sleep/:id"
+                },
+                workout_session: {
+                    read: "/api/v1/health/fitness",
+                    update: "/api/v1/health/workouts/:id"
+                }
+            }
+        },
         multiUserModel: {
             summary: "Forge is multi-user by default. Humans and bots share one entity graph, with explicit ownership on every record and directional relationship settings between every pair of users.",
             defaultUserScopeBehavior: "If no user scope is provided, Forge returns all visible users. Use userId or repeated userIds when an agent should focus on one owner namespace or on a specific human/bot slice.",
@@ -2858,6 +2970,7 @@ function buildAgentOnboardingPayload(request) {
                 ],
                 configNotes: [
                     "Localhost and Tailscale targets can usually use the operator-session path without a long-lived token.",
+                    "Use a distinct actor label such as Albert (claw) so OpenClaw-originated work stays obvious in Forge provenance.",
                     "Create each agent as a Forge bot user, then use userId or userIds in tool inputs whenever the agent should focus on one human, one bot, or a specific collaboration slice."
                 ]
             },
@@ -2875,6 +2988,7 @@ function buildAgentOnboardingPayload(request) {
                 ],
                 configNotes: [
                     "Hermes keeps its durable Forge config under ~/.hermes/forge/config.json.",
+                    "Use a distinct actor label such as Albert (hermes) so Hermes-originated work stays obvious in Forge provenance.",
                     "Hermes uses the same multi-user scoping rules and should pass userIds intentionally when working across humans and bots.",
                     "The Forge relationship graph still decides whether Hermes may see, message, plan for, or affect another owner."
                 ]
@@ -2958,8 +3072,8 @@ function buildAgentOnboardingPayload(request) {
             saveSuggestionPlacement: "end_of_message",
             saveSuggestionTone: "gentle_optional",
             maxQuestionsPerTurn: 1,
-            psycheExplorationRule: "When a Psyche entity needs understanding first, begin with one exploratory question before any working formulation, replacement belief, suggested title, or save pitch. Keep the opening reflection to one or two short sentences, stay in plain prose instead of bullets or numbered lists, keep that first reply short, do not mention Forge search or save structure yet, avoid colons or list-shaped phrasing, and wait for the user's answer before offering a fuller formulation.",
-            psycheOpeningQuestionRule: "Prefer a concrete opening question tied to the entity: ask when the value mattered, what happened the last time the pattern appeared, what felt threatened before the behavior, what the feared outcome is inside the belief, what the mode is protecting, what the part says to do, or where the shift began in the incident.",
+            psycheExplorationRule: "When a Psyche entity needs understanding first, begin with one exploratory question before any working formulation, replacement belief, suggested title, or save pitch. Keep the opening reflection to one or two short sentences, stay in plain prose instead of bullets or numbered lists, keep that first reply short, do not mention Forge search or save structure yet, avoid colons or list-shaped phrasing, prefer what/when/how over why until the experience is grounded, and wait for the user's answer before offering a fuller formulation.",
+            psycheOpeningQuestionRule: "Prefer a concrete opening question tied to the entity: ask when the value mattered, what happened the last time the pattern appeared, what cue or body signal came first before the behavior, what the belief starts saying about self or outcome, what feels most at risk inside the mode, what the part is trying to get the user to do or stop doing, or where the shift began in the incident. Reflect briefly before the question and stay in one follow-up lane at a time.",
             duplicateCheckRoute: "/api/v1/entities/search",
             uiSuggestionRule: "offer_visual_ui_when_review_or_editing_would_be_easier",
             browserFallbackRule: "Do not open the Forge UI or a browser just to create or update normal entities when the batch entity tools can do the job.",
@@ -3528,8 +3642,43 @@ export async function buildServer(options = {}) {
         }
     }, DIAGNOSTIC_LOG_RETENTION_SWEEP_INTERVAL_MS);
     diagnosticRetentionTimer.unref?.();
+    const activeCronRuns = new Set();
+    const cronSchedulerTimer = setInterval(() => {
+        const now = new Date();
+        for (const processor of listAiProcessors()) {
+            if (processor.triggerMode !== "cron" ||
+                !processor.endpointEnabled ||
+                !processor.cronExpression.trim() ||
+                activeCronRuns.has(processor.id)) {
+                continue;
+            }
+            try {
+                const interval = CronExpressionParser.parse(processor.cronExpression, {
+                    currentDate: processor.lastRunAt && Number.isFinite(Date.parse(processor.lastRunAt))
+                        ? processor.lastRunAt
+                        : new Date(now.getTime() - 60_000).toISOString()
+                });
+                const nextDueAt = interval.next().toDate();
+                if (nextDueAt.getTime() > now.getTime()) {
+                    continue;
+                }
+                activeCronRuns.add(processor.id);
+                void runAiProcessor(processor.id, { input: "", context: {}, widgetSnapshots: {} }, {
+                    llm: managers.llm,
+                    secrets: managers.secrets
+                }, { trigger: "cron" }).finally(() => {
+                    activeCronRuns.delete(processor.id);
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }, 30_000);
+    cronSchedulerTimer.unref?.();
     app.addHook("onClose", async () => {
         clearInterval(diagnosticRetentionTimer);
+        clearInterval(cronSchedulerTimer);
         taskRunWatchdog?.stop();
         await managers.backgroundJobs.stop();
     });
@@ -3858,6 +4007,147 @@ export async function buildServer(options = {}) {
     app.get("/api/v1/health/fitness", async (request) => ({
         fitness: getFitnessViewData(resolveScopedUserIds(request.query))
     }));
+    app.get("/api/v1/movement/day", async (request) => {
+        const query = request.query;
+        return {
+            movement: getMovementDayDetail({
+                date: typeof query.date === "string" ? query.date : undefined,
+                userIds: resolveScopedUserIds(query)
+            })
+        };
+    });
+    app.get("/api/v1/movement/month", async (request) => {
+        const query = request.query;
+        return {
+            movement: getMovementMonthSummary({
+                month: typeof query.month === "string" ? query.month : undefined,
+                userIds: resolveScopedUserIds(query)
+            })
+        };
+    });
+    app.get("/api/v1/movement/all-time", async (request) => ({
+        movement: getMovementAllTimeSummary(resolveScopedUserIds(request.query))
+    }));
+    app.get("/api/v1/movement/timeline", async (request) => {
+        const parsed = movementTimelineQuerySchema.parse(request.query ?? {});
+        return {
+            movement: getMovementTimeline({
+                ...parsed,
+                userIds: parsed.userIds.length > 0
+                    ? parsed.userIds
+                    : (resolveScopedUserIds(request.query) ?? [])
+            })
+        };
+    });
+    app.get("/api/v1/movement/settings", async (request) => ({
+        settings: getMovementSettings(resolveScopedUserIds(request.query))
+    }));
+    app.patch("/api/v1/movement/settings", async (request) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/settings" });
+        const userId = resolveScopedUserIds(request.query)?.[0] ??
+            getDefaultUser().id;
+        return {
+            settings: updateMovementSettings(userId, movementSettingsPatchSchema.parse(request.body ?? {}), toActivityContext(auth))
+        };
+    });
+    app.get("/api/v1/movement/places", async (request) => ({
+        places: listMovementPlaces(resolveScopedUserIds(request.query))
+    }));
+    app.post("/api/v1/movement/places", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/places" });
+        const userId = resolveScopedUserIds(request.query)?.[0] ??
+            getDefaultUser().id;
+        reply.code(201);
+        return {
+            place: createMovementPlace({
+                ...movementPlaceMutationSchema.parse(request.body ?? {}),
+                userId,
+                source: "user"
+            }, toActivityContext(auth))
+        };
+    });
+    app.patch("/api/v1/movement/places/:id", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/places/:id" });
+        const { id } = request.params;
+        const place = updateMovementPlace(id, movementPlacePatchSchema.parse(request.body ?? {}), toActivityContext(auth));
+        if (!place) {
+            reply.code(404);
+            return { error: "Movement place not found" };
+        }
+        return { place };
+    });
+    app.patch("/api/v1/movement/stays/:id", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/stays/:id" });
+        const { id } = request.params;
+        const stay = updateMovementStay(id, movementStayPatchSchema.parse(request.body ?? {}), toActivityContext(auth));
+        if (!stay) {
+            reply.code(404);
+            return { error: "Movement stay not found" };
+        }
+        return { stay };
+    });
+    app.delete("/api/v1/movement/stays/:id", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/stays/:id" });
+        const { id } = request.params;
+        const result = deleteMovementStay(id, toActivityContext(auth));
+        if (!result) {
+            reply.code(404);
+            return { error: "Movement stay not found" };
+        }
+        return result;
+    });
+    app.patch("/api/v1/movement/trips/:id", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/trips/:id" });
+        const { id } = request.params;
+        const trip = updateMovementTrip(id, movementTripPatchSchema.parse(request.body ?? {}), toActivityContext(auth));
+        if (!trip) {
+            reply.code(404);
+            return { error: "Movement trip not found" };
+        }
+        return { trip };
+    });
+    app.delete("/api/v1/movement/trips/:id", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/trips/:id" });
+        const { id } = request.params;
+        const result = deleteMovementTrip(id, toActivityContext(auth));
+        if (!result) {
+            reply.code(404);
+            return { error: "Movement trip not found" };
+        }
+        return result;
+    });
+    app.patch("/api/v1/movement/trips/:id/points/:pointId", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/trips/:id/points/:pointId" });
+        const { id, pointId } = request.params;
+        const result = updateMovementTripPoint(id, pointId, movementTripPointPatchSchema.parse(request.body ?? {}), toActivityContext(auth));
+        if (!result) {
+            reply.code(404);
+            return { error: "Movement datapoint not found" };
+        }
+        return result;
+    });
+    app.delete("/api/v1/movement/trips/:id/points/:pointId", async (request, reply) => {
+        const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/movement/trips/:id/points/:pointId" });
+        const { id, pointId } = request.params;
+        const result = deleteMovementTripPoint(id, pointId, toActivityContext(auth));
+        if (!result) {
+            reply.code(404);
+            return { error: "Movement datapoint not found" };
+        }
+        return result;
+    });
+    app.get("/api/v1/movement/trips/:id", async (request, reply) => {
+        const { id } = request.params;
+        const movement = getMovementTripDetail(id);
+        if (!movement) {
+            reply.code(404);
+            return { error: "Movement trip not found" };
+        }
+        return { movement };
+    });
+    app.post("/api/v1/movement/selection", async (request) => ({
+        movement: getMovementSelectionAggregate(movementSelectionAggregateSchema.parse(request.body ?? {}))
+    }));
     app.post("/api/v1/health/pairing-sessions", async (request, reply) => {
         requireOperatorSession(request.headers, {
             route: "/api/v1/health/pairing-sessions"
@@ -3895,6 +4185,106 @@ export async function buildServer(options = {}) {
     app.post("/api/v1/mobile/pairing/verify", async (request) => ({
         pairing: verifyCompanionPairing(verifyCompanionPairingSchema.parse(request.body ?? {}))
     }));
+    app.post("/api/v1/mobile/movement/bootstrap", async (request) => {
+        const parsed = movementMobileBootstrapSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        return {
+            movement: getMovementMobileBootstrap(pairing)
+        };
+    });
+    app.post("/api/v1/mobile/movement/places", async (request, reply) => {
+        const parsed = movementMobilePlaceMutationSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        reply.code(201);
+        return {
+            place: createMovementPlace({
+                ...parsed.place,
+                userId: pairing.user_id,
+                source: "companion"
+            }, {
+                actor: "Forge Companion",
+                source: "system"
+            })
+        };
+    });
+    app.post("/api/v1/mobile/movement/timeline", async (request) => {
+        const parsed = movementMobileTimelineSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        return {
+            movement: getMovementTimeline({
+                before: parsed.before,
+                limit: parsed.limit,
+                userIds: [pairing.user_id]
+            })
+        };
+    });
+    app.patch("/api/v1/mobile/movement/stays/:id", async (request, reply) => {
+        const parsed = movementMobileStayPatchSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        const { id } = request.params;
+        const stay = updateMovementStay(id, parsed.patch, {
+            actor: "Forge Companion",
+            source: "system"
+        }, { userId: pairing.user_id });
+        if (!stay) {
+            reply.code(404);
+            return { error: "Movement stay not found" };
+        }
+        return { stay };
+    });
+    app.patch("/api/v1/mobile/movement/trips/:id", async (request, reply) => {
+        const parsed = movementMobileTripPatchSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        const { id } = request.params;
+        const trip = updateMovementTrip(id, parsed.patch, {
+            actor: "Forge Companion",
+            source: "system"
+        }, { userId: pairing.user_id });
+        if (!trip) {
+            reply.code(404);
+            return { error: "Movement trip not found" };
+        }
+        return { trip };
+    });
+    app.post("/api/v1/mobile/watch/bootstrap", async (request) => {
+        const parsed = mobileWatchBootstrapSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        assertWatchReady(pairing);
+        return {
+            watch: buildWatchBootstrap(pairing)
+        };
+    });
+    app.post("/api/v1/mobile/watch/habits/:id/check-ins", async (request, reply) => {
+        const parsed = mobileWatchHabitCheckInSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        assertWatchReady(pairing);
+        const { id } = request.params;
+        const habit = createHabitCheckIn(id, {
+            dateKey: parsed.dateKey,
+            status: parsed.status,
+            note: parsed.note
+        }, { source: "system", actor: `watch:${parsed.dedupeKey}` });
+        if (!habit) {
+            reply.code(404);
+            return { error: "Habit not found" };
+        }
+        return {
+            habit,
+            metrics: buildXpMetricsPayload(),
+            watch: buildWatchBootstrap(pairing, {
+                anchorDateKey: parsed.dateKey
+            })
+        };
+    });
+    app.post("/api/v1/mobile/watch/capture-events:batch", async (request) => {
+        const parsed = mobileWatchCaptureBatchSchema.parse(request.body ?? {});
+        const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+        assertWatchReady(pairing);
+        return {
+            receipt: ingestWatchCaptureBatch(pairing, parsed),
+            watch: buildWatchBootstrap(pairing)
+        };
+    });
     app.post("/api/v1/mobile/healthkit/sync", async (request) => ({
         sync: ingestMobileHealthSync(mobileHealthSyncSchema.parse(request.body ?? {}))
     }));
@@ -3948,6 +4338,88 @@ export async function buildServer(options = {}) {
         const userIds = resolveScopedUserIds(request.query);
         return { overview: getPsycheOverview(userIds) };
     });
+    app.get("/api/v1/psyche/questionnaires", async (request) => {
+        requirePsycheScopedAccess(request.headers, ["psyche.read"], { route: "/api/v1/psyche/questionnaires" });
+        const userIds = resolveScopedUserIds(request.query);
+        return listQuestionnaireInstruments({ userIds });
+    });
+    app.post("/api/v1/psyche/questionnaires", async (request, reply) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaires" });
+        const result = createQuestionnaireInstrument(createQuestionnaireInstrumentSchema.parse(request.body ?? {}), toActivityContext(auth));
+        reply.code(201);
+        return result;
+    });
+    app.get("/api/v1/psyche/questionnaires/:id", async (request) => {
+        requirePsycheScopedAccess(request.headers, ["psyche.read"], { route: "/api/v1/psyche/questionnaires/:id" });
+        const { id } = request.params;
+        const userIds = resolveScopedUserIds(request.query);
+        return getQuestionnaireInstrumentDetail(id, { userIds });
+    });
+    app.post("/api/v1/psyche/questionnaires/:id/clone", async (request, reply) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaires/:id/clone" });
+        const { id } = request.params;
+        const body = (request.body ?? {});
+        const userId = typeof body.userId === "string" && body.userId.trim().length > 0
+            ? body.userId.trim()
+            : null;
+        const result = cloneQuestionnaireInstrument(id, { userId }, toActivityContext(auth));
+        reply.code(201);
+        return result;
+    });
+    app.post("/api/v1/psyche/questionnaires/:id/draft", async (request) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaires/:id/draft" });
+        const { id } = request.params;
+        return ensureQuestionnaireDraftVersion(id, toActivityContext(auth));
+    });
+    app.patch("/api/v1/psyche/questionnaires/:id/draft", async (request) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaires/:id/draft" });
+        const { id } = request.params;
+        return updateQuestionnaireDraftVersion(id, updateQuestionnaireVersionSchema.parse(request.body ?? {}), toActivityContext(auth));
+    });
+    app.post("/api/v1/psyche/questionnaires/:id/publish", async (request) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaires/:id/publish" });
+        const { id } = request.params;
+        return publishQuestionnaireDraftVersion(id, publishQuestionnaireVersionSchema.parse(request.body ?? {}), toActivityContext(auth));
+    });
+    app.post("/api/v1/psyche/questionnaires/:id/runs", async (request, reply) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write", "psyche.read"], { route: "/api/v1/psyche/questionnaires/:id/runs" });
+        const { id } = request.params;
+        const result = startQuestionnaireRun(id, startQuestionnaireRunSchema.parse(request.body ?? {}), toActivityContext(auth));
+        reply.code(201);
+        return result;
+    });
+    app.get("/api/v1/psyche/questionnaire-runs/:id", async (request) => {
+        requirePsycheScopedAccess(request.headers, ["psyche.read"], { route: "/api/v1/psyche/questionnaire-runs/:id" });
+        const { id } = request.params;
+        const userIds = resolveScopedUserIds(request.query);
+        return getQuestionnaireRunDetail(id, { userIds });
+    });
+    app.patch("/api/v1/psyche/questionnaire-runs/:id", async (request) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaire-runs/:id" });
+        const { id } = request.params;
+        return updateQuestionnaireRun(id, updateQuestionnaireRunSchema.parse(request.body ?? {}), toActivityContext(auth));
+    });
+    app.post("/api/v1/psyche/questionnaire-runs/:id/complete", async (request) => {
+        const auth = requirePsycheScopedAccess(request.headers, ["psyche.write"], { route: "/api/v1/psyche/questionnaire-runs/:id/complete" });
+        const { id } = request.params;
+        return completeQuestionnaireRun(id, toActivityContext(auth));
+    });
+    app.get("/api/v1/psyche/self-observation/calendar", async (request) => {
+        requirePsycheScopedAccess(request.headers, ["psyche.read"], { route: "/api/v1/psyche/self-observation/calendar" });
+        const query = calendarOverviewQuerySchema.parse(request.query ?? {});
+        const now = new Date();
+        const from = query.from ??
+            new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const to = query.to ??
+            new Date(now.getTime() + 21 * 24 * 60 * 60 * 1000).toISOString();
+        return {
+            calendar: getPsycheObservationCalendar({
+                from,
+                to,
+                userIds: query.userIds
+            })
+        };
+    });
     app.get("/api/v1/psyche/values", async (request) => {
         requirePsycheScopedAccess(request.headers, ["psyche.read"], { route: "/api/v1/psyche/values" });
         const userIds = resolveScopedUserIds(request.query);
@@ -5239,6 +5711,37 @@ export async function buildServer(options = {}) {
         providers: listCalendarProviderMetadata(),
         connections: listConnectedCalendarConnections()
     }));
+    app.post("/api/v1/calendar/oauth/google/start", async (request) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/calendar/oauth/google/start"
+        });
+        return await startGoogleCalendarOauth(startGoogleCalendarOauthSchema.parse(request.body ?? {}), {
+            browserOrigin: typeof request.body?.browserOrigin ===
+                "string"
+                ? request.body.browserOrigin
+                : null,
+            openerOrigin: typeof request.headers.origin === "string"
+                ? request.headers.origin
+                : typeof request.headers.referer === "string"
+                    ? request.headers.referer
+                    : null,
+            requestBaseOrigin: getRequestOrigin(request)
+        });
+    });
+    app.get("/api/v1/calendar/oauth/google/session/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/calendar/oauth/google/session/:id" });
+        try {
+            return getGoogleCalendarOauthSession(request.params.id);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Unknown Google calendar auth session")) {
+                reply.code(404);
+                return { error: "Google calendar auth session not found" };
+            }
+            throw error;
+        }
+    });
     app.post("/api/v1/calendar/oauth/microsoft/start", async (request) => {
         requireScopedAccess(request.headers, ["write"], {
             route: "/api/v1/calendar/oauth/microsoft/start"
@@ -5311,6 +5814,54 @@ export async function buildServer(options = {}) {
       setTimeout(() => window.close(), 180);
     </script>
   </body>
+</html>`;
+        reply.type("text/html; charset=utf-8");
+        return body;
+    });
+    app.get("/api/v1/calendar/oauth/google/callback", async (request, reply) => {
+        const query = request.query;
+        const result = await completeGoogleCalendarOauth({
+            state: query.state ?? null,
+            code: query.code ?? null,
+            error: query.error ?? null,
+            errorDescription: query.error_description ?? null
+        });
+        const session = result.session;
+        const escapedOrigin = JSON.stringify(result.openerOrigin || "*");
+        const escapedMessage = JSON.stringify({
+            type: "forge:google-calendar-auth",
+            sessionId: session.sessionId,
+            status: session.status
+        });
+        const body = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Forge Google sign-in</title>
+    <style>
+      body{margin:0;font-family:ui-sans-serif,system-ui,sans-serif;background:#0b1320;color:#f8fafc;display:grid;place-items:center;min-height:100vh}
+      main{max-width:30rem;padding:2rem;border:1px solid rgba(255,255,255,.08);border-radius:24px;background:linear-gradient(180deg,rgba(18,28,38,.98),rgba(11,17,28,.98))}
+      h1{margin:0 0 .75rem;font-size:1.15rem}
+      p{margin:0;color:rgba(248,250,252,.72);line-height:1.6}
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${session.status === "authorized" ? "Google account connected" : "Google sign-in needs attention"}</h1>
+      <p>${session.status === "authorized" ? "Forge received your Google account and sent the result back to the calendar setup flow. You can close this window." : (session.error ?? "Forge could not complete Google sign-in. You can close this window and try again from Settings.")}</p>
+    </main>
+    <script>
+      const message = ${escapedMessage};
+      const targetOrigin = ${escapedOrigin};
+      try {
+        if (window.opener && !window.opener.closed) {
+          window.opener.postMessage(message, targetOrigin);
+        }
+      } catch {}
+      setTimeout(() => window.close(), 180);
+    </script>
+  </body>
 </html>`;
         reply.type("text/html; charset=utf-8");
         return body;
@@ -6247,9 +6798,425 @@ export async function buildServer(options = {}) {
     app.patch("/api/v1/settings", async (request) => {
         const auth = requireScopedAccess(request.headers, ["write"], { route: "/api/v1/settings" });
         return {
-            settings: updateSettings(updateSettingsSchema.parse(request.body ?? {}), toActivityContext(auth))
+            settings: updateSettings(updateSettingsSchema.parse(request.body ?? {}), {
+                activity: toActivityContext(auth),
+                secrets: managers.secrets
+            })
+        };
+    });
+    app.post("/api/v1/settings/models/connections", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/settings/models/connections"
+        });
+        const parsed = upsertAiModelConnectionSchema.parse(request.body ?? {});
+        const oauthCredential = parsed.oauthSessionId?.trim()
+            ? consumeOpenAiCodexOauthCredentials(parsed.oauthSessionId.trim())
+            : null;
+        const connection = upsertAiModelConnection(parsed, managers.secrets, {
+            oauthCredential
+        });
+        const currentSettings = getSettings();
+        const selectedWikiConnectionId = currentSettings.modelSettings.forgeAgent.wiki.connectionId;
+        if (selectedWikiConnectionId === connection.id) {
+            updateSettings({
+                modelSettings: {
+                    forgeAgent: {
+                        wiki: {
+                            connectionId: connection.id,
+                            model: parsed.model
+                        }
+                    }
+                }
+            }, { secrets: managers.secrets });
+        }
+        reply.code(201);
+        return { connection };
+    });
+    app.delete("/api/v1/settings/models/connections/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/settings/models/connections/:id" });
+        const deletedId = deleteAiModelConnection(request.params.id, managers.secrets);
+        if (!deletedId) {
+            reply.code(404);
+            return { error: "AI model connection not found" };
+        }
+        return { deletedId };
+    });
+    app.post("/api/v1/settings/models/connections/test", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/settings/models/connections/test" });
+        const parsed = testAiModelConnectionSchema.parse(request.body ?? {});
+        const existing = parsed.connectionId
+            ? getAiModelConnectionById(parsed.connectionId)
+            : null;
+        const credential = parsed.connectionId
+            ? readModelConnectionCredential(parsed.connectionId, managers.secrets)
+            : null;
+        const explicitApiKey = parsed.apiKey?.trim() ||
+            (credential?.kind === "api_key"
+                ? credential.apiKey
+                : credential?.kind === "oauth"
+                    ? credential.access
+                    : null);
+        const result = await managers.llm.testWikiConnection({
+            provider: parsed.provider ?? existing?.provider ?? "openai-api",
+            baseUrl: parsed.baseUrl?.trim() ||
+                existing?.baseUrl ||
+                "https://api.openai.com/v1",
+            model: parsed.model,
+            systemPrompt: "",
+            secretId: null,
+            metadata: {}
+        }, explicitApiKey, ({ level, message, details = {} }) => {
+            recordDiagnosticLog({
+                level,
+                source: normalizeDiagnosticSource(request.headers["x-forge-source"]),
+                scope: typeof details.scope === "string" ? details.scope : "model_settings",
+                eventKey: typeof details.eventKey === "string"
+                    ? details.eventKey
+                    : "model_connection_test",
+                message,
+                route: "/api/v1/settings/models/connections/test",
+                functionName: "testModelConnection",
+                details
+            });
+        });
+        reply.code(200);
+        return { result };
+    });
+    app.post("/api/v1/settings/models/oauth/openai-codex/start", async (request) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/settings/models/oauth/openai-codex/start"
+        });
+        return { session: await startOpenAiCodexOauthSession() };
+    });
+    app.get("/api/v1/settings/models/oauth/openai-codex/session/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/settings/models/oauth/openai-codex/session/:id" });
+        try {
+            return {
+                session: getOpenAiCodexOauthSession(request.params.id)
+            };
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Unknown OpenAI Codex OAuth session")) {
+                reply.code(404);
+                return { error: "OpenAI Codex OAuth session not found" };
+            }
+            throw error;
+        }
+    });
+    app.post("/api/v1/settings/models/oauth/openai-codex/session/:id/manual", async (request) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/settings/models/oauth/openai-codex/session/:id/manual" });
+        return {
+            session: submitOpenAiCodexOauthManualInput(request.params.id, submitOpenAiCodexOauthManualCodeSchema.parse(request.body ?? {})
+                .codeOrUrl)
+        };
+    });
+    app.get("/api/v1/surfaces/:surfaceId/ai-processors", async (request) => {
+        requireScopedAccess(request.headers, ["read"], {
+            route: "/api/v1/surfaces/:surfaceId/ai-processors"
+        });
+        return {
+            graph: getSurfaceProcessorGraph(request.params.surfaceId)
+        };
+    });
+    app.get("/api/v1/surfaces/:surfaceId/layout", async (request) => {
+        requireScopedAccess(request.headers, ["read"], {
+            route: "/api/v1/surfaces/:surfaceId/layout"
+        });
+        return {
+            layout: getSurfaceLayout(request.params.surfaceId)
+        };
+    });
+    app.put("/api/v1/surfaces/:surfaceId/layout", async (request) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/surfaces/:surfaceId/layout"
+        });
+        const surfaceId = request.params.surfaceId;
+        return {
+            layout: saveSurfaceLayout(surfaceId, writeSurfaceLayoutSchema.parse(request.body ?? {}))
+        };
+    });
+    app.post("/api/v1/surfaces/:surfaceId/layout/reset", async (request) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/surfaces/:surfaceId/layout/reset"
+        });
+        return {
+            layout: resetSurfaceLayout(request.params.surfaceId)
+        };
+    });
+    app.post("/api/v1/surfaces/:surfaceId/ai-processors", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/surfaces/:surfaceId/ai-processors"
+        });
+        const body = createAiProcessorSchema.parse({
+            ...(request.body ?? {}),
+            surfaceId: request.params.surfaceId
+        });
+        const processor = createAiProcessor({
+            ...body
+        });
+        reply.code(201);
+        return { processor };
+    });
+    app.patch("/api/v1/ai-processors/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/ai-processors/:id"
+        });
+        const processor = updateAiProcessor(request.params.id, updateAiProcessorSchema.parse(request.body ?? {}));
+        if (!processor) {
+            reply.code(404);
+            return { error: "AI processor not found" };
+        }
+        return { processor };
+    });
+    app.delete("/api/v1/ai-processors/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/ai-processors/:id"
+        });
+        const processor = deleteAiProcessor(request.params.id);
+        if (!processor) {
+            reply.code(404);
+            return { error: "AI processor not found" };
+        }
+        return { processor };
+    });
+    app.post("/api/v1/ai-processor-links", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/ai-processor-links"
+        });
+        const link = createAiProcessorLink(createAiProcessorLinkSchema.parse(request.body ?? {}));
+        reply.code(201);
+        return { link };
+    });
+    app.delete("/api/v1/ai-processor-links/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/ai-processor-links/:id"
+        });
+        const link = deleteAiProcessorLink(request.params.id);
+        if (!link) {
+            reply.code(404);
+            return { error: "AI processor link not found" };
+        }
+        return { link };
+    });
+    app.post("/api/v1/ai-processors/:id/run", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/ai-processors/:id/run"
+        });
+        const processor = getAiProcessorById(request.params.id);
+        if (!processor) {
+            reply.code(404);
+            return { error: "AI processor not found" };
+        }
+        return await runAiProcessor(processor.id, runAiProcessorSchema.parse(request.body ?? {}), {
+            llm: managers.llm,
+            secrets: managers.secrets
+        }, { trigger: "manual" });
+    });
+    app.get("/api/v1/aiproc/:slug", async (request, reply) => {
+        requireScopedAccess(request.headers, ["read"], {
+            route: "/api/v1/aiproc/:slug"
+        });
+        const processor = getAiProcessorBySlug(request.params.slug);
+        if (!processor) {
+            reply.code(404);
+            return { error: "AI processor not found" };
+        }
+        return { processor };
+    });
+    app.post("/api/v1/aiproc/:slug/run", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/aiproc/:slug/run"
+        });
+        const processor = getAiProcessorBySlug(request.params.slug);
+        if (!processor) {
+            reply.code(404);
+            return { error: "AI processor not found" };
+        }
+        return await runAiProcessor(processor.id, runAiProcessorSchema.parse(request.body ?? {}), {
+            llm: managers.llm,
+            secrets: managers.secrets
+        }, { trigger: "route" });
+    });
+    const registerFlowApiRoutes = (basePath, noun, options) => {
+        const collectionKey = options?.collectionKey ?? "connectors";
+        const singularKey = options?.singularKey ?? "connector";
+        const catalogPath = options?.catalogPath ?? `${basePath}/catalog/boxes`;
+        app.get(catalogPath, async (request) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: catalogPath
+            });
+            return {
+                boxes: [
+                    ...listForgeBoxCatalog(),
+                    ...listAiConnectors().flatMap((connector) => connector.publishedOutputs.map((output) => buildConnectorOutputCatalogEntry({
+                        connectorId: connector.id,
+                        title: connector.title,
+                        outputId: output.id
+                    })))
+                ]
+            };
+        });
+        app.get(basePath, async (request) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: basePath
+            });
+            return {
+                [collectionKey]: listAiConnectors()
+            };
+        });
+        app.post(basePath, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: basePath
+            });
+            const connector = createAiConnector(createAiConnectorSchema.parse(request.body ?? {}));
+            reply.code(201);
+            return { [singularKey]: connector };
+        });
+        app.get(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                [singularKey]: connector,
+                runs: listAiConnectorRuns(connector.id),
+                conversation: getAiConnectorConversationForConnector(connector.id)
+            };
+        });
+        app.patch(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id`
+            });
+            const connector = updateAiConnector(request.params.id, updateAiConnectorSchema.parse(request.body ?? {}));
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return { [singularKey]: connector };
+        });
+        app.delete(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id`
+            });
+            const connector = deleteAiConnector(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return { [singularKey]: connector };
+        });
+        app.post(`${basePath}/:id/run`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id/run`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            const execution = await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
+                llm: managers.llm,
+                secrets: managers.secrets
+            }, "run");
+            return {
+                [singularKey]: execution.connector,
+                run: execution.run,
+                conversation: execution.conversation
+            };
+        });
+        app.post(`${basePath}/:id/chat`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id/chat`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            const execution = await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
+                llm: managers.llm,
+                secrets: managers.secrets
+            }, "chat");
+            return {
+                [singularKey]: execution.connector,
+                run: execution.run,
+                conversation: execution.conversation
+            };
+        });
+        app.get(`${basePath}/:id/output`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id/output`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                [singularKey]: connector,
+                output: connector.lastRun?.result ?? null
+            };
+        });
+        app.get(`${basePath}/:id/runs`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id/runs`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                runs: listAiConnectorRuns(connector.id)
+            };
+        });
+    };
+    registerFlowApiRoutes("/api/v1/workbench/flows", "Workbench flow", {
+        collectionKey: "flows",
+        singularKey: "flow",
+        catalogPath: "/api/v1/workbench/catalog/boxes"
+    });
+    app.post("/api/v1/workbench/run", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/workbench/run"
+        });
+        const payload = runAiConnectorSchema
+            .extend({
+            flowId: z.string().trim().min(1)
+        })
+            .parse(request.body ?? {});
+        const flow = getAiConnectorById(payload.flowId);
+        if (!flow) {
+            reply.code(404);
+            return { error: "Workbench flow not found" };
+        }
+        const { flowId, ...runInput } = payload;
+        const execution = await runAiConnector(flow.id, runInput, {
+            llm: managers.llm,
+            secrets: managers.secrets
+        }, "run");
+        return {
+            flow: execution.connector,
+            run: execution.run,
+            conversation: execution.conversation
         };
     });
+    app.get("/api/v1/workbench/flows/by-slug/:slug", async (request, reply) => {
+        requireScopedAccess(request.headers, ["read"], {
+            route: "/api/v1/workbench/flows/by-slug/:slug"
+        });
+        const connector = getAiConnectorBySlug(request.params.slug);
+        if (!connector) {
+            reply.code(404);
+            return { error: "Workbench flow not found" };
+        }
+        return { flow: connector };
+    });
     app.post("/api/v1/settings/tokens", async (request, reply) => {
         const auth = requireOperatorSession(request.headers, { route: "/api/v1/settings/tokens" });
         const token = managers.token.issueLocalAgentToken(createAgentTokenSchema.parse(request.body ?? {}), auth);