forge-openclaw-plugin 0.2.61 → 0.2.66

package/dist/server/server/src/services/life-force.js

@@ -23,6 +23,73 @@ const LIFE_FORCE_STAT_LABELS = {
     composure: "Composure",
     flow: "Flow"
 };
+const AGENT_ACTOR_PATTERN = /\b(codex|hermes|openclaw|agent|bot)\b|aurel\s+the\s+bot/i;
+const PASSIVE_CALENDAR_PATTERN = /\b(vacation|vacances?|cong[eé]s?|absence|holiday|out\s+of\s+office|ooo|away|leave|off)\b/i;
+function isAgentAuthoredActivity(input) {
+    if (input.source === "agent") {
+        return true;
+    }
+    return AGENT_ACTOR_PATTERN.test(input.actor ?? "");
+}
+function agentSupervisionMultiplier(input) {
+    if (!isAgentAuthoredActivity(input)) {
+        return 1;
+    }
+    return input.goalLinked ? 0.05 : 0.15;
+}
+function noteApMultiplier(input) {
+    const author = input.author?.trim().toLowerCase() ?? "";
+    if (input.source === "system" && author === "movement sync") {
+        return 0;
+    }
+    return isAgentAuthoredActivity({ actor: input.author, source: input.source })
+        ? 0.15
+        : 1;
+}
+function calendarCategoriesText(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.join(" ") : "";
+    }
+    catch {
+        return "";
+    }
+}
+function isPassiveCalendarContainer(row, profile) {
+    const hasManualOrCustomApProfile = profile?.sourceMethod === "manual" ||
+        (profile?.metadata.customSustainRateApPerHour !== null &&
+            profile?.metadata.customSustainRateApPerHour !== undefined);
+    if (hasManualOrCustomApProfile) {
+        return false;
+    }
+    const durationHours = Math.max(0, (Date.parse(row.end_at) - Date.parse(row.start_at)) / 3_600_000);
+    const searchable = [
+        row.title,
+        row.event_type,
+        calendarCategoriesText(row.categories_json)
+    ].join(" ");
+    if (row.availability === "free") {
+        return true;
+    }
+    if (row.is_all_day === 1) {
+        return true;
+    }
+    return durationHours >= 12 && PASSIVE_CALENDAR_PATTERN.test(searchable);
+}
+function scaleContributionAp(contribution, multiplier, reason) {
+    if (multiplier >= 1) {
+        return contribution;
+    }
+    return {
+        ...contribution,
+        totalAp: Number((contribution.totalAp * Math.max(0, multiplier)).toFixed(4)),
+        why: `${contribution.why} ${reason}`,
+        metadata: {
+            ...(contribution.metadata ?? {}),
+            personalApMultiplier: multiplier
+        }
+    };
+}
 const CALENDAR_ACTIVITY_PRESETS = {
     deep_work: {
         title: "Deep work",
@@ -987,6 +1054,7 @@ function readTaskRunRows(range, userId) {
          task_runs.timed_out_at,
          task_runs.updated_at,
          tasks.title AS task_title,
+         tasks.goal_id AS task_goal_id,
          task_runs.planned_duration_seconds,
          tasks.planned_duration_seconds AS task_expected_duration_seconds
        FROM task_runs
@@ -1103,7 +1171,39 @@ function getOrCreateDaySnapshot(userId, date) {
        WHERE user_id = ? AND date_key = ?`)
         .get(userId, range.dateKey);
     if (existing) {
-        return existing;
+        const profile = ensureLifeForceProfile(userId);
+        const template = readWeekdayTemplate(userId, date.getUTCDay());
+        const sleepRecoveryMultiplier = computeSleepRecoveryMultiplier(userId, date);
+        const fatigueDebtCarry = computeFatigueDebtCarry(userId, date);
+        const readinessMultiplier = profile.readiness_multiplier;
+        const dailyBudgetAp = Math.max(40, Math.round(profile.base_daily_ap *
+            computeLifeForceMultiplier(profile) *
+            sleepRecoveryMultiplier *
+            readinessMultiplier) - fatigueDebtCarry);
+        const derivedChanged = Math.abs(existing.daily_budget_ap - dailyBudgetAp) > 0.01 ||
+            Math.abs(existing.sleep_recovery_multiplier - sleepRecoveryMultiplier) > 0.001 ||
+            Math.abs(existing.readiness_multiplier - readinessMultiplier) > 0.001 ||
+            Math.abs(existing.fatigue_debt_carry - fatigueDebtCarry) > 0.01;
+        if (!derivedChanged) {
+            return existing;
+        }
+        const points = normalizeCurveToBudget(parseCurvePoints(template.points_json), dailyBudgetAp);
+        const updatedAt = nowIso();
+        getDatabase()
+            .prepare(`UPDATE life_force_day_snapshots
+         SET daily_budget_ap = ?,
+             sleep_recovery_multiplier = ?,
+             readiness_multiplier = ?,
+             fatigue_debt_carry = ?,
+             points_json = ?,
+             updated_at = ?
+         WHERE id = ?`)
+            .run(dailyBudgetAp, sleepRecoveryMultiplier, readinessMultiplier, fatigueDebtCarry, JSON.stringify(points), updatedAt, existing.id);
+        return getDatabase()
+            .prepare(`SELECT *
+         FROM life_force_day_snapshots
+         WHERE id = ?`)
+            .get(existing.id);
     }
     const profile = ensureLifeForceProfile(userId);
     const template = readWeekdayTemplate(userId, date.getUTCDay());
@@ -1190,8 +1290,11 @@ function readTodayAdjustmentRows(userId, range) {
          work_adjustments.entity_id,
          work_adjustments.applied_delta_minutes,
          work_adjustments.note,
+         work_adjustments.actor,
+         work_adjustments.source,
          work_adjustments.created_at,
-         tasks.planned_duration_seconds
+         tasks.planned_duration_seconds,
+         tasks.goal_id AS task_goal_id
        FROM work_adjustments
        LEFT JOIN tasks
          ON work_adjustments.entity_type = 'task'
@@ -1216,7 +1319,11 @@ function readTodayAdjustmentApByTaskId(userId, range, lifeForceProfile) {
             id: row.entity_id,
             plannedDurationSeconds: row.planned_duration_seconds
         }, lifeForceProfile);
-        const deltaAp = rateToTotalAp(profile.sustainRateApPerHour, row.applied_delta_minutes * 60);
+        const deltaAp = rateToTotalAp(profile.sustainRateApPerHour, row.applied_delta_minutes * 60) * agentSupervisionMultiplier({
+            actor: row.actor,
+            source: row.source,
+            goalLinked: Boolean(row.task_goal_id)
+        });
         totals.set(row.entity_id, (totals.get(row.entity_id) ?? 0) + deltaAp);
     }
     return totals;
@@ -1301,7 +1408,7 @@ function buildWorkAdjustmentContributions(userId, range, lifeForceProfile) {
             plannedDurationSeconds: row.planned_duration_seconds
         }, lifeForceProfile);
         const totalAp = rateToTotalAp(profile.sustainRateApPerHour, row.applied_delta_minutes * 60);
-        return {
+        return scaleContributionAp({
             entityType: "task",
             entityId: row.entity_id,
             eventKind: "work_adjustment",
@@ -1315,9 +1422,15 @@ function buildWorkAdjustmentContributions(userId, range, lifeForceProfile) {
             role: "background",
             metadata: {
                 adjustmentId: row.id,
-                appliedDeltaMinutes: row.applied_delta_minutes
+                appliedDeltaMinutes: row.applied_delta_minutes,
+                actor: row.actor,
+                source: row.source
             }
-        };
+        }, agentSupervisionMultiplier({
+            actor: row.actor,
+            source: row.source,
+            goalLinked: Boolean(row.task_goal_id)
+        }), "Agent-authored manual work is charged as light supervision AP instead of full human effort.");
     });
 }
 function buildTaskRunContributions(userId, range, now, lifeForceProfile) {
@@ -1336,7 +1449,7 @@ function buildTaskRunContributions(userId, range, now, lifeForceProfile) {
         const totalAp = rateToTotalAp(profile.sustainRateApPerHour, seconds);
         const startsAt = new Date(Math.max(range.startMs, Date.parse(row.claimed_at))).toISOString();
         const endsAt = new Date(Math.min(range.endMs, terminalRunMs(row, now))).toISOString();
-        const contribution = {
+        const contribution = scaleContributionAp({
             entityType: "task",
             entityId: row.task_id,
             eventKind: "task_run",
@@ -1348,8 +1461,11 @@ function buildTaskRunContributions(userId, range, now, lifeForceProfile) {
             startsAt,
             endsAt,
             role: row.is_current === 1 ? "primary" : "secondary",
-            metadata: { taskRunId: row.id }
-        };
+            metadata: { taskRunId: row.id, actor: row.actor }
+        }, agentSupervisionMultiplier({
+            actor: row.actor,
+            goalLinked: Boolean(row.task_goal_id)
+        }), "Agent-authored task runs are charged as supervision AP for the human user.");
         contributions.push(contribution);
         const existing = totalsByTaskId.get(row.task_id) ?? { todayAp: 0, totalAp: 0 };
         existing.todayAp += totalAp;
@@ -1372,6 +1488,8 @@ function buildNoteContributions(userId, range, now, lifeForceProfile) {
             .prepare(`SELECT
            notes.id,
            notes.title,
+           notes.author,
+           notes.source,
            notes.created_at,
            GROUP_CONCAT(
              CASE
@@ -1399,19 +1517,34 @@ function buildNoteContributions(userId, range, now, lifeForceProfile) {
                 .filter(Boolean);
             return !linkedTaskIds.some((taskId) => (taskRunWindowsByTaskId.get(taskId) ?? []).some((window) => createdAtMs >= window.startMs && createdAtMs <= window.endMs));
         })
-            .map((row) => ({
-            entityType: "note",
-            entityId: row.id,
-            eventKind: "note_created",
-            sourceKind: "note",
-            totalAp: noteProfile.totalCostAp,
-            rateApPerHour: null,
-            title: row.title || "Note",
-            why: "Standalone capture takes a small impulse of activation and focus.",
-            startsAt: row.created_at,
-            endsAt: row.created_at,
-            role: "background"
-        }));
+            .flatMap((row) => {
+            const multiplier = noteApMultiplier({
+                author: row.author,
+                source: row.source
+            });
+            if (multiplier <= 0) {
+                return [];
+            }
+            return [
+                scaleContributionAp({
+                    entityType: "note",
+                    entityId: row.id,
+                    eventKind: "note_created",
+                    sourceKind: "note",
+                    totalAp: noteProfile.totalCostAp,
+                    rateApPerHour: null,
+                    title: row.title || "Note",
+                    why: "Standalone capture takes a small impulse of activation and focus.",
+                    startsAt: row.created_at,
+                    endsAt: row.created_at,
+                    role: "background",
+                    metadata: {
+                        author: row.author,
+                        source: row.source
+                    }
+                }, multiplier, "Agent-authored notes are charged as a small monitoring impulse instead of full personal work.")
+            ];
+        });
     }
     catch {
         return [];
@@ -1652,8 +1785,10 @@ function readCalendarEventLifeForceRows(range) {
            forge_events.title,
            forge_events.start_at,
            forge_events.end_at,
+           forge_events.is_all_day,
            forge_events.availability,
            forge_events.event_type,
+           forge_events.categories_json,
            COUNT(forge_event_links.id) AS link_count
          FROM forge_events
          LEFT JOIN forge_event_links
@@ -1666,8 +1801,10 @@ function readCalendarEventLifeForceRows(range) {
            forge_events.title,
            forge_events.start_at,
            forge_events.end_at,
+           forge_events.is_all_day,
            forge_events.availability,
-           forge_events.event_type`)
+           forge_events.event_type,
+           forge_events.categories_json`)
             .all(range.from, range.to);
     }
     catch {
@@ -1973,11 +2110,15 @@ function buildCalendarDrains(rows, now, range, lifeForceProfile, blockingWindows
     const plannedDrains = [];
     try {
         for (const row of rows) {
-            const calendarProfile = buildEffectiveProfile(readEntityActionProfile("calendar_event", row.id, {
+            const storedProfile = readEntityActionProfile("calendar_event", row.id, {
                 profileKey: `calendar_event_${row.id}`,
                 title: row.title,
                 entityType: "calendar_event"
-            }) ??
+            });
+            if (isPassiveCalendarContainer(row, storedProfile)) {
+                continue;
+            }
+            const calendarProfile = buildEffectiveProfile(storedProfile ??
                 buildCalendarEventActionProfile({
                     eventId: row.id,
                     title: row.title,

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

@@ -1,5 +1,5 @@
-import { request as httpRequest } from "node:http";
-import { request as httpsRequest } from "node:https";
+import { Agent as HttpAgent, request as httpRequest } from "node:http";
+import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { access, readFile } from "node:fs/promises";
@@ -80,7 +80,8 @@ function buildManagedDevWebLaunch(input) {
         };
     }
     const host = input.env.FORGE_DEV_WEB_HOST?.trim() || "127.0.0.1";
-    const port = input.env.FORGE_DEV_WEB_PORT?.trim() || getDefaultDevWebOriginPort(input.origin);
+    const port = input.env.FORGE_DEV_WEB_PORT?.trim() ||
+        getDefaultDevWebOriginPort(input.origin);
     return {
         command: process.execPath,
         args: [viteCliPath, "--host", host, "--port", port],
@@ -136,15 +137,23 @@ function parseRequestTarget(requestPath) {
 function copyProxyHeaders(response, reply) {
     for (const [name, value] of response.headers) {
         const lowerName = name.toLowerCase();
-        if (lowerName === "connection" ||
-            lowerName === "content-length" ||
-            lowerName === "keep-alive" ||
-            lowerName === "transfer-encoding") {
+        if (hopByHopHeaders.has(lowerName)) {
             continue;
         }
         reply.header(name, value);
     }
 }
+const hopByHopHeaders = new Set([
+    "connection",
+    "content-length",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade"
+]);
 function buildDevWebTarget(origin, pathname, search) {
     const target = new URL(pathname.startsWith("/") ? pathname.slice(1) : pathname, origin);
     target.search = search;
@@ -163,6 +172,72 @@ async function proxyDevAsset(input) {
     }
     return Buffer.from(await response.arrayBuffer());
 }
+export function createKeepAliveDevAssetProxy() {
+    const httpAgent = new HttpAgent({
+        keepAlive: true,
+        maxFreeSockets: 8,
+        maxSockets: 32
+    });
+    const httpsAgent = new HttpsAgent({
+        keepAlive: true,
+        maxFreeSockets: 8,
+        maxSockets: 32
+    });
+    return {
+        fetch(input) {
+            const target = buildDevWebTarget(input.origin, input.pathname, input.search);
+            const isHttps = target.protocol === "https:";
+            const request = isHttps ? httpsRequest : httpRequest;
+            const agent = isHttps ? httpsAgent : httpAgent;
+            return new Promise((resolve, reject) => {
+                const proxyRequest = request(target, {
+                    agent,
+                    headers: {
+                        Accept: "*/*",
+                        Host: target.host
+                    },
+                    method: "GET"
+                }, (response) => {
+                    input.reply.code(response.statusCode ?? 502);
+                    for (const [name, value] of Object.entries(response.headers)) {
+                        if (!value || hopByHopHeaders.has(name.toLowerCase())) {
+                            continue;
+                        }
+                        input.reply.header(name, value);
+                    }
+                    if (!response.headers["cache-control"]) {
+                        input.reply.header("Cache-Control", "no-store, max-age=0, must-revalidate");
+                    }
+                    const chunks = [];
+                    response.on("data", (chunk) => {
+                        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                    });
+                    response.on("end", () => {
+                        resolve(Buffer.concat(chunks));
+                    });
+                    response.on("error", reject);
+                });
+                proxyRequest.on("error", reject);
+                proxyRequest.end();
+            });
+        },
+        close() {
+            httpAgent.destroy();
+            httpsAgent.destroy();
+        }
+    };
+}
+function createDevAssetProxy(fetchImpl) {
+    if (fetchImpl !== fetch) {
+        return {
+            fetch(input) {
+                return proxyDevAsset({ ...input, fetchImpl });
+            },
+            close() { }
+        };
+    }
+    return createKeepAliveDevAssetProxy();
+}
 function writeProxyUpgradeResponse(socket, response) {
     const statusCode = response.statusCode ?? 101;
     const statusMessage = response.statusMessage ?? "Switching Protocols";
@@ -344,12 +419,11 @@ async function serveAsset(requestPath, reply, options) {
         : await options.devWebRuntime.ensureReady();
     if (devWebOrigin) {
         try {
-            return await proxyDevAsset({
+            return await options.devAssetProxy.fetch({
                 origin: devWebOrigin,
                 pathname: normalizedRequestPath,
                 search: requestTarget.search,
-                reply,
-                fetchImpl: options.fetchImpl
+                reply
             });
         }
         catch {
@@ -393,8 +467,10 @@ async function serveAsset(requestPath, reply, options) {
 export async function registerWebRoutes(app, options = {}) {
     const devWebRuntime = options.devWebRuntime ?? createManagedDevWebRuntime();
     const fetchImpl = options.fetchImpl ?? fetch;
+    const devAssetProxy = options.devAssetProxy ?? createDevAssetProxy(fetchImpl);
     app.addHook("onClose", async () => {
         await devWebRuntime.stop();
+        devAssetProxy.close();
     });
     app.server.on("upgrade", (request, socket, head) => {
         void (async () => {
@@ -406,6 +482,6 @@ export async function registerWebRoutes(app, options = {}) {
             });
         })();
     });
-    app.get("/", async (_request, reply) => serveAsset("/", reply, { devWebRuntime, fetchImpl }));
-    app.get("/*", async (request, reply) => serveAsset(request.url, reply, { devWebRuntime, fetchImpl }));
+    app.get("/", async (_request, reply) => serveAsset("/", reply, { devWebRuntime, devAssetProxy }));
+    app.get("/*", async (request, reply) => serveAsset(request.url, reply, { devWebRuntime, devAssetProxy }));
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "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.61",
+  "version": "0.2.66",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.61",
+  "version": "0.2.66",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -103,7 +103,7 @@
     "axios": "^1.16.0",
     "fast-xml-parser": "^5.7.1",
     "follow-redirects": "^1.16.0",
-    "hono": "4.12.14",
+    "hono": "^4.12.18",
     "ip-address": "^10.2.0",
     "uuid": "^14.0.0"
   },

package/skills/forge-openclaw/SKILL.md

@@ -89,8 +89,11 @@ guessing.
   exact `/api/v1/*` route or OpenClaw `/forge/v1/*` mirror published in onboarding.
   Life Force may be keyed as `lifeForce` and as the entity-style alias `life_force`;
   both point to the same `/api/v1/life-force/*` route family.
-- The specialized route-key tool schemas include the exact route-key to method/path
-  map. When a route key's exact path contains placeholders such as `:id`,
+- The live onboarding `methodRoutes` map and the specialized route-key tool schemas
+  include the exact route-key to method/path map. Use `methodRoutes` as the
+  route-key-to-`METHOD /api/v1/...` source of truth when checking specialized
+  methods, especially POST aggregate reads such as Movement `selection` and DELETE
+  repair paths. When a route key's exact path contains placeholders such as `:id`,
   `:weekday`, `:runId`, or `:nodeId`, pass those values in `pathParams` using the
   placeholder names exactly. Do not place IDs inside `routeKey`, invent a raw route
   string, or ask the user to choose an endpoint when the lane already selects one. If
@@ -98,6 +101,40 @@ guessing.
   call and treat the disagreement as a Forge contract bug to fix, not as a reason to
   guess a nearby route.
 
+Concrete route-key examples for internal use:
+
+- Movement all-time read:
+  `{"routeKey":"allTime","query":{"userIds":["user_operator"]}}`
+- Movement timeline read:
+  `{"routeKey":"timeline","query":{"from":"2026-05-01T00:00:00.000Z","to":"2026-05-06T23:59:59.999Z","userIds":["user_operator"]}}`
+- Movement selection aggregate:
+  `{"routeKey":"selection","query":{"from":"2026-05-01T00:00:00.000Z","to":"2026-05-14T23:59:59.999Z","placeIds":["place_home"],"userIds":["user_operator"]}}`
+- Movement trip detail:
+  `{"routeKey":"tripDetail","pathParams":{"id":"trip_123"}}`
+- Movement missing-stay correction:
+  first `{"routeKey":"userBoxPreflight","body":{"kind":"stay","startedAt":"2026-05-06T13:00:00.000Z","endedAt":"2026-05-06T15:00:00.000Z","placeLabel":"Home","userId":"user_operator"}}`,
+  then `{"routeKey":"userBoxCreate","body":{"kind":"stay","startedAt":"2026-05-06T13:00:00.000Z","endedAt":"2026-05-06T15:00:00.000Z","placeLabel":"Home","userId":"user_operator","note":"Manual correction after reviewing the timeline."}}`
+- Life Force overview:
+  `{"routeKey":"overview"}`
+- Life Force profile edit:
+  `{"routeKey":"profile","body":{"baselineDailyAp":24,"recoveryNotes":"Clinic-admin days need a lower expected afternoon load."}}`
+- Life Force weekday template edit:
+  `{"routeKey":"weekdayTemplate","pathParams":{"weekday":"monday"},"body":{"points":[{"hour":13,"freeAp":-4}]}}`
+- Life Force fatigue signal:
+  `{"routeKey":"fatigueSignal","body":{"signal":"tired","intensity":7,"note":"Sharp post-lunch dip after clinic admin."}}`
+- Workbench flow catalog:
+  `{"routeKey":"listFlows","query":{"includeArchived":false}}`
+- Workbench box catalog:
+  `{"routeKey":"boxCatalog"}`
+- Workbench run detail:
+  `{"routeKey":"runDetail","pathParams":{"id":"flow_research_digest","runId":"run_123"}}`
+- Workbench published output:
+  `{"routeKey":"publishedOutput","pathParams":{"id":"flow_research_digest"}}`
+- Workbench latest node output:
+  `{"routeKey":"latestNodeOutput","pathParams":{"id":"flow_research_digest","nodeId":"node_summary"}}`
+- Workbench run execution:
+  `{"routeKey":"runFlow","pathParams":{"id":"flow_research_digest"},"body":{"input":{"topic":"question flow quality"}}}`
+
 Preferences rule:
 
 - When the user wants to understand or refine taste, ranking, recommendation fit, or “what Forge thinks I like”, treat that as the Preferences surface rather than a normal planning intake.
@@ -136,6 +173,11 @@ Health rule:
 
 - Sleep and sports records are first-class health surfaces, not generic notes or tasks.
 - Use `forge_get_sleep_overview` and `forge_get_sports_overview` for review and trend reading.
+- In `forge_get_agent_onboarding.entityRouteModel.readModelOnlySurfaces`, the health
+  overview routes are published under both the plain names `sleepOverview` and
+  `sportsOverview` and the entity-style aliases `sleep_overview` and
+  `sports_overview`. Treat those as read-only overview surfaces, not batch CRUD
+  entities.
 - Use the shared batch entity tools for ordinary `sleep_session` and `workout_session` create, update, delete, and search work. Do not force agents into a large one-route-per-entity mental model when the batch routes already cover the record cleanly.
 - Use `forge_update_sleep_session` and `forge_update_workout_session` only when the job is reflective enrichment on one existing health record after review, such as attaching notes, tags, mood, meaning, or Forge links.
 - Habit-generated workouts and imported HealthKit workouts belong to the same workout record model, so do not invent a separate storage path for sport sessions.