forge-openclaw-plugin 0.2.59 → 0.2.61

package/dist/server/server/src/services/gamification-assets.js

@@ -0,0 +1,231 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import AdmZip from "adm-zip";
+import { getEffectiveDataRoot } from "../db.js";
+import { GAMIFICATION_CATALOG, GAMIFICATION_MASCOT_KEYS } from "../../../src/lib/gamification-catalog.js";
+const assetVersion = "0.2.59";
+const defaultReleaseBaseUrl = "https://github.com/albertbuchard/forge/releases/download/forge-gamification-assets-v0.2.59";
+const styleDefinitions = [
+    {
+        id: "dramatic-smithie",
+        label: "Fantasy",
+        description: "Warm, lighthearted 3D forge art with expressive mascot reactions and playful trophies.",
+        previewUrl: "/gamification-previews/dramatic-smithie-mascot.webp",
+        fileName: `forge-gamification-dramatic-smithie-${assetVersion}.zip`,
+        sha256: "407c98a89626d723f9f92e79411df7c999458459c96e0e09e73020b3d3ce14c0"
+    },
+    {
+        id: "dark-fantasy",
+        label: "Dark Fantasy",
+        description: "Obsidian iron, ember gold, high-pressure streak energy, and mythic trophy silhouettes.",
+        previewUrl: "/gamification-previews/dark-fantasy-mascot.webp",
+        fileName: `forge-gamification-dark-fantasy-${assetVersion}.zip`,
+        sha256: "9545900906784a23d15f4536eb8c32683ffff0ef42006d06c70cea101c1db570"
+    },
+    {
+        id: "mind-locksmith",
+        label: "Mind Locksmith",
+        description: "Modern locksmith-of-the-mind art for planning, memory, Psyche, health, and agent work.",
+        previewUrl: "/gamification-previews/mind-locksmith-mascot.webp",
+        fileName: `forge-gamification-mind-locksmith-${assetVersion}.zip`,
+        sha256: "cfdfd4259145e589e6e0fba8e1deb69d30931cfabbe6d626c0053e4f4cfe5f10"
+    }
+];
+export const defaultGamificationAssetStyle = "dramatic-smithie";
+function getCustomReleaseBaseUrl() {
+    return process.env.FORGE_GAMIFICATION_ASSET_BASE_URL?.trim().replace(/\/+$/, "");
+}
+function getDownloadUrl(style) {
+    const customReleaseBaseUrl = getCustomReleaseBaseUrl();
+    return `${customReleaseBaseUrl ?? defaultReleaseBaseUrl}/${style.fileName}`;
+}
+function getStyleDefinition(styleId) {
+    const style = styleDefinitions.find((candidate) => candidate.id === styleId);
+    if (!style) {
+        throw new Error(`Unknown gamification asset style: ${styleId}`);
+    }
+    return style;
+}
+function getExpectedSpritePaths(styleId) {
+    const itemAssetKeys = [
+        ...new Set(GAMIFICATION_CATALOG.map((item) => item.assetKey))
+    ];
+    const expectedPaths = new Set();
+    for (const key of itemAssetKeys) {
+        expectedPaths.add(`themes/${styleId}/items/${key}-256.webp`);
+        expectedPaths.add(`themes/${styleId}/items/${key}-512.webp`);
+    }
+    for (const key of GAMIFICATION_MASCOT_KEYS) {
+        expectedPaths.add(`themes/${styleId}/mascots/${key}-256.webp`);
+        expectedPaths.add(`themes/${styleId}/mascots/${key}-512.webp`);
+    }
+    return expectedPaths;
+}
+function assertSafeRelativePath(relativePath) {
+    if (relativePath.startsWith("/") ||
+        relativePath.includes("\\") ||
+        relativePath.split("/").some((segment) => segment === "..")) {
+        throw new Error(`Unsafe gamification asset path: ${relativePath}`);
+    }
+}
+function getStyleRoot(styleId) {
+    const style = getStyleDefinition(styleId);
+    return path.join(getEffectiveDataRoot(), "runtime-assets", "gamification", "styles", `${style.id}-${assetVersion}-${style.sha256.slice(0, 16)}`);
+}
+function getMarkerPath(styleId) {
+    return path.join(getStyleRoot(styleId), ".forge-gamification-style-ready.json");
+}
+async function countReadableFiles(root, relativePaths) {
+    let count = 0;
+    for (const relativePath of relativePaths) {
+        try {
+            await access(path.join(root, relativePath));
+            count += 1;
+        }
+        catch {
+            // Missing files are reported through the count.
+        }
+    }
+    return count;
+}
+async function readInstalledAt(styleId) {
+    try {
+        const marker = JSON.parse(await readFile(getMarkerPath(styleId), "utf8"));
+        return typeof marker.installedAt === "string" ? marker.installedAt : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getStyleStatus(styleId) {
+    const style = getStyleDefinition(styleId);
+    const expectedPaths = getExpectedSpritePaths(style.id);
+    const root = getStyleRoot(style.id);
+    const spriteCount = existsSync(getMarkerPath(style.id))
+        ? await countReadableFiles(root, expectedPaths)
+        : 0;
+    const installed = spriteCount === expectedPaths.size;
+    return {
+        ...style,
+        downloadUrl: getDownloadUrl(style),
+        installed,
+        spriteCount,
+        expectedSpriteCount: expectedPaths.size,
+        installedAt: installed ? await readInstalledAt(style.id) : null
+    };
+}
+export async function getGamificationAssetStatus() {
+    const styles = await Promise.all(styleDefinitions.map((style) => getStyleStatus(style.id)));
+    return {
+        version: assetVersion,
+        defaultStyle: defaultGamificationAssetStyle,
+        styles
+    };
+}
+function buildDownloadHeaders(url) {
+    const headers = {
+        Accept: "application/octet-stream"
+    };
+    const token = resolveGithubTokenForDownload(url);
+    if (token && /github\.com/i.test(url)) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    return headers;
+}
+function resolveGithubTokenForDownload(url) {
+    if (!/github\.com/i.test(url)) {
+        return undefined;
+    }
+    const envToken = process.env.FORGE_GAMIFICATION_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN;
+    if (envToken?.trim()) {
+        return envToken.trim();
+    }
+    const result = spawnSync("gh", ["auth", "token"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+    });
+    const cliToken = result.status === 0 ? result.stdout.trim() : "";
+    return cliToken || undefined;
+}
+function validateArchive(styleId, archive) {
+    const expectedPaths = getExpectedSpritePaths(styleId);
+    const entriesByName = new Map(archive
+        .getEntries()
+        .filter((entry) => !entry.isDirectory)
+        .map((entry) => {
+        assertSafeRelativePath(entry.entryName);
+        return [entry.entryName, entry];
+    }));
+    const missing = [...expectedPaths].filter((entryName) => !entriesByName.has(entryName));
+    const unexpected = [...entriesByName.keys()].filter((entryName) => !expectedPaths.has(entryName));
+    if (missing.length > 0 || unexpected.length > 0) {
+        throw new Error(`Invalid gamification style archive for ${styleId}. Missing ${missing.length}, unexpected ${unexpected.length}.`);
+    }
+    return { expectedPaths, entriesByName };
+}
+export async function installGamificationAssetStyle(styleId, fetchImpl = fetch) {
+    const style = getStyleDefinition(styleId);
+    const downloadUrl = getDownloadUrl(style);
+    const response = await fetchImpl(downloadUrl, {
+        headers: buildDownloadHeaders(downloadUrl)
+    });
+    if (!response.ok) {
+        throw new Error(`Could not download gamification assets (${response.status} ${response.statusText}).`);
+    }
+    const archivePayload = Buffer.from(await response.arrayBuffer());
+    const actualSha256 = createHash("sha256").update(archivePayload).digest("hex");
+    if (actualSha256 !== style.sha256) {
+        throw new Error(`Gamification asset checksum mismatch for ${style.id}. Expected ${style.sha256}, got ${actualSha256}.`);
+    }
+    const archive = new AdmZip(archivePayload);
+    const { expectedPaths, entriesByName } = validateArchive(style.id, archive);
+    const targetRoot = getStyleRoot(style.id);
+    await rm(targetRoot, { recursive: true, force: true });
+    for (const relativePath of expectedPaths) {
+        const entry = entriesByName.get(relativePath);
+        if (!entry) {
+            throw new Error(`Missing gamification archive entry: ${relativePath}`);
+        }
+        const targetPath = path.join(targetRoot, relativePath);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFile(targetPath, entry.getData());
+    }
+    await writeFile(getMarkerPath(style.id), `${JSON.stringify({
+        style: style.id,
+        version: assetVersion,
+        sha256: style.sha256,
+        spriteCount: expectedPaths.size,
+        installedAt: new Date().toISOString(),
+        source: downloadUrl
+    }, null, 2)}\n`, "utf8");
+    return getStyleStatus(style.id);
+}
+export async function resolveGamificationSpriteAssetPath(relativeSpritePath) {
+    const safePath = relativeSpritePath.replace(/^\/+/, "");
+    try {
+        assertSafeRelativePath(safePath);
+    }
+    catch {
+        return path.join(getEffectiveDataRoot(), "runtime-assets", "missing-gamification-asset");
+    }
+    const match = /^themes\/([^/]+)\//.exec(safePath);
+    if (!match) {
+        return path.join(getEffectiveDataRoot(), "runtime-assets", "missing-gamification-asset");
+    }
+    const styleId = match[1];
+    const style = styleDefinitions.find((candidate) => candidate.id === styleId);
+    if (!style) {
+        return path.join(getEffectiveDataRoot(), "runtime-assets", "missing-gamification-asset");
+    }
+    if (!getExpectedSpritePaths(style.id).has(safePath)) {
+        return path.join(getEffectiveDataRoot(), "runtime-assets", "missing-gamification-asset");
+    }
+    const status = await getStyleStatus(style.id);
+    if (!status.installed) {
+        return path.join(getEffectiveDataRoot(), "runtime-assets", "missing-gamification-asset");
+    }
+    return path.join(getStyleRoot(style.id), safePath);
+}

package/dist/server/server/src/services/gamification.js

@@ -1,10 +1,41 @@
 import { getDatabase } from "../db.js";
 import { enqueueGamificationCelebration, getGamificationEquipment, insertGamificationUnlock, listGamificationDailyActivity, listGamificationUnlocks, listUnseenGamificationCelebrations, replaceGamificationDailyActivity, upsertGamificationEquipment } from "../repositories/gamification.js";
-import { getDailyAmbientXp, listRewardRules } from "../repositories/rewards.js";
+import { getDailyAmbientXp, listRewardRules, recordEntityCreationReward } from "../repositories/rewards.js";
 import { getDefaultUser, listUsers, listUsersByIds } from "../repositories/users.js";
 import { GAMIFICATION_CATALOG, GAMIFICATION_STREAK_AWAY_DAY_KEYS, GAMIFICATION_STREAK_POWER_DAY_KEYS } from "../../../src/lib/gamification-catalog.js";
 import { achievementSignalSchema, gamificationCatalogPayloadSchema, gamificationProfileSchema, milestoneRewardSchema, rewardLedgerEventSchema } from "../types.js";
 const XP_CURVE_VERSION = "smith-forge";
+const ENTITY_CREATION_REWARD_SOURCES = [
+    { entityType: "goal", tableName: "goals", titleColumn: "title" },
+    { entityType: "project", tableName: "projects", titleColumn: "title" },
+    { entityType: "strategy", tableName: "strategies", titleColumn: "title" },
+    { entityType: "task", tableName: "tasks", titleColumn: "title" },
+    { entityType: "habit", tableName: "habits", titleColumn: "title" },
+    { entityType: "note", tableName: "notes", titleColumn: "content_plain" },
+    { entityType: "tag", tableName: "tags", titleColumn: "name" },
+    { entityType: "calendar_event", tableName: "calendar_events", titleColumn: "title" },
+    {
+        entityType: "work_block_template",
+        tableName: "work_block_templates",
+        titleColumn: "title"
+    },
+    { entityType: "task_timebox", tableName: "task_timeboxes", titleColumn: "title" },
+    {
+        entityType: "questionnaire_instrument",
+        tableName: "questionnaire_instruments",
+        titleColumn: "title"
+    },
+    { entityType: "psyche_value", tableName: "psyche_values", titleColumn: "title" },
+    {
+        entityType: "behavior_pattern",
+        tableName: "behavior_patterns",
+        titleColumn: "title"
+    },
+    { entityType: "behavior", tableName: "psyche_behaviors", titleColumn: "title" },
+    { entityType: "belief_entry", tableName: "belief_entries", titleColumn: "statement" },
+    { entityType: "mode_profile", tableName: "mode_profiles", titleColumn: "title" },
+    { entityType: "trigger_report", tableName: "trigger_reports", titleColumn: "title" }
+];
 function startOfWeek(date) {
     const clone = new Date(date);
     const day = clone.getDay();
@@ -209,6 +240,42 @@ function loadScopedRewardEvents(scope) {
         ? true
         : event.ownerUserId !== null && scopeUserIds.has(event.ownerUserId));
 }
+function syncEntityCreationRewards(scope) {
+    const database = getDatabase();
+    const scopeUserIds = [...new Set(scope.userIds)];
+    const scopePlaceholders = scopeUserIds.map(() => "?").join(", ");
+    for (const source of ENTITY_CREATION_REWARD_SOURCES) {
+        const scopedWhere = scopeUserIds.length > 0
+            ? `WHERE (
+             entity_owners.user_id IN (${scopePlaceholders})
+             OR (entity_owners.user_id IS NULL AND ? IS NOT NULL)
+           )`
+            : "";
+        const params = scopeUserIds.length > 0
+            ? [source.entityType, ...scopeUserIds, scopeUserIds[0] ?? null]
+            : [source.entityType];
+        const rows = database
+            .prepare(`SELECT
+           ${source.tableName}.id AS id,
+           ${source.tableName}.${source.titleColumn} AS title,
+           ${source.tableName}.created_at AS created_at
+         FROM ${source.tableName}
+         LEFT JOIN entity_owners
+           ON entity_owners.entity_type = ?
+          AND entity_owners.entity_id = ${source.tableName}.id
+         ${scopedWhere}`)
+            .all(...params);
+        for (const row of rows) {
+            recordEntityCreationReward({
+                entityType: source.entityType,
+                entityId: row.id,
+                title: row.title,
+                source: "system",
+                createdAt: row.created_at
+            });
+        }
+    }
+}
 function isQualifyingStreakReward(event) {
     return (event.deltaXp > 0 &&
         event.reversedByRewardId === null &&
@@ -245,8 +312,9 @@ function syncDailyActivity(userId, scopedRewards, timezone) {
 }
 function calculateStreakFromActivity(activeDateKeys, now, timezone) {
     const today = dateKeyInTimezone(now, timezone);
+    const yesterday = subtractDaysFromDateKey(today, 1);
     let streak = 0;
-    let cursor = today;
+    let cursor = activeDateKeys.has(today) ? today : yesterday;
     while (activeDateKeys.has(cursor)) {
         streak += 1;
         cursor = subtractDaysFromDateKey(cursor, 1);
@@ -297,8 +365,11 @@ function calculateMissedDays(activeDateKeys, now, timezone) {
     if (!latest || latest === today) {
         return { missedDays: 0, lastActiveDateKey: latest };
     }
+    if (latest === subtractDaysFromDateKey(today, 1)) {
+        return { missedDays: 0, lastActiveDateKey: latest };
+    }
     return {
-        missedDays: Math.max(0, daysBetweenDateKeys(latest, today)),
+        missedDays: Math.max(0, daysBetweenDateKeys(latest, today) - 1),
         lastActiveDateKey: latest
     };
 }
@@ -746,6 +817,7 @@ function syncCatalog(input) {
 function buildGamificationState(goals, tasks, habits, options = {}) {
     const now = options.now ?? new Date();
     const scope = resolveGamificationScope(options.userIds);
+    syncEntityCreationRewards(scope);
     const scopedRewards = loadScopedRewardEvents(scope);
     const timezone = resolveTimezone();
     const primaryUserId = scope.userIds[0] ?? "aggregate";

package/dist/server/server/src/types.js

@@ -2690,7 +2690,7 @@ export const settingsPayloadSchema = z.object({
     notifications: notificationPreferencesSchema,
     execution: executionSettingsSchema,
     themePreference: themePreferenceSchema,
-    gamificationTheme: gamificationThemeSchema.default("dark-fantasy"),
+    gamificationTheme: gamificationThemeSchema.default("dramatic-smithie"),
     customTheme: customThemeSchema.nullable(),
     localePreference: appLocaleSchema,
     security: z.object({

package/dist/server/server/src/web.js

@@ -1,14 +1,11 @@
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import AdmZip from "adm-zip";
-import { getEffectiveDataRoot } from "./db.js";
-import { GAMIFICATION_CATALOG, GAMIFICATION_MASCOT_KEYS } from "../../src/lib/gamification-catalog.js";
+import { resolveGamificationSpriteAssetPath } from "./services/gamification-assets.js";
 const distDir = path.join(process.cwd(), "dist");
 const packagedRuntimeDistDir = path.join(process.cwd(), "plugins", "forge-codex", "runtime", "dist");
 const contentTypes = {
@@ -23,14 +20,6 @@ const contentTypes = {
     ".woff2": "font/woff2"
 };
 const gamificationSpriteRoutePrefix = "/gamification/sprites/";
-const gamificationSpriteArchivePath = path.join("gamification", "sprites.zip");
-const gamificationSpriteThemes = [
-    "dark-fantasy",
-    "dramatic-smithie",
-    "mind-locksmith"
-];
-const gamificationSpriteSizes = [256, 512];
-let gamificationAssetExtractionPromise = null;
 function normalizeBasePath(value) {
     if (!value || value === "/") {
         return "/";
@@ -124,99 +113,10 @@ function resolveAsset(clientDir, requestPath) {
     const safePath = requestPath.replace(/^\/+/, "");
     return path.join(clientDir, safePath);
 }
-function buildExpectedGamificationSpritePaths() {
-    const itemAssetKeys = [
-        ...new Set(GAMIFICATION_CATALOG.map((item) => item.assetKey))
-    ];
-    const expectedPaths = new Set();
-    for (const theme of gamificationSpriteThemes) {
-        for (const size of gamificationSpriteSizes) {
-            for (const key of itemAssetKeys) {
-                expectedPaths.add(`themes/${theme}/items/${key}-${size}.webp`);
-            }
-            for (const key of GAMIFICATION_MASCOT_KEYS) {
-                expectedPaths.add(`themes/${theme}/mascots/${key}-${size}.webp`);
-            }
-        }
-    }
-    return expectedPaths;
-}
-function assertSafeZipEntryName(entryName) {
-    if (entryName.startsWith("/") ||
-        entryName.includes("\\") ||
-        entryName.split("/").some((segment) => segment === "..")) {
-        throw new Error(`Unsafe gamification asset archive entry: ${entryName}`);
-    }
-}
-async function countReadableFiles(root, relativePaths) {
-    let count = 0;
-    for (const relativePath of relativePaths) {
-        try {
-            await access(path.join(root, relativePath));
-            count += 1;
-        }
-        catch {
-            // Missing files are counted by the caller.
-        }
-    }
-    return count;
-}
-async function materializeGamificationAssets(clientDir) {
-    const archivePath = path.join(clientDir, gamificationSpriteArchivePath);
-    const archivePayload = await readFile(archivePath);
-    const archiveHash = createHash("sha256")
-        .update(archivePayload)
-        .digest("hex")
-        .slice(0, 16);
-    const targetRoot = path.join(getEffectiveDataRoot(), "runtime-assets", "gamification", `sprites-${archiveHash}`);
-    const markerPath = path.join(targetRoot, ".forge-gamification-sprites-ready.json");
-    const expectedPaths = buildExpectedGamificationSpritePaths();
-    if (existsSync(markerPath) &&
-        (await countReadableFiles(targetRoot, expectedPaths)) === expectedPaths.size) {
-        return targetRoot;
-    }
-    const archive = new AdmZip(archivePayload);
-    const entriesByName = new Map(archive
-        .getEntries()
-        .filter((entry) => !entry.isDirectory)
-        .map((entry) => {
-        assertSafeZipEntryName(entry.entryName);
-        return [entry.entryName, entry];
-    }));
-    const missing = [...expectedPaths].filter((entryName) => !entriesByName.has(entryName));
-    const unexpected = [...entriesByName.keys()].filter((entryName) => !expectedPaths.has(entryName));
-    if (missing.length > 0 || unexpected.length > 0) {
-        throw new Error(`Invalid gamification sprite archive. Missing ${missing.length}, unexpected ${unexpected.length}.`);
-    }
-    await rm(targetRoot, { recursive: true, force: true });
-    for (const relativePath of expectedPaths) {
-        const entry = entriesByName.get(relativePath);
-        if (!entry) {
-            throw new Error(`Missing gamification sprite archive entry: ${relativePath}`);
-        }
-        const targetPath = path.join(targetRoot, relativePath);
-        await mkdir(path.dirname(targetPath), { recursive: true });
-        await writeFile(targetPath, entry.getData());
-    }
-    await writeFile(markerPath, `${JSON.stringify({
-        archiveHash,
-        spriteCount: expectedPaths.size,
-        materializedAt: new Date().toISOString()
-    }, null, 2)}\n`, "utf8");
-    return targetRoot;
-}
 async function resolveBuiltAsset(clientDir, requestPath) {
     if (requestPath.startsWith(gamificationSpriteRoutePrefix)) {
         const relativeSpritePath = requestPath.slice(gamificationSpriteRoutePrefix.length);
-        const safePath = relativeSpritePath.replace(/^\/+/, "");
-        if (!gamificationAssetExtractionPromise) {
-            gamificationAssetExtractionPromise = materializeGamificationAssets(clientDir).catch((error) => {
-                gamificationAssetExtractionPromise = null;
-                throw error;
-            });
-        }
-        const spriteRoot = await gamificationAssetExtractionPromise;
-        return path.join(spriteRoot, safePath);
+        return resolveGamificationSpriteAssetPath(relativeSpritePath);
     }
     return resolveAsset(clientDir, requestPath);
 }
@@ -438,7 +338,10 @@ async function serveAsset(requestPath, reply, options) {
         return { error: "Not found" };
     }
     const normalizedRequestPath = stripBasePath(requestTarget.pathname, getDefaultBasePath());
-    const devWebOrigin = await options.devWebRuntime.ensureReady();
+    const handlesLocalGamificationSprite = normalizedRequestPath.startsWith(gamificationSpriteRoutePrefix);
+    const devWebOrigin = handlesLocalGamificationSprite
+        ? null
+        : await options.devWebRuntime.ensureReady();
     if (devWebOrigin) {
         try {
             return await proxyDevAsset({

package/dist/server/src/lib/api.js

@@ -1515,6 +1515,15 @@ export function getOperatorOverview() {
 export function getSettings() {
     return request("/api/v1/settings");
 }
+export function getForgeDoctor() {
+    return request("/api/v1/doctor");
+}
+export function applyForgeDoctorFixes(input) {
+    return request("/api/v1/doctor/fixes", {
+        method: "POST",
+        body: JSON.stringify(input)
+    });
+}
 export function saveAiModelConnection(input) {
     return request("/api/v1/settings/models/connections", {
         method: "POST",
@@ -2063,6 +2072,15 @@ export function getGamificationCatalog(userIds) {
     const suffix = search.toString() ? `?${search}` : "";
     return request(`/api/v1/gamification/catalog${suffix}`);
 }
+export function getGamificationAssetStatus() {
+    return request("/api/v1/gamification/assets");
+}
+export function installGamificationAssetStyle(style) {
+    return request("/api/v1/gamification/assets/install", {
+        method: "POST",
+        body: JSON.stringify({ style })
+    });
+}
 export function getGamificationEquipment(userIds) {
     const search = new URLSearchParams();
     appendUserIds(search, coerceUserIds(userIds));

package/dist/server/src/lib/gamification-catalog.js

@@ -222,7 +222,7 @@ const PSYCHE_TROPHIES = [
     trophy("psyche", "Value Blade", allOf(metric("psycheValueCount", 10), metric("goalLinkedTaskCompletionCount", 100)), "Create 10 values and complete 100 goal-linked tasks.", "Values and work started cutting in the same direction."),
     trophy("psyche", "Shadow Temper", allOf(metric("modeProfileCount", 12), metric("triggerReportRichCount", 50)), "Create 12 modes and 50 rich trigger reports.", "Shadow material became usable steel."),
     trophy("psyche", "Inner Forge", allOf(metric("psycheValueCount", 12), metric("behaviorPatternCount", 25), metric("beliefFlexibleAlternativeCount", 30)), "Create 12 values, 25 patterns, and 30 flexible beliefs.", "A full inner forge takes shape."),
-    trophy("psyche", "Schema Bell", metric("questionnaireRunCount", 10), "Complete 10 questionnaire runs.", "Structured self-observation rang the bell repeatedly."),
+    trophy("psyche", "Schema Bell", metric("questionnaireRunCount", 40), "Complete 40 questionnaire runs.", "Structured self-observation rang the bell repeatedly."),
     trophy("psyche", "Mode Guide", metric("modeGuideSessionCount", 5), "Complete 5 mode guide sessions.", "Guided mode work became an actual practice."),
     trophy("psyche", "Repair Script", metric("behaviorCount", 10), "Create 10 Psyche behaviors.", "Behaviors now carry repair plans, not just names."),
     trophy("psyche", "Flexible Self", metric("beliefFlexibleAlternativeCount", 50), "Create 50 beliefs with flexible alternatives.", "A trophy for not letting old beliefs remain iron cages."),

package/dist/server/src/lib/schemas.js

@@ -56,7 +56,7 @@ export const settingsMutationSchema = z.object({
         timeAccountingMode: z.enum(["split", "parallel", "primary_only"])
     }),
     themePreference: forgeThemePreferenceSchema,
-    gamificationTheme: gamificationThemeSchema.default("dark-fantasy"),
+    gamificationTheme: gamificationThemeSchema.default("dramatic-smithie"),
     customTheme: forgeCustomThemeSchema.nullable().optional(),
     localePreference: appLocaleSchema,
     calendarProviders: z

package/openclaw.plugin.json

@@ -2,10 +2,92 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.59",
+  "version": "0.2.61",
+  "activation": {
+    "onStartup": true,
+    "onCapabilities": [
+      "tool"
+    ],
+    "onCommands": [
+      "forge"
+    ]
+  },
   "skills": [
     "./skills"
   ],
+  "commandAliases": [
+    {
+      "name": "forge"
+    }
+  ],
+  "contracts": {
+    "tools": [
+      "forge_adjust_work_minutes",
+      "forge_apply_doctor_fix",
+      "forge_call_life_force_route",
+      "forge_call_movement_route",
+      "forge_call_workbench_route",
+      "forge_clone_questionnaire",
+      "forge_complete_questionnaire_run",
+      "forge_complete_task_run",
+      "forge_connect_calendar_provider",
+      "forge_create_entities",
+      "forge_create_task_timebox",
+      "forge_create_work_block_template",
+      "forge_delete_entities",
+      "forge_enqueue_preferences_item_from_entity",
+      "forge_ensure_questionnaire_draft",
+      "forge_focus_task_run",
+      "forge_get_agent_onboarding",
+      "forge_get_calendar_overview",
+      "forge_get_current_work",
+      "forge_get_doctor",
+      "forge_get_operator_context",
+      "forge_get_operator_overview",
+      "forge_get_preferences_workspace",
+      "forge_get_psyche_overview",
+      "forge_get_questionnaire",
+      "forge_get_questionnaire_run",
+      "forge_get_self_observation_calendar",
+      "forge_get_sleep_overview",
+      "forge_get_sports_overview",
+      "forge_get_ui_entrypoint",
+      "forge_get_user_directory",
+      "forge_get_weekly_review",
+      "forge_get_wiki_health",
+      "forge_get_wiki_page",
+      "forge_get_wiki_settings",
+      "forge_get_xp_metrics",
+      "forge_grant_reward_bonus",
+      "forge_heartbeat_task_run",
+      "forge_ingest_wiki_source",
+      "forge_list_questionnaires",
+      "forge_list_wiki_pages",
+      "forge_log_work",
+      "forge_merge_preferences_contexts",
+      "forge_post_insight",
+      "forge_publish_questionnaire_draft",
+      "forge_recommend_task_timeboxes",
+      "forge_reindex_wiki_embeddings",
+      "forge_release_task_run",
+      "forge_restore_entities",
+      "forge_search_entities",
+      "forge_search_wiki",
+      "forge_start_preferences_game",
+      "forge_start_questionnaire_run",
+      "forge_start_task_run",
+      "forge_submit_preferences_judgment",
+      "forge_submit_preferences_signal",
+      "forge_sync_calendar_connection",
+      "forge_sync_wiki_vault",
+      "forge_update_entities",
+      "forge_update_preferences_score",
+      "forge_update_questionnaire_run",
+      "forge_update_sleep_session",
+      "forge_update_workout_session",
+      "forge_upsert_wiki_page"
+    ]
+  },
   "uiHints": {
     "origin": {
       "label": "Forge Origin",
@@ -19,7 +101,7 @@
     },
     "dataRoot": {
       "label": "Forge Data Root",
-      "help": "Absolute folder path for the shared Forge home. Local installs default to ~/.forge so OpenClaw, Hermes, and Codex automatically meet in one runtime.",
+      "help": "Optional absolute folder path for Forge data. Defaults to ~/.forge. When set, Forge stores forge.sqlite directly in this folder; use the same value across adapters that should share one database.",
       "placeholder": "~/.forge",
       "advanced": true
     },
@@ -63,7 +145,7 @@
       "dataRoot": {
         "type": "string",
         "default": "~/.forge",
-        "description": "Absolute path for the shared Forge data root. Defaults to ~/.forge so local OpenClaw, Hermes, and Codex installs converge on one runtime."
+        "description": "Absolute path for the shared Forge data root. Defaults to ~/.forge. Explicit values override that default; use the same value across local adapters that should share one database."
       },
       "apiToken": {
         "type": "string",