npm - forge-openclaw-plugin - Versions diffs - 0.2.24 → 0.2.26 - Mend

forge-openclaw-plugin 0.2.24 → 0.2.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (208) hide show

package/dist/index.html CHANGED Viewed

@@ -13,15 +13,14 @@
     />
     <link rel="icon" type="image/png" href="/forge/assets/favicon-BCHm9dUV.ico" />
     <link rel="alternate icon" href="/forge/assets/favicon-BCHm9dUV.ico" />
-    <script type="module" crossorigin src="/forge/assets/index-DTCwBWAs.js"></script>
-    <link rel="modulepreload" crossorigin href="/forge/assets/viz-C6hfyqzu.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/vendor-De38P6YR.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/ui-BzK4azQb.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/motion-D4sZgCHd.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/table-BWzTaky1.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/board-_C6oMy5w.js">
+    <script type="module" crossorigin src="/forge/assets/index-ytlpSj23.js"></script>
+    <link rel="modulepreload" crossorigin href="/forge/assets/vendor-lE3tZJcC.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/board-ta0rUHOf.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/ui-DInOpaYF.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/motion-fBKPB6yw.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/table-C-IGTQni.js">
     <link rel="stylesheet" crossorigin href="/forge/assets/vendor-DT3pnAKJ.css">
-    <link rel="stylesheet" crossorigin href="/forge/assets/index-DttXlAgi.css">
+    <link rel="stylesheet" crossorigin href="/forge/assets/index-Ro0ZF_az.css">
   </head>
   <body class="bg-canvas text-ink antialiased">
     <div id="root"></div>

package/dist/openclaw/local-runtime.d.ts CHANGED Viewed

@@ -33,7 +33,9 @@ export type ForgeRuntimeRestartResult = {
 };
 export declare function ensureForgeRuntimeReady(config: ForgePluginConfig): Promise<void>;
 export declare function startForgeRuntime(config: ForgePluginConfig): Promise<ForgeRuntimeStartResult>;
-export declare function primeForgeRuntime(config: ForgePluginConfig): void;
+export declare function primeForgeRuntime(config: ForgePluginConfig, logger?: {
+    warn?(message: string): void;
+}): void;
 export declare function stopForgeRuntime(config: ForgePluginConfig): Promise<ForgeRuntimeStopResult>;
 export declare function getForgeRuntimeStatus(config: ForgePluginConfig): Promise<ForgeRuntimeStatusResult>;
 export declare function restartForgeRuntime(config: ForgePluginConfig): Promise<ForgeRuntimeRestartResult>;

package/dist/openclaw/local-runtime.js CHANGED Viewed

@@ -168,6 +168,37 @@ function isLocalOrigin(origin) {
 function getCurrentModuleRoot() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 }
+function buildLaunchPlanSearchPaths(moduleRoot) {
+    const repoRoot = path.resolve(moduleRoot, "..");
+    return {
+        packagedEntries: [
+            path.join(moduleRoot, "server", "index.js"),
+            path.join(moduleRoot, "dist", "server", "index.js"),
+            path.join(moduleRoot, "dist", "server", "src", "index.js"),
+            path.join(moduleRoot, "dist", "server", "server", "src", "index.js")
+        ],
+        packagedMigrations: path.join(moduleRoot, "server", "migrations"),
+        sourceEntries: [
+            path.join(repoRoot, "server", "src", "index.ts"),
+            path.join(moduleRoot, "server", "src", "index.ts")
+        ],
+        tsxCliCandidates: [
+            path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs"),
+            path.join(moduleRoot, "node_modules", "tsx", "dist", "cli.mjs")
+        ],
+        repoRoot
+    };
+}
+function formatLaunchPlanFailure(moduleRoot) {
+    const paths = buildLaunchPlanSearchPaths(moduleRoot);
+    return [
+        "Forge local runtime could not find a launchable server entry.",
+        `Packaged entry candidates: ${paths.packagedEntries.join(", ")}.`,
+        `Expected migrations at: ${paths.packagedMigrations}.`,
+        `Source entry candidates: ${paths.sourceEntries.join(", ")}.`,
+        `tsx candidates: ${paths.tsxCliCandidates.join(", ")}.`
+    ].join(" ");
+}
 function getRuntimeLogPath(config) {
     const origin = new URL(config.origin).hostname.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
     return path.join(homedir(), ".openclaw", "logs", FORGE_PLUGIN_ID, `${origin}-${config.port}.log`);
@@ -177,7 +208,7 @@ function openRuntimeLogFile(logPath) {
     return openSync(logPath, "a");
 }
 function isPackagedServerPlan(plan) {
-    return plan.entryFile.endsWith(path.join("dist", "server", "index.js"));
+    return plan.mode === "packaged";
 }
 function getNpmInvocation() {
     const binDir = path.dirname(process.execPath);
@@ -250,23 +281,25 @@ async function ensurePackagedRuntimeDependencies(plan, config) {
 }
 function resolveLaunchPlan() {
     const moduleRoot = getCurrentModuleRoot();
+    const paths = buildLaunchPlanSearchPaths(moduleRoot);
     // Published or linked plugin package runtime.
-    const packagedEntry = path.join(moduleRoot, "dist", "server", "index.js");
-    const packagedMigrations = path.join(moduleRoot, "server", "migrations");
-    if (existsSync(packagedEntry) && existsSync(packagedMigrations)) {
+    const packagedEntry = paths.packagedEntries.find((candidate) => existsSync(candidate));
+    if (packagedEntry && existsSync(paths.packagedMigrations)) {
         return {
             packageRoot: moduleRoot,
-            entryFile: packagedEntry
+            entryFile: packagedEntry,
+            mode: "packaged"
         };
     }
     // Source-tree fallback for local development before packaging.
-    const repoRoot = moduleRoot;
-    const sourceEntry = path.join(repoRoot, "server", "src", "index.ts");
-    const tsxCli = path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs");
-    if (existsSync(sourceEntry) && existsSync(tsxCli)) {
+    const sourceEntry = paths.sourceEntries.find((candidate) => existsSync(candidate));
+    const tsxCli = paths.tsxCliCandidates.find((candidate) => existsSync(candidate));
+    if (sourceEntry && tsxCli) {
         return {
-            packageRoot: repoRoot,
-            entryFile: tsxCli
+            packageRoot: paths.repoRoot,
+            entryFile: tsxCli,
+            mode: "source",
+            sourceEntryFile: sourceEntry
         };
     }
     return null;
@@ -330,7 +363,9 @@ async function adoptManagedRuntimeState(config, probe) {
 }
 async function spawnManagedRuntime(config, plan) {
     const isPackagedServer = isPackagedServerPlan(plan);
-    const args = isPackagedServer ? [plan.entryFile] : [plan.entryFile, path.join(plan.packageRoot, "server", "src", "index.ts")];
+    const args = isPackagedServer
+        ? [plan.entryFile]
+        : [plan.entryFile, plan.sourceEntryFile ?? path.join(plan.packageRoot, "server", "src", "index.ts")];
     const logPath = getRuntimeLogPath(config);
     const logFd = openRuntimeLogFile(logPath);
     const child = spawn(process.execPath, args, {
@@ -454,7 +489,7 @@ export async function ensureForgeRuntimeReady(config) {
     }
     const plan = resolveLaunchPlan();
     if (!plan) {
-        return;
+        throw new Error(formatLaunchPlanFailure(getCurrentModuleRoot()));
     }
     startupPromise = (async () => {
         const probeBeforeStart = await probeForgeRuntime(config, HEALTHCHECK_TIMEOUT_MS);
@@ -556,8 +591,9 @@ export async function startForgeRuntime(config) {
         baseUrl: config.baseUrl
     };
 }
-export function primeForgeRuntime(config) {
-    void ensureForgeRuntimeReady(config).catch(() => {
+export function primeForgeRuntime(config, logger) {
+    void ensureForgeRuntimeReady(config).catch((error) => {
+        logger?.warn?.(`Forge local runtime bootstrap failed for ${config.baseUrl}: ${error instanceof Error ? error.message : String(error)}`);
         // Keep plugin registration non-blocking. Failures surface on first real call.
     });
 }

package/dist/openclaw/parity.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ export type ApiRouteKey = `${Uppercase<string>} ${string}`;
 export type ForgeSupportedPluginApiRoute = {
     method: Uppercase<string>;
     path: string;
-    purpose: "diagnostics" | "overview" | "operator_context" | "onboarding" | "psyche" | "xp" | "weekly_review" | "entities" | "work" | "insights" | "wiki" | "health";
+    purpose: "diagnostics" | "overview" | "operator_context" | "onboarding" | "psyche" | "xp" | "weekly_review" | "entities" | "work" | "insights" | "wiki" | "health" | "preferences" | "questionnaires";
 };
 export declare const FORGE_SUPPORTED_PLUGIN_API_ROUTES: ForgeSupportedPluginApiRoute[];
 export declare function makeApiRouteKey(method: string, path: string): ApiRouteKey;

package/dist/openclaw/parity.js CHANGED Viewed

@@ -29,6 +29,35 @@ export const FORGE_SUPPORTED_PLUGIN_API_ROUTES = [
     { method: "PATCH", path: "/api/v1/health/sleep/:id", purpose: "health" },
     { method: "GET", path: "/api/v1/health/fitness", purpose: "health" },
     { method: "PATCH", path: "/api/v1/health/workouts/:id", purpose: "health" },
+    { method: "GET", path: "/api/v1/preferences/workspace", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/game/start", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/catalogs", purpose: "preferences" },
+    { method: "PATCH", path: "/api/v1/preferences/catalogs/:id", purpose: "preferences" },
+    { method: "DELETE", path: "/api/v1/preferences/catalogs/:id", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/catalog-items", purpose: "preferences" },
+    { method: "PATCH", path: "/api/v1/preferences/catalog-items/:id", purpose: "preferences" },
+    { method: "DELETE", path: "/api/v1/preferences/catalog-items/:id", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/contexts", purpose: "preferences" },
+    { method: "PATCH", path: "/api/v1/preferences/contexts/:id", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/contexts/merge", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/items", purpose: "preferences" },
+    { method: "PATCH", path: "/api/v1/preferences/items/:id", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/items/from-entity", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/judgments", purpose: "preferences" },
+    { method: "POST", path: "/api/v1/preferences/signals", purpose: "preferences" },
+    { method: "PATCH", path: "/api/v1/preferences/items/:id/score", purpose: "preferences" },
+    { method: "GET", path: "/api/v1/psyche/questionnaires", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaires", purpose: "questionnaires" },
+    { method: "GET", path: "/api/v1/psyche/questionnaires/:id", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaires/:id/clone", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaires/:id/draft", purpose: "questionnaires" },
+    { method: "PATCH", path: "/api/v1/psyche/questionnaires/:id/draft", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaires/:id/publish", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaires/:id/runs", purpose: "questionnaires" },
+    { method: "GET", path: "/api/v1/psyche/questionnaire-runs/:id", purpose: "questionnaires" },
+    { method: "PATCH", path: "/api/v1/psyche/questionnaire-runs/:id", purpose: "questionnaires" },
+    { method: "POST", path: "/api/v1/psyche/questionnaire-runs/:id/complete", purpose: "questionnaires" },
+    { method: "GET", path: "/api/v1/psyche/self-observation/calendar", purpose: "questionnaires" },
     { method: "POST", path: "/api/v1/entities/search", purpose: "entities" },
     { method: "POST", path: "/api/v1/entities/create", purpose: "entities" },
     { method: "POST", path: "/api/v1/entities/update", purpose: "entities" },

package/dist/openclaw/plugin-entry-shared.d.ts CHANGED Viewed

@@ -5,6 +5,7 @@ export declare const FORGE_PLUGIN_NAME = "Forge";
 export declare const FORGE_PLUGIN_DESCRIPTION = "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.";
 export declare const DEFAULT_FORGE_ORIGIN = "http://127.0.0.1";
 export declare const DEFAULT_FORGE_PORT = 4317;
+export declare const DEFAULT_OPENCLAW_ACTOR_LABEL = "aurel (claw)";
 export declare function resolveForgePluginConfig(pluginConfig: unknown): ForgePluginConfig;
 export declare const forgePluginConfigSchema: ForgePluginConfigSchema;
 export declare function registerForgePlugin(api: ForgePluginRegistrationApi): void;

package/dist/openclaw/plugin-entry-shared.js CHANGED Viewed

@@ -2,14 +2,16 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { buildForgeBaseUrl, buildForgeWebAppUrl } from "./api-client.js";
-import { primeForgeRuntime } from "./local-runtime.js";
+import { ensureForgeRuntimeReady, getForgeRuntimeStatus, primeForgeRuntime } from "./local-runtime.js";
 import { registerForgePluginCli, registerForgePluginRoutes } from "./routes.js";
+import { registerForgeSessionBootstrapHook } from "./session-bootstrap.js";
 import { registerForgePluginTools } from "./tools.js";
 export const FORGE_PLUGIN_ID = "forge-openclaw-plugin";
 export const FORGE_PLUGIN_NAME = "Forge";
 export const FORGE_PLUGIN_DESCRIPTION = "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.";
 export const DEFAULT_FORGE_ORIGIN = "http://127.0.0.1";
 export const DEFAULT_FORGE_PORT = 4317;
+export const DEFAULT_OPENCLAW_ACTOR_LABEL = "aurel (claw)";
 const LOCAL_HOSTNAMES = new Set(["127.0.0.1", "localhost", "::1"]);
 function normalizeString(value, fallback) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
@@ -88,7 +90,7 @@ export function resolveForgePluginConfig(pluginConfig) {
         portSource: hasConfiguredPort ? "configured" : preferredPort !== null ? "preferred" : "default",
         dataRoot: normalizeDataRoot(raw.dataRoot),
         apiToken: typeof raw.apiToken === "string" ? raw.apiToken.trim() : "",
-        actorLabel: normalizeString(raw.actorLabel, "aurel"),
+        actorLabel: normalizeString(raw.actorLabel, DEFAULT_OPENCLAW_ACTOR_LABEL),
         timeoutMs: normalizeTimeout(raw.timeoutMs, 15_000)
     };
 }
@@ -124,7 +126,7 @@ export const forgePluginConfigSchema = {
             },
             actorLabel: {
                 type: "string",
-                default: "aurel",
+                default: DEFAULT_OPENCLAW_ACTOR_LABEL,
                 description: "Actor label recorded in Forge provenance headers."
             },
             timeoutMs: {
@@ -161,8 +163,8 @@ export const forgePluginConfigSchema = {
         },
         actorLabel: {
             label: "Actor Label",
-            help: "Recorded in Forge provenance headers for plugin-originated writes.",
-            placeholder: "aurel"
+            help: "Recorded in Forge provenance headers for plugin-originated writes. Use a distinct OpenClaw label such as <name> (claw).",
+            placeholder: DEFAULT_OPENCLAW_ACTOR_LABEL
         },
         timeoutMs: {
             label: "Request Timeout (ms)",
@@ -173,7 +175,30 @@ export const forgePluginConfigSchema = {
 };
 export function registerForgePlugin(api) {
     const config = resolveForgePluginConfig(api.pluginConfig);
-    primeForgeRuntime(config);
+    if (api.registerService) {
+        api.registerService({
+            id: "forge-local-runtime-bootstrap",
+            start: async ({ logger }) => {
+                if (!isLocalOrigin(config.origin)) {
+                    logger.info?.(`Forge local runtime bootstrap skipped for remote target ${config.baseUrl}.`);
+                    return;
+                }
+                logger.info?.(`Forge local runtime bootstrap: ensuring Forge at ${config.baseUrl}.`);
+                try {
+                    await ensureForgeRuntimeReady(config);
+                    const status = await getForgeRuntimeStatus(config);
+                    logger.info?.(`Forge local runtime bootstrap: ${status?.message ?? `Forge is ready at ${config.baseUrl}.`}`);
+                }
+                catch (error) {
+                    logger.warn?.(`Forge local runtime bootstrap failed for ${config.baseUrl}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        });
+    }
+    else {
+        primeForgeRuntime(config, api.logger);
+    }
+    registerForgeSessionBootstrapHook(api, config);
     registerForgePluginRoutes(api, config);
     registerForgePluginCli(api, config);
     registerForgePluginTools(api, config);

package/dist/openclaw/plugin-sdk-types.d.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { TSchema } from "@sinclair/typebox";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { InternalHookEvent } from "openclaw/plugin-sdk/hook-runtime";
 export type ForgePluginConfigSchema = {
     parse(value: unknown): unknown;
     jsonSchema: Record<string, unknown>;
@@ -41,15 +42,43 @@ export type ForgeCliRegistrarContext = {
         debug?(message: string): void;
     };
 };
+export type ForgePluginServiceContext = {
+    config?: unknown;
+    workspaceDir?: string;
+    stateDir: string;
+    logger: {
+        info?(message: string): void;
+        warn?(message: string): void;
+        error?(message: string): void;
+        debug?(message: string): void;
+    };
+};
+export type ForgeRegisteredService = {
+    id: string;
+    start: (context: ForgePluginServiceContext) => Promise<void> | void;
+    stop?: (context: ForgePluginServiceContext) => Promise<void> | void;
+};
 export type ForgePluginRegistrationApi = {
     pluginConfig?: unknown;
+    logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+        error?(message: string): void;
+        debug?(message: string): void;
+    };
     registerHttpRoute(route: ForgeRegisteredHttpRoute): void;
     registerTool(tool: ForgeRegisteredTool, options?: {
         optional?: boolean;
     }): void;
+    registerHook?(events: string | string[], handler: (event: InternalHookEvent) => Promise<void> | void, options?: {
+        name?: string;
+        description?: string;
+        register?: boolean;
+    }): void;
     registerCli?(registrar: (context: ForgeCliRegistrarContext) => void, options?: {
         commands?: string[];
     }): void;
+    registerService?(service: ForgeRegisteredService): void;
 };
 export type ForgePluginRouteApi = Pick<ForgePluginRegistrationApi, "registerHttpRoute">;
 export type ForgePluginToolApi = Pick<ForgePluginRegistrationApi, "registerTool">;

package/dist/openclaw/routes.js CHANGED Viewed

@@ -164,6 +164,16 @@ export const FORGE_PLUGIN_ROUTE_GROUPS = [
         upstreamPath: "/api/v1/health/fitness",
         target: (_match, url) => passthroughSearch("/api/v1/health/fitness", url)
     }),
+    exact("/forge/v1/preferences/workspace", {
+        method: "GET",
+        upstreamPath: "/api/v1/preferences/workspace",
+        target: (_match, url) => passthroughSearch("/api/v1/preferences/workspace", url)
+    }),
+    exact("/forge/v1/psyche/self-observation/calendar", {
+        method: "GET",
+        upstreamPath: "/api/v1/psyche/self-observation/calendar",
+        target: (_match, url) => passthroughSearch("/api/v1/psyche/self-observation/calendar", url)
+    }),
     exact("/forge/v1/operator/log-work", {
         method: "POST",
         upstreamPath: "/api/v1/operator/log-work",
@@ -185,6 +195,232 @@ export const FORGE_PLUGIN_ROUTE_GROUPS = [
         requiresToken: true,
         target: (_match, url) => passthroughSearch("/api/v1/insights", url)
     }),
+    {
+        path: "/forge/v1/preferences",
+        match: "prefix",
+        operations: [
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/game\/start$/,
+                upstreamPath: "/api/v1/preferences/game/start",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/game/start", url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/catalogs$/,
+                upstreamPath: "/api/v1/preferences/catalogs",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/catalogs", url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/preferences\/catalogs\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/catalogs/:id",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/catalogs/${match[1]}`, url)
+            },
+            {
+                method: "DELETE",
+                pattern: /^\/forge\/v1\/preferences\/catalogs\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/catalogs/:id",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/catalogs/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/catalog-items$/,
+                upstreamPath: "/api/v1/preferences/catalog-items",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/catalog-items", url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/preferences\/catalog-items\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/catalog-items/:id",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/catalog-items/${match[1]}`, url)
+            },
+            {
+                method: "DELETE",
+                pattern: /^\/forge\/v1\/preferences\/catalog-items\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/catalog-items/:id",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/catalog-items/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/contexts$/,
+                upstreamPath: "/api/v1/preferences/contexts",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/contexts", url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/preferences\/contexts\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/contexts/:id",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/contexts/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/contexts\/merge$/,
+                upstreamPath: "/api/v1/preferences/contexts/merge",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/contexts/merge", url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/items$/,
+                upstreamPath: "/api/v1/preferences/items",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/items", url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/preferences\/items\/([^/]+)$/,
+                upstreamPath: "/api/v1/preferences/items/:id",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/items/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/items\/from-entity$/,
+                upstreamPath: "/api/v1/preferences/items/from-entity",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/items/from-entity", url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/judgments$/,
+                upstreamPath: "/api/v1/preferences/judgments",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/judgments", url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/preferences\/signals$/,
+                upstreamPath: "/api/v1/preferences/signals",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/preferences/signals", url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/preferences\/items\/([^/]+)\/score$/,
+                upstreamPath: "/api/v1/preferences/items/:id/score",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/preferences/items/${match[1]}/score`, url)
+            }
+        ]
+    },
+    {
+        path: "/forge/v1/psyche/questionnaires",
+        match: "prefix",
+        operations: [
+            {
+                method: "GET",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires$/,
+                upstreamPath: "/api/v1/psyche/questionnaires",
+                target: (_match, url) => passthroughSearch("/api/v1/psyche/questionnaires", url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires$/,
+                upstreamPath: "/api/v1/psyche/questionnaires",
+                requestBody: "json",
+                requiresToken: true,
+                target: (_match, url) => passthroughSearch("/api/v1/psyche/questionnaires", url)
+            },
+            {
+                method: "GET",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id",
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)\/clone$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id/clone",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}/clone`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)\/draft$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id/draft",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}/draft`, url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)\/draft$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id/draft",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}/draft`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)\/publish$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id/publish",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}/publish`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaires\/([^/]+)\/runs$/,
+                upstreamPath: "/api/v1/psyche/questionnaires/:id/runs",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaires/${match[1]}/runs`, url)
+            }
+        ]
+    },
+    {
+        path: "/forge/v1/psyche/questionnaire-runs",
+        match: "prefix",
+        operations: [
+            {
+                method: "GET",
+                pattern: /^\/forge\/v1\/psyche\/questionnaire-runs\/([^/]+)$/,
+                upstreamPath: "/api/v1/psyche/questionnaire-runs/:id",
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaire-runs/${match[1]}`, url)
+            },
+            {
+                method: "PATCH",
+                pattern: /^\/forge\/v1\/psyche\/questionnaire-runs\/([^/]+)$/,
+                upstreamPath: "/api/v1/psyche/questionnaire-runs/:id",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaire-runs/${match[1]}`, url)
+            },
+            {
+                method: "POST",
+                pattern: /^\/forge\/v1\/psyche\/questionnaire-runs\/([^/]+)\/complete$/,
+                upstreamPath: "/api/v1/psyche/questionnaire-runs/:id/complete",
+                requestBody: "json",
+                requiresToken: true,
+                target: (match, url) => passthroughSearch(`/api/v1/psyche/questionnaire-runs/${match[1]}/complete`, url)
+            }
+        ]
+    },
     {
         path: "/forge/v1/wiki/pages",
         match: "prefix",