forge-openclaw-plugin 0.2.26 → 0.2.28

package/dist/server/server/src/openapi.js

@@ -37,6 +37,14 @@ const API_TAGS = [
         name: "Health",
         description: "Runtime health, sleep, sports, workout, and mobile sync surfaces."
     },
+    {
+        name: "Movement",
+        description: "Movement overviews, timeline history, known places, stays, trips, selection aggregates, and user-defined overlay routes."
+    },
+    {
+        name: "Life Force",
+        description: "Energy-budget, fatigue, and action-point modeling routes."
+    },
     {
         name: "Auth",
         description: "Operator session bootstrapping for trusted local usage."
@@ -125,6 +133,10 @@ const API_TAGS = [
         name: "Insights",
         description: "Stored insights and structured feedback on them."
     },
+    {
+        name: "Workbench",
+        description: "Graph-flow catalog, execution, published outputs, and node-result routes."
+    },
     {
         name: "Metrics",
         description: "XP, reward-ledger, and runtime metric surfaces."
@@ -145,7 +157,11 @@ const API_TAGS = [
 const API_TAG_GROUPS = [
     {
         name: "Runtime",
-        tags: ["Meta", "Health", "Auth", "Platform", "Operator", "Diagnostics"]
+        tags: ["Meta", "Auth", "Platform", "Operator", "Diagnostics"]
+    },
+    {
+        name: "Embodied Context",
+        tags: ["Health", "Movement", "Life Force"]
     },
     {
         name: "Core Work",
@@ -162,7 +178,8 @@ const API_TAG_GROUPS = [
             "Activity",
             "Metrics",
             "Reviews",
-            "Insights"
+            "Insights",
+            "Workbench"
         ]
     },
     {
@@ -188,6 +205,18 @@ function resolveTagsForPath(path) {
         path.startsWith("/api/v1/mobile")) {
         return ["Health"];
     }
+    if (path.startsWith("/api/v1/movement")) {
+        return ["Movement"];
+    }
+    if (path.startsWith("/api/v1/life-force")) {
+        return ["Life Force"];
+    }
+    if (path.startsWith("/api/v1/workbench")) {
+        return ["Workbench"];
+    }
+    if (path.startsWith("/api/v1/screen-time")) {
+        return ["Health"];
+    }
     if (path === "/api/v1/context" || path.startsWith("/api/v1/domains")) {
         return ["Platform"];
     }
@@ -2591,9 +2620,15 @@ export function buildOpenApiDocument() {
             "conceptModel",
             "psycheSubmoduleModel",
             "psycheCoachingPlaybooks",
+            "conversationRules",
+            "entityConversationPlaybooks",
             "relationshipModel",
+            "entityRouteModel",
+            "multiUserModel",
+            "strategyContractModel",
             "entityCatalog",
             "toolInputCatalog",
+            "connectionGuides",
             "verificationPaths",
             "recommendedPluginTools",
             "interactionGuidance",
@@ -2690,10 +2725,20 @@ export function buildOpenApiDocument() {
                     "task",
                     "taskRun",
                     "note",
+                    "wiki",
+                    "sleepSession",
+                    "workoutSession",
+                    "preferences",
+                    "questionnaire",
+                    "selfObservation",
                     "insight",
                     "calendar",
                     "workBlock",
                     "taskTimebox",
+                    "workAdjustment",
+                    "movement",
+                    "lifeForce",
+                    "workbench",
                     "psyche"
                 ],
                 properties: {
@@ -2702,10 +2747,20 @@ export function buildOpenApiDocument() {
                     task: { type: "string" },
                     taskRun: { type: "string" },
                     note: { type: "string" },
+                    wiki: { type: "string" },
+                    sleepSession: { type: "string" },
+                    workoutSession: { type: "string" },
+                    preferences: { type: "string" },
+                    questionnaire: { type: "string" },
+                    selfObservation: { type: "string" },
                     insight: { type: "string" },
                     calendar: { type: "string" },
                     workBlock: { type: "string" },
                     taskTimebox: { type: "string" },
+                    workAdjustment: { type: "string" },
+                    movement: { type: "string" },
+                    lifeForce: { type: "string" },
+                    workbench: { type: "string" },
                     psyche: { type: "string" }
                 }
             },
@@ -2761,24 +2816,138 @@ export function buildOpenApiDocument() {
                     notes: arrayOf({ type: "string" })
                 }
             }),
+            conversationRules: arrayOf({ type: "string" }),
+            entityConversationPlaybooks: arrayOf({
+                type: "object",
+                additionalProperties: false,
+                required: ["focus", "openingQuestion", "coachingGoal", "askSequence"],
+                properties: {
+                    focus: { type: "string" },
+                    openingQuestion: { type: "string" },
+                    coachingGoal: { type: "string" },
+                    askSequence: arrayOf({ type: "string" })
+                }
+            }),
             relationshipModel: arrayOf({ type: "string" }),
+            entityRouteModel: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "batchCrudEntities",
+                    "batchRoutes",
+                    "specializedCrudEntities",
+                    "actionEntities",
+                    "specializedDomainSurfaces",
+                    "readModelOnlySurfaces"
+                ],
+                properties: {
+                    batchCrudEntities: arrayOf({ type: "string" }),
+                    batchRoutes: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["search", "create", "update", "delete", "restore"],
+                        properties: {
+                            search: { type: "string" },
+                            create: { type: "string" },
+                            update: { type: "string" },
+                            delete: { type: "string" },
+                            restore: { type: "string" }
+                        }
+                    },
+                    specializedCrudEntities: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: { type: "string" }
+                        }
+                    },
+                    actionEntities: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: true
+                        }
+                    },
+                    specializedDomainSurfaces: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: true
+                        }
+                    },
+                    readModelOnlySurfaces: {
+                        type: "object",
+                        additionalProperties: { type: "string" }
+                    }
+                }
+            },
+            multiUserModel: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "summary",
+                    "defaultUserScopeBehavior",
+                    "routeScoping",
+                    "relationshipGraphDefaults"
+                ],
+                properties: {
+                    summary: { type: "string" },
+                    defaultUserScopeBehavior: { type: "string" },
+                    routeScoping: arrayOf({ type: "string" }),
+                    relationshipGraphDefaults: arrayOf({ type: "string" })
+                }
+            },
+            strategyContractModel: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "draftSummary",
+                    "lockSummary",
+                    "unlockSummary",
+                    "alignmentSummary",
+                    "metricBreakdown"
+                ],
+                properties: {
+                    draftSummary: { type: "string" },
+                    lockSummary: { type: "string" },
+                    unlockSummary: { type: "string" },
+                    alignmentSummary: { type: "string" },
+                    metricBreakdown: arrayOf({ type: "string" })
+                }
+            },
             entityCatalog: arrayOf({
                 type: "object",
                 additionalProperties: false,
                 required: [
                     "entityType",
+                    "classification",
                     "purpose",
                     "minimumCreateFields",
                     "relationshipRules",
                     "searchHints",
-                    "fieldGuide"
+                    "fieldGuide",
+                    "preferredMutationPath"
                 ],
                 properties: {
                     entityType: { type: "string" },
+                    classification: {
+                        type: "string",
+                        enum: [
+                            "batch_crud_entity",
+                            "specialized_crud_entity",
+                            "action_workflow_entity",
+                            "read_model_only_surface"
+                        ]
+                    },
                     purpose: { type: "string" },
                     minimumCreateFields: arrayOf({ type: "string" }),
                     relationshipRules: arrayOf({ type: "string" }),
                     searchHints: arrayOf({ type: "string" }),
+                    routeBase: nullable({ type: "string" }),
+                    preferredMutationPath: { type: "string" },
+                    preferredReadPath: nullable({ type: "string" }),
+                    preferredMutationTool: nullable({ type: "string" }),
+                    examples: arrayOf({ type: "string" }),
                     fieldGuide: arrayOf({
                         type: "object",
                         additionalProperties: false,
@@ -2831,6 +3000,15 @@ export function buildOpenApiDocument() {
                     "context",
                     "xpMetrics",
                     "weeklyReview",
+                    "sleepOverview",
+                    "sportsOverview",
+                    "lifeForce",
+                    "movementTimeline",
+                    "movementAllTime",
+                    "workbenchFlows",
+                    "wikiSettings",
+                    "wikiSearch",
+                    "wikiHealth",
                     "calendarOverview",
                     "settingsBin",
                     "batchSearch",
@@ -2842,6 +3020,15 @@ export function buildOpenApiDocument() {
                     context: { type: "string" },
                     xpMetrics: { type: "string" },
                     weeklyReview: { type: "string" },
+                    sleepOverview: { type: "string" },
+                    sportsOverview: { type: "string" },
+                    lifeForce: { type: "string" },
+                    movementTimeline: { type: "string" },
+                    movementAllTime: { type: "string" },
+                    workbenchFlows: { type: "string" },
+                    wikiSettings: { type: "string" },
+                    wikiSearch: { type: "string" },
+                    wikiHealth: { type: "string" },
                     calendarOverview: { type: "string" },
                     settingsBin: { type: "string" },
                     batchSearch: { type: "string" },
@@ -2858,6 +3045,9 @@ export function buildOpenApiDocument() {
                     "readModels",
                     "uiWorkflow",
                     "entityWorkflow",
+                    "wikiWorkflow",
+                    "healthWorkflow",
+                    "rewardWorkflow",
                     "workWorkflow",
                     "calendarWorkflow",
                     "insightWorkflow"
@@ -2867,6 +3057,9 @@ export function buildOpenApiDocument() {
                     readModels: arrayOf({ type: "string" }),
                     uiWorkflow: arrayOf({ type: "string" }),
                     entityWorkflow: arrayOf({ type: "string" }),
+                    wikiWorkflow: arrayOf({ type: "string" }),
+                    healthWorkflow: arrayOf({ type: "string" }),
+                    rewardWorkflow: arrayOf({ type: "string" }),
                     workWorkflow: arrayOf({ type: "string" }),
                     calendarWorkflow: arrayOf({ type: "string" }),
                     insightWorkflow: arrayOf({ type: "string" })
@@ -2880,6 +3073,8 @@ export function buildOpenApiDocument() {
                     "saveSuggestionPlacement",
                     "saveSuggestionTone",
                     "maxQuestionsPerTurn",
+                    "psycheExplorationRule",
+                    "psycheOpeningQuestionRule",
                     "duplicateCheckRoute",
                     "uiSuggestionRule",
                     "browserFallbackRule",
@@ -2890,12 +3085,28 @@ export function buildOpenApiDocument() {
                     saveSuggestionPlacement: { type: "string" },
                     saveSuggestionTone: { type: "string" },
                     maxQuestionsPerTurn: { type: "integer" },
+                    psycheExplorationRule: { type: "string" },
+                    psycheOpeningQuestionRule: { type: "string" },
                     duplicateCheckRoute: { type: "string" },
                     uiSuggestionRule: { type: "string" },
                     browserFallbackRule: { type: "string" },
                     writeConsentRule: { type: "string" }
                 }
             },
+            connectionGuides: {
+                type: "object",
+                additionalProperties: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["label", "installSteps", "verifyCommands", "configNotes"],
+                    properties: {
+                        label: { type: "string" },
+                        installSteps: arrayOf({ type: "string" }),
+                        verifyCommands: arrayOf({ type: "string" }),
+                        configNotes: arrayOf({ type: "string" })
+                    }
+                }
+            },
             mutationGuidance: {
                 type: "object",
                 additionalProperties: false,
@@ -3843,6 +4054,19 @@ export function buildOpenApiDocument() {
                             }
                         }, "Sleep overview")
                     }
+                },
+                post: {
+                    summary: "Create one manual sleep session",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["sleep"],
+                            properties: {
+                                sleep: { $ref: "#/components/schemas/SleepSession" }
+                            }
+                        }, "Created sleep session"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
                 }
             },
             "/api/v1/health/fitness": {
@@ -3859,226 +4083,1037 @@ export function buildOpenApiDocument() {
                     }
                 }
             },
-            "/api/v1/health/workouts/{id}": {
-                patch: {
-                    summary: "Update one workout session's reflective metadata",
+            "/api/v1/health/workouts": {
+                post: {
+                    summary: "Create one manual workout session",
                     responses: {
-                        "200": jsonResponse({
+                        "201": jsonResponse({
                             type: "object",
                             required: ["workout"],
                             properties: {
                                 workout: { $ref: "#/components/schemas/WorkoutSession" }
                             }
-                        }, "Updated workout session"),
-                        "404": { $ref: "#/components/responses/Error" }
-                    }
-                }
-            },
-            "/api/v1/health/sleep/{id}": {
-                patch: {
-                    summary: "Update one sleep session's reflective metadata",
-                    responses: {
-                        "200": jsonResponse({
-                            type: "object",
-                            required: ["sleep"],
-                            properties: {
-                                sleep: { $ref: "#/components/schemas/SleepSession" }
-                            }
-                        }, "Updated sleep session"),
-                        "404": { $ref: "#/components/responses/Error" }
+                        }, "Created workout session"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/settings": {
+            "/api/v1/health/workouts/{id}": {
                 get: {
-                    summary: "Read wiki spaces plus enabled LLM and embedding profiles",
+                    summary: "Read one workout session",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["settings"],
+                            required: ["workout"],
                             properties: {
-                                settings: {
-                                    type: "object",
-                                    additionalProperties: true
-                                }
+                                workout: { $ref: "#/components/schemas/WorkoutSession" }
                             }
-                        }, "Wiki settings")
+                        }, "Workout session"),
+                        "404": { $ref: "#/components/responses/Error" }
                     }
-                }
-            },
-            "/api/v1/wiki/pages": {
-                get: {
-                    summary: "List wiki or evidence pages inside one space",
+                },
+                patch: {
+                    summary: "Update one workout session's reflective metadata",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["pages"],
+                            required: ["workout"],
                             properties: {
-                                pages: arrayOf({
-                                    type: "object",
-                                    additionalProperties: true
-                                })
+                                workout: { $ref: "#/components/schemas/WorkoutSession" }
                             }
-                        }, "Wiki page list")
+                        }, "Updated workout session"),
+                        "404": { $ref: "#/components/responses/Error" }
                     }
                 },
-                post: {
-                    summary: "Create a wiki page through the file-backed wiki surface",
+                delete: {
+                    summary: "Delete one workout session immediately",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["page"],
+                            required: ["workout"],
                             properties: {
-                                page: { type: "object", additionalProperties: true }
+                                workout: { $ref: "#/components/schemas/WorkoutSession" }
                             }
-                        }, "Created wiki page"),
+                        }, "Deleted workout session"),
                         "404": { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/pages/{id}": {
+            "/api/v1/health/sleep/{id}": {
                 get: {
-                    summary: "Read one wiki page with backlinks and attached metadata",
+                    summary: "Read one sleep session",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["page"],
+                            required: ["sleep"],
                             properties: {
-                                page: { type: "object", additionalProperties: true }
+                                sleep: { $ref: "#/components/schemas/SleepSession" }
                             }
-                        }, "Wiki page detail"),
+                        }, "Sleep session"),
                         "404": { $ref: "#/components/responses/Error" }
                     }
                 },
                 patch: {
-                    summary: "Update an existing wiki page through the file-backed surface",
+                    summary: "Update one sleep session's reflective metadata",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["page"],
+                            required: ["sleep"],
                             properties: {
-                                page: { type: "object", additionalProperties: true }
+                                sleep: { $ref: "#/components/schemas/SleepSession" }
                             }
-                        }, "Updated wiki page"),
+                        }, "Updated sleep session"),
                         "404": { $ref: "#/components/responses/Error" }
                     }
-                }
-            },
-            "/api/v1/wiki/search": {
-                post: {
-                    summary: "Search the wiki with text, semantic, entity, or hybrid retrieval",
+                },
+                delete: {
+                    summary: "Delete one sleep session immediately",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["results"],
+                            required: ["sleep"],
                             properties: {
-                                results: arrayOf({
-                                    type: "object",
-                                    additionalProperties: true
-                                })
+                                sleep: { $ref: "#/components/schemas/SleepSession" }
                             }
-                        }, "Wiki search results")
+                        }, "Deleted sleep session"),
+                        "404": { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/health": {
+            "/api/v1/life-force": {
                 get: {
-                    summary: "Read wiki health signals for one space",
+                    summary: "Read the current life-force overview with stats, drains, curve state, warnings, and recommendations",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["health"],
+                            required: ["lifeForce", "templates"],
                             properties: {
-                                health: { type: "object", additionalProperties: true }
+                                lifeForce: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                templates: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
                             }
-                        }, "Wiki health")
+                        }, "Life-force overview"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/sync": {
-                post: {
-                    summary: "Resync markdown files from the local wiki vault into Forge metadata",
+            "/api/v1/life-force/profile": {
+                patch: {
+                    summary: "Update the user-controlled life-force profile settings",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            additionalProperties: true
-                        }, "Wiki sync result")
+                            required: ["lifeForce", "actor"],
+                            properties: {
+                                lifeForce: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                actor: { type: "string" }
+                            }
+                        }, "Updated life-force profile"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/reindex": {
-                post: {
-                    summary: "Recompute wiki embedding chunks for one space and optional profile",
+            "/api/v1/life-force/templates/{weekday}": {
+                put: {
+                    summary: "Replace one weekday life-force curve template",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            additionalProperties: true
-                        }, "Wiki reindex result")
+                            required: ["weekday", "points", "actor"],
+                            properties: {
+                                weekday: { type: "integer" },
+                                points: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                }),
+                                actor: { type: "string" }
+                            }
+                        }, "Updated weekday curve template"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/wiki/ingest-jobs": {
+            "/api/v1/life-force/fatigue-signals": {
                 post: {
-                    summary: "Queue a wiki ingest job from raw text, local files, or a URL",
+                    summary: "Record a tired or recovered fatigue signal and rebuild life-force state",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            additionalProperties: true
-                        }, "Queued wiki ingest job")
+                            required: ["lifeForce", "actor"],
+                            properties: {
+                                lifeForce: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                actor: { type: "string" }
+                            }
+                        }, "Updated life-force state after fatigue signal"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/context": {
+            "/api/v1/movement/day": {
                 get: {
-                    summary: "Get the full Forge snapshot for the routed app shell",
+                    summary: "Read one day of movement detail with distance, stays, trips, gaps, and summaries",
                     responses: {
-                        "200": jsonResponse({ $ref: "#/components/schemas/ForgeSnapshot" }, "Forge snapshot"),
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["movement"],
+                            properties: {
+                                movement: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement day detail"),
                         default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/operator/context": {
+            "/api/v1/movement/month": {
                 get: {
-                    summary: "Get the operator-focused Forge context for agents and assistant workflows",
+                    summary: "Read one month of movement summary",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["context"],
+                            required: ["movement"],
                             properties: {
-                                context: {
-                                    $ref: "#/components/schemas/OperatorContextPayload"
+                                movement: {
+                                    type: "object",
+                                    additionalProperties: true
                                 }
                             }
-                        }, "Operator context")
+                        }, "Movement month summary"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/users/directory": {
+            "/api/v1/movement/all-time": {
                 get: {
-                    summary: "Read the live human and bot directory with ownership summaries and directional relationship graph",
+                    summary: "Read all-time movement summary including place and trip distribution",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["directory"],
+                            required: ["movement"],
                             properties: {
-                                directory: {
+                                movement: {
                                     type: "object",
                                     additionalProperties: true
                                 }
                             }
-                        }, "User directory")
+                        }, "Movement all-time summary"),
+                        default: { $ref: "#/components/responses/Error" }
                     }
                 }
             },
-            "/api/v1/preferences/workspace": {
+            "/api/v1/movement/timeline": {
                 get: {
-                    summary: "Get the inferred Preferences workspace for one user, domain, and optional context",
+                    summary: "Read the paginated movement timeline with stays, trips, missing spans, and projected boxes",
                     responses: {
                         "200": jsonResponse({
                             type: "object",
-                            required: ["workspace"],
+                            required: ["movement"],
                             properties: {
-                                workspace: {
+                                movement: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement timeline"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/settings": {
+                get: {
+                    summary: "Read movement capture settings",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["settings"],
+                            properties: {
+                                settings: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement settings"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
+                patch: {
+                    summary: "Update movement capture settings",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["settings"],
+                            properties: {
+                                settings: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated movement settings"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/places": {
+                get: {
+                    summary: "List known movement places",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["places"],
+                            properties: {
+                                places: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Movement places"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
+                post: {
+                    summary: "Create one user-defined movement place",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["place"],
+                            properties: {
+                                place: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Created movement place"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/places/{id}": {
+                patch: {
+                    summary: "Update one known movement place",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["place"],
+                            properties: {
+                                place: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated movement place"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/user-boxes": {
+                post: {
+                    summary: "Create a user-defined movement overlay box such as a manual stay, trip, or missing-data override",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["box"],
+                            properties: {
+                                box: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Created movement user box"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/user-boxes/preflight": {
+                post: {
+                    summary: "Analyze a proposed movement overlay before saving it, especially when replacing a missing gap or overlapping another box",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["preflight"],
+                            properties: {
+                                preflight: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement user-box preflight"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/user-boxes/{id}": {
+                patch: {
+                    summary: "Update one user-defined movement overlay box",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["box"],
+                            properties: {
+                                box: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated movement user box"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Delete one user-defined movement box",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Deleted movement user box"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/automatic-boxes/{id}/invalidate": {
+                post: {
+                    summary: "Hide one automatic movement box and project the resulting user-defined overlay",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["box"],
+                            properties: {
+                                box: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Invalidated automatic movement box"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/stays/{id}": {
+                patch: {
+                    summary: "Update one recorded movement stay",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["stay"],
+                            properties: {
+                                stay: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated movement stay"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Delete one recorded movement stay",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Deleted movement stay"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/trips/{id}": {
+                get: {
+                    summary: "Read one movement trip with its full detail",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["movement"],
+                            properties: {
+                                movement: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement trip detail"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                patch: {
+                    summary: "Update one movement trip",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["trip"],
+                            properties: {
+                                trip: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated movement trip"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Delete one movement trip",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Deleted movement trip"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/trips/{id}/points/{pointId}": {
+                patch: {
+                    summary: "Update one movement trip datapoint",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Updated movement trip point"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Delete one movement trip datapoint",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Deleted movement trip point"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/movement/selection": {
+                post: {
+                    summary: "Aggregate one selected movement range or set of segments",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["movement"],
+                            properties: {
+                                movement: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Movement selection aggregate"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/catalog/boxes": {
+                get: {
+                    summary: "List registered Workbench boxes and their contracts",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["boxes"],
+                            properties: {
+                                boxes: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Workbench box catalog"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows": {
+                get: {
+                    summary: "List Workbench flows and recent execution summaries",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flows"],
+                            properties: {
+                                flows: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Workbench flow collection"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
+                post: {
+                    summary: "Create one Workbench flow",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["flow"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Created Workbench flow"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}": {
+                get: {
+                    summary: "Read one Workbench flow with runs",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "runs"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                runs: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Workbench flow detail"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                patch: {
+                    summary: "Update one Workbench flow",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated Workbench flow"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Delete one Workbench flow",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Deleted Workbench flow"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/by-slug/{slug}": {
+                get: {
+                    summary: "Read one Workbench flow by slug",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench flow by slug"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/run": {
+                post: {
+                    summary: "Run one Workbench flow by id",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "run", "conversation"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                run: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                conversation: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench flow execution"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/run": {
+                post: {
+                    summary: "Run one Workbench flow by payload with flowId",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "run", "conversation"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                run: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                conversation: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench flow execution"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/chat": {
+                post: {
+                    summary: "Continue or start one Workbench chat flow",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Workbench chat response"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/output": {
+                get: {
+                    summary: "Read the latest published whole-flow output",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Workbench published output"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/runs": {
+                get: {
+                    summary: "List Workbench runs for one flow",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "runs"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                runs: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Workbench run list"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/runs/{runId}": {
+                get: {
+                    summary: "Read one Workbench run detail",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "run"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                run: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench run detail"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/runs/{runId}/nodes": {
+                get: {
+                    summary: "List node results for one Workbench run",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "run", "nodeResults"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                run: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                nodeResults: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Workbench node results"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/runs/{runId}/nodes/{nodeId}": {
+                get: {
+                    summary: "Read one node result for one Workbench run",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "nodeResult"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                nodeResult: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench node result"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/workbench/flows/{id}/nodes/{nodeId}/output": {
+                get: {
+                    summary: "Read the latest successful output for one Workbench node",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["flow", "run", "nodeResult"],
+                            properties: {
+                                flow: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                run: {
+                                    type: "object",
+                                    additionalProperties: true
+                                },
+                                nodeResult: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Workbench latest node output"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/wiki/settings": {
+                get: {
+                    summary: "Read wiki spaces plus enabled LLM and embedding profiles",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["settings"],
+                            properties: {
+                                settings: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Wiki settings")
+                    }
+                }
+            },
+            "/api/v1/wiki/pages": {
+                get: {
+                    summary: "List wiki or evidence pages inside one space",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["pages"],
+                            properties: {
+                                pages: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Wiki page list")
+                    }
+                },
+                post: {
+                    summary: "Create a wiki page through the file-backed wiki surface",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["page"],
+                            properties: {
+                                page: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created wiki page"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/wiki/pages/{id}": {
+                get: {
+                    summary: "Read one wiki page with backlinks and attached metadata",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["page"],
+                            properties: {
+                                page: { type: "object", additionalProperties: true }
+                            }
+                        }, "Wiki page detail"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                },
+                patch: {
+                    summary: "Update an existing wiki page through the file-backed surface",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["page"],
+                            properties: {
+                                page: { type: "object", additionalProperties: true }
+                            }
+                        }, "Updated wiki page"),
+                        "404": { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/wiki/search": {
+                post: {
+                    summary: "Search the wiki with text, semantic, entity, or hybrid retrieval",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["results"],
+                            properties: {
+                                results: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Wiki search results")
+                    }
+                }
+            },
+            "/api/v1/wiki/health": {
+                get: {
+                    summary: "Read wiki health signals for one space",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["health"],
+                            properties: {
+                                health: { type: "object", additionalProperties: true }
+                            }
+                        }, "Wiki health")
+                    }
+                }
+            },
+            "/api/v1/wiki/sync": {
+                post: {
+                    summary: "Resync markdown files from the local wiki vault into Forge metadata",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Wiki sync result")
+                    }
+                }
+            },
+            "/api/v1/wiki/reindex": {
+                post: {
+                    summary: "Recompute wiki embedding chunks for one space and optional profile",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Wiki reindex result")
+                    }
+                }
+            },
+            "/api/v1/wiki/ingest-jobs": {
+                post: {
+                    summary: "Queue a wiki ingest job from raw text, local files, or a URL",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            additionalProperties: true
+                        }, "Queued wiki ingest job")
+                    }
+                }
+            },
+            "/api/v1/context": {
+                get: {
+                    summary: "Get the full Forge snapshot for the routed app shell",
+                    responses: {
+                        "200": jsonResponse({ $ref: "#/components/schemas/ForgeSnapshot" }, "Forge snapshot"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
+            "/api/v1/operator/context": {
+                get: {
+                    summary: "Get the operator-focused Forge context for agents and assistant workflows",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["context"],
+                            properties: {
+                                context: {
+                                    $ref: "#/components/schemas/OperatorContextPayload"
+                                }
+                            }
+                        }, "Operator context")
+                    }
+                }
+            },
+            "/api/v1/users/directory": {
+                get: {
+                    summary: "Read the live human and bot directory with ownership summaries and directional relationship graph",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["directory"],
+                            properties: {
+                                directory: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "User directory")
+                    }
+                }
+            },
+            "/api/v1/preferences/workspace": {
+                get: {
+                    summary: "Get the inferred Preferences workspace for one user, domain, and optional context",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["workspace"],
+                            properties: {
+                                workspace: {
                                     type: "object",
                                     additionalProperties: true
                                 }
@@ -4107,6 +5142,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/catalogs": {
+                get: {
+                    summary: "List Preferences concept lists",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["catalogs"],
+                            properties: {
+                                catalogs: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Preferences catalogs"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 post: {
                     summary: "Create a Preferences concept list",
                     responses: {
@@ -4125,6 +5176,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/catalogs/{id}": {
+                get: {
+                    summary: "Get one Preferences concept list",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["catalog"],
+                            properties: {
+                                catalog: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Preferences catalog"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 patch: {
                     summary: "Update a Preferences concept list",
                     responses: {
@@ -4159,6 +5226,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/catalog-items": {
+                get: {
+                    summary: "List Preferences concept entries",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["items"],
+                            properties: {
+                                items: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Preferences catalog items"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 post: {
                     summary: "Create a Preferences concept entry",
                     responses: {
@@ -4177,6 +5260,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/catalog-items/{id}": {
+                get: {
+                    summary: "Get one Preferences concept entry",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["item"],
+                            properties: {
+                                item: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Preferences catalog item"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 patch: {
                     summary: "Update a Preferences concept entry",
                     responses: {
@@ -4211,6 +5310,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/contexts": {
+                get: {
+                    summary: "List Preferences contexts",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["contexts"],
+                            properties: {
+                                contexts: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Preferences contexts"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 post: {
                     summary: "Create a Preferences context",
                     responses: {
@@ -4229,6 +5344,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/contexts/{id}": {
+                get: {
+                    summary: "Get one Preferences context",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["context"],
+                            properties: {
+                                context: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Preferences context"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 patch: {
                     summary: "Update a Preferences context",
                     responses: {
@@ -4244,6 +5375,22 @@ export function buildOpenApiDocument() {
                         }, "Updated Preferences context"),
                         default: { $ref: "#/components/responses/Error" }
                     }
+                },
+                delete: {
+                    summary: "Delete a Preferences context",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["context"],
+                            properties: {
+                                context: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Deleted Preferences context"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
                 }
             },
             "/api/v1/preferences/contexts/merge": {
@@ -4265,6 +5412,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/items": {
+                get: {
+                    summary: "List Preferences items",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["items"],
+                            properties: {
+                                items: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Preferences items"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 post: {
                     summary: "Create a standalone Preferences item",
                     responses: {
@@ -4283,6 +5446,22 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/preferences/items/{id}": {
+                get: {
+                    summary: "Get one Preferences item",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["item"],
+                            properties: {
+                                item: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Preferences item"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 patch: {
                     summary: "Update a Preferences item",
                     responses: {
@@ -4298,6 +5477,22 @@ export function buildOpenApiDocument() {
                         }, "Updated Preferences item"),
                         default: { $ref: "#/components/responses/Error" }
                     }
+                },
+                delete: {
+                    summary: "Delete a Preferences item",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["item"],
+                            properties: {
+                                item: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Deleted Preferences item"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
                 }
             },
             "/api/v1/preferences/items/from-entity": {
@@ -4422,6 +5617,38 @@ export function buildOpenApiDocument() {
                         }, "Questionnaire instrument detail"),
                         default: { $ref: "#/components/responses/Error" }
                     }
+                },
+                patch: {
+                    summary: "Update one questionnaire instrument through the direct route",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["instrument"],
+                            properties: {
+                                instrument: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Updated questionnaire instrument"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
+                delete: {
+                    summary: "Archive one questionnaire instrument through the direct route",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["instrument"],
+                            properties: {
+                                instrument: {
+                                    type: "object",
+                                    additionalProperties: true
+                                }
+                            }
+                        }, "Archived questionnaire instrument"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
                 }
             },
             "/api/v1/psyche/questionnaires/{id}/clone": {
@@ -5611,6 +6838,21 @@ export function buildOpenApiDocument() {
                     }
                 }
             },
+            "/api/v1/calendar/work-block-templates/{id}": {
+                get: {
+                    summary: "Get one recurring work-block template",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["template"],
+                            properties: {
+                                template: { $ref: "#/components/schemas/WorkBlockTemplate" }
+                            }
+                        }, "Work-block template"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
             "/api/v1/calendar/timeboxes": {
                 get: {
                     summary: "List task timeboxes",
@@ -5641,6 +6883,21 @@ export function buildOpenApiDocument() {
                     }
                 }
             },
+            "/api/v1/calendar/timeboxes/{id}": {
+                get: {
+                    summary: "Get one task timebox",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["timebox"],
+                            properties: {
+                                timebox: { $ref: "#/components/schemas/TaskTimebox" }
+                            }
+                        }, "Task timebox"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
             "/api/v1/calendar/timeboxes/recommend": {
                 post: {
                     summary: "Suggest future timeboxes for a task",
@@ -5660,6 +6917,21 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/calendar/events": {
+                get: {
+                    summary: "List native and mirrored calendar events for a range",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["events"],
+                            properties: {
+                                events: arrayOf({
+                                    $ref: "#/components/schemas/CalendarEvent"
+                                })
+                            }
+                        }, "Calendar events"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 post: {
                     summary: "Create a native Forge calendar event",
                     description: "Forge stores the event canonically first, then projects it to a connected writable calendar when a preferred calendar is selected.",
@@ -5676,6 +6948,19 @@ export function buildOpenApiDocument() {
                 }
             },
             "/api/v1/calendar/events/{id}": {
+                get: {
+                    summary: "Get one Forge calendar event",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["event"],
+                            properties: {
+                                event: { $ref: "#/components/schemas/CalendarEvent" }
+                            }
+                        }, "Calendar event"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                },
                 patch: {
                     summary: "Update a Forge calendar event and sync remote projections",
                     responses: {