forge-openclaw-plugin 0.3.12 → 0.3.14

package/dist/server/server/src/health-weight-loss.js

@@ -13,6 +13,9 @@ const scoreSchema = z
     .union([z.coerce.number().int().min(0).max(10), z.null()])
     .optional();
 const tagsSchema = z.array(z.string().trim().min(1)).default([]);
+const parsedStringDefaultSchema = z.preprocess((value) => (typeof value === "string" ? value : ""), z.string().trim());
+const parsedOptionalDatetimeSchema = z.preprocess((value) => (typeof value === "string" && value.trim() ? value : undefined), z.string().datetime().optional());
+const parsedOptionalNumberSchema = z.preprocess((value) => (value === null || value === "" ? undefined : value), z.coerce.number().finite().optional());
 const linksSchema = z
     .array(z.object({
     entityType: z.string().trim().min(1),
@@ -2169,28 +2172,300 @@ function getNutritionCodexProfile(connectionId) {
 }
 const parsedMealItemSchema = z.object({
     name: z.string().trim().min(1),
+    searchQuery: parsedStringDefaultSchema.default(""),
+    brand: parsedStringDefaultSchema.default(""),
     quantity: z.coerce.number().positive().default(1),
     unit: z.string().trim().min(1).default("serving"),
-    grams: optionalNumberSchema,
-    calories: optionalNumberSchema,
-    proteinGrams: optionalNumberSchema,
-    carbohydrateGrams: optionalNumberSchema,
-    fatGrams: optionalNumberSchema,
-    fiberGrams: optionalNumberSchema,
-    sugarGrams: optionalNumberSchema,
-    sodiumMg: optionalNumberSchema,
+    grams: parsedOptionalNumberSchema,
+    calories: parsedOptionalNumberSchema,
+    proteinGrams: parsedOptionalNumberSchema,
+    carbohydrateGrams: parsedOptionalNumberSchema,
+    fatGrams: parsedOptionalNumberSchema,
+    fiberGrams: parsedOptionalNumberSchema,
+    sugarGrams: parsedOptionalNumberSchema,
+    sodiumMg: parsedOptionalNumberSchema,
     tags: tagsSchema,
     confidence: z.coerce.number().min(0).max(1).default(0.45)
 });
 const parsedMealSchema = z.object({
     mealLabel: z.string().trim().default(""),
-    loggedAt: z.string().datetime().optional(),
+    loggedAt: parsedOptionalDatetimeSchema,
     items: z.array(parsedMealItemSchema).min(1),
     uncertaintyReasons: z.array(z.string()).default([]),
     clarificationQuestions: z.array(z.string()).default([]),
     tags: tagsSchema
 });
+const parsedMealNutritionCompletionSchema = z.object({
+    items: z
+        .array(z.object({
+        index: z.coerce.number().int().min(0),
+        grams: parsedOptionalNumberSchema,
+        calories: parsedOptionalNumberSchema,
+        proteinGrams: parsedOptionalNumberSchema,
+        carbohydrateGrams: parsedOptionalNumberSchema,
+        fatGrams: parsedOptionalNumberSchema,
+        fiberGrams: parsedOptionalNumberSchema,
+        sugarGrams: parsedOptionalNumberSchema,
+        sodiumMg: parsedOptionalNumberSchema,
+        confidence: z.coerce.number().min(0).max(1).default(0.45),
+        reason: parsedStringDefaultSchema.default("")
+    }))
+        .default([]),
+    validationNotes: z.array(z.string()).default([])
+});
+function searchableFoodText(value) {
+    return (value ?? "")
+        .trim()
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function foodSearchTokens(value) {
+    return searchableFoodText(value)
+        .split(" ")
+        .filter((token) => token.length >= 3);
+}
+function foodHasRequiredMacros(food) {
+    return (hasNutritionValue(food.calories) &&
+        hasNutritionValue(food.proteinGrams) &&
+        hasNutritionValue(food.carbohydrateGrams) &&
+        hasNutritionValue(food.fatGrams));
+}
+function scoreNutritionFoodMatch(item, food) {
+    const queryText = searchableFoodText([item.searchQuery, item.brand, item.name].filter(Boolean).join(" "));
+    const foodText = searchableFoodText([food.brand, food.name].join(" "));
+    const queryTokens = foodSearchTokens(queryText);
+    if (queryTokens.length === 0 || !foodText) {
+        return 0;
+    }
+    const matchedTokens = queryTokens.filter((token) => foodText.includes(token));
+    const coverage = matchedTokens.length / queryTokens.length;
+    const exactBoost = queryText && foodText.includes(queryText)
+        ? 0.35
+        : searchableFoodText(item.name) &&
+            foodText.includes(searchableFoodText(item.name))
+            ? 0.2
+            : 0;
+    const nutritionBoost = foodHasRequiredMacros(food) ? 0.2 : -0.2;
+    return coverage + exactBoost + nutritionBoost;
+}
+const countedFoodGramEstimates = [
+    { tokens: ["almond"], gramsPerUnit: 1.2 },
+    { tokens: ["cashew"], gramsPerUnit: 1.6 },
+    { tokens: ["pistachio"], gramsPerUnit: 0.6 },
+    { tokens: ["walnut"], gramsPerUnit: 4 },
+    { tokens: ["hazelnut"], gramsPerUnit: 1.3 },
+    { tokens: ["egg"], gramsPerUnit: 50 },
+    { tokens: ["slice", "bread"], gramsPerUnit: 35 }
+];
+function estimateCountedFoodGrams(item) {
+    if (hasNutritionValue(item.grams) && item.grams > 0) {
+        return item.grams;
+    }
+    if (!hasNutritionValue(item.quantity) || item.quantity <= 0) {
+        return item.grams;
+    }
+    const unit = normalizeCustomFoodToken(item.unit);
+    const countLikeUnits = new Set([
+        "",
+        "piece",
+        "pieces",
+        "unit",
+        "units",
+        "count",
+        "counts",
+        "custom",
+        "almond",
+        "almonds",
+        "nut",
+        "nuts"
+    ]);
+    if (!countLikeUnits.has(unit)) {
+        return item.grams;
+    }
+    const text = searchableFoodText([item.name, item.searchQuery, item.brand].filter(Boolean).join(" "));
+    const estimate = countedFoodGramEstimates.find(({ tokens }) => tokens.every((token) => text.includes(token)));
+    return estimate ? round(item.quantity * estimate.gramsPerUnit, 1) : item.grams;
+}
+async function resolveParsedMealItemNutrition(item) {
+    const searchQueries = Array.from(new Set([
+        item.searchQuery,
+        [item.brand, item.name].filter(Boolean).join(" "),
+        item.name
+    ]
+        .map((query) => query.trim())
+        .filter(Boolean)));
+    const seen = new Set();
+    let match = null;
+    for (const query of searchQueries) {
+        const foods = await searchNutritionFoods({ query, limit: 1 })
+            .then((result) => result.foods)
+            .catch(() => []);
+        const candidates = foods
+            .filter((food) => {
+            if (seen.has(food.id)) {
+                return false;
+            }
+            seen.add(food.id);
+            return foodHasRequiredMacros(food);
+        })
+            .map((food) => ({
+            food,
+            score: scoreNutritionFoodMatch(item, food)
+        }))
+            .sort((left, right) => right.score - left.score);
+        match = candidates.find((candidate) => candidate.score >= 0.45) ?? null;
+        if (match) {
+            break;
+        }
+    }
+    const baseItem = {
+        name: item.name,
+        brand: item.brand || null,
+        quantity: item.quantity,
+        unit: item.unit,
+        grams: estimateCountedFoodGrams(item),
+        calories: item.calories,
+        proteinGrams: item.proteinGrams,
+        carbohydrateGrams: item.carbohydrateGrams,
+        fatGrams: item.fatGrams,
+        fiberGrams: item.fiberGrams,
+        sugarGrams: item.sugarGrams,
+        sodiumMg: item.sodiumMg,
+        tags: item.tags,
+        confidence: item.confidence,
+        nutrients: {}
+    };
+    if (match) {
+        const resolved = resolveMealItemForInsert({
+            ...baseItem,
+            foodId: match.food.id,
+            name: match.food.name,
+            brand: match.food.brand || item.brand || null,
+            tags: Array.from(new Set([
+                ...item.tags,
+                "catalog_resolved",
+                match.food.source.replaceAll("-", "_")
+            ])),
+            confidence: Math.max(item.confidence, match.food.confidence ?? 0.65),
+            nutrients: {
+                catalogResolution: {
+                    source: match.food.source,
+                    sourceId: match.food.sourceId,
+                    searchQueries,
+                    score: round(match.score, 2)
+                }
+            }
+        }, { cacheConfirmedCustomFood: false });
+        return {
+            ...resolved,
+            resolutionNote: `Resolved "${item.name}" to ${match.food.name}${match.food.brand ? ` (${match.food.brand})` : ""}.`
+        };
+    }
+    return {
+        ...baseItem,
+        tags: Array.from(new Set([...item.tags, "chatgpt_estimate"])),
+        nutrients: {
+            estimateResolution: {
+                searchQueries,
+                searchedSources: ["local_cache", "open_food_facts", "usda_fdc"],
+                matched: false
+            }
+        },
+        resolutionNote: searchQueries.length > 0
+            ? `No catalog match with complete macros for "${item.name}"; using ChatGPT estimate for review.`
+            : null
+    };
+}
+async function completeMissingParsedMealNutritionWithChatGpt(rawText, items, llm, profile) {
+    const incompleteItems = items
+        .map((item, index) => ({ item, index, missing: missingRequiredNutritionFields(item) }))
+        .filter(({ missing }) => missing.length > 0);
+    if (incompleteItems.length === 0) {
+        return { items, validationNotes: [], llmCallCount: 0 };
+    }
+    const result = await llm.runTextPrompt(profile, {
+        systemPrompt: "You are Forge's nutrition fact checker. Return strict JSON only. Use conservative, plausible nutrition values and explain uncertainty briefly.",
+        prompt: `Some parsed food-log items still lack required nutrition after Forge searched its local, Open Food Facts, and USDA-backed catalogs.
+
+Original user text:
+${rawText}
+
+Items needing complete nutrition:
+${JSON.stringify(incompleteItems.map(({ item, index, missing }) => ({
+            index,
+            name: item.name,
+            brand: item.brand,
+            quantity: item.quantity,
+            unit: item.unit,
+            grams: item.grams,
+            missing
+        })))}
+
+Return strict JSON only:
+{
+  "items": [
+    {
+      "index": 0,
+      "grams": 100,
+      "calories": 0,
+      "proteinGrams": 0,
+      "carbohydrateGrams": 0,
+      "fatGrams": 0,
+      "fiberGrams": null,
+      "sugarGrams": null,
+      "sodiumMg": null,
+      "confidence": 0.0,
+      "reason": "short source/estimate explanation"
+    }
+  ],
+  "validationNotes": []
+}
+
+Every returned item must include calories, proteinGrams, carbohydrateGrams, and fatGrams. Estimate grams for counted portions when needed.`
+    });
+    const completion = parsedMealNutritionCompletionSchema.parse(JSON.parse(extractJsonObject(result.outputText)));
+    const completedByIndex = new Map(completion.items.map((item) => [item.index, item]));
+    return {
+        items: items.map((item, index) => {
+            const completed = completedByIndex.get(index);
+            if (!completed) {
+                return item;
+            }
+            const reason = completed.reason || "ChatGPT supplied conservative nutrition values.";
+            return {
+                ...item,
+                grams: item.grams ?? completed.grams,
+                calories: item.calories ?? completed.calories,
+                proteinGrams: item.proteinGrams ?? completed.proteinGrams,
+                carbohydrateGrams: item.carbohydrateGrams ?? completed.carbohydrateGrams,
+                fatGrams: item.fatGrams ?? completed.fatGrams,
+                fiberGrams: item.fiberGrams ?? completed.fiberGrams,
+                sugarGrams: item.sugarGrams ?? completed.sugarGrams,
+                sodiumMg: item.sodiumMg ?? completed.sodiumMg,
+                confidence: Math.max(item.confidence, completed.confidence),
+                tags: Array.from(new Set([...item.tags, "chatgpt_validated"])),
+                nutrients: {
+                    ...item.nutrients,
+                    chatGptNutritionValidation: {
+                        reason,
+                        confidence: completed.confidence
+                    }
+                },
+                resolutionNote: item.resolutionNote
+                    ? `${item.resolutionNote} ${reason}`
+                    : reason
+            };
+        }),
+        validationNotes: completion.validationNotes,
+        llmCallCount: 1
+    };
+}
 export async function parseNutritionFoodLogWithChatGpt(input, llm) {
+    const parseStartedAt = Date.now();
     const parsed = nutritionParseRequestSchema.parse(input);
     const profile = getNutritionCodexProfile(parsed.connectionId);
     if (!profile) {
@@ -2218,7 +2493,9 @@ Return this JSON shape:
   "loggedAt": "ISO time if known",
   "items": [
     {
-      "name": "food name",
+      "name": "normalized food name",
+      "searchQuery": "best search query for Forge nutrition catalogs, including corrected brand/product wording when obvious",
+      "brand": "brand or product line if known",
       "quantity": 1,
       "unit": "serving|g|ml|piece|cup|tbsp|custom",
       "grams": null,
@@ -2238,31 +2515,60 @@ Return this JSON shape:
   "tags": []
 }
 
-Use null for unknown nutrients. Prefer conservative estimates and mark uncertainty.`;
+Decompose mixed meals into separate food items. Correct obvious food-brand typos in searchQuery but keep the name human-readable. When a quantity is known from the text, preserve it. For counted foods such as nuts, eggs, fruit, slices, pieces, and bars, estimate grams when possible because Forge scales catalog nutrition by grams. For packaged foods, include brand/product hints in searchQuery. Fill calories, proteinGrams, carbohydrateGrams, and fatGrams with conservative estimates when catalog lookup may fail; use null only when there is genuinely no defensible estimate. Before returning JSON, validate every item against the original text and make sure each item has either a useful searchQuery for public nutrition catalogs or complete calories/proteinGrams/carbohydrateGrams/fatGrams. Mark uncertainty.`;
     const result = await llm.runTextPrompt(profile, {
         systemPrompt: "You are Forge's nutrition parser. Return strict JSON only. Never claim precision when food quantity is unclear.",
         prompt
     });
     const parsedResult = parsedMealSchema.parse(JSON.parse(extractJsonObject(result.outputText)));
+    const initiallyResolvedItems = await Promise.all(parsedResult.items.map((item) => resolveParsedMealItemNutrition(item)));
+    const { items: resolvedItems, validationNotes, llmCallCount: nutritionCompletionLlmCallCount } = await completeMissingParsedMealNutritionWithChatGpt(parsed.text, initiallyResolvedItems, llm, profile);
+    const stillIncompleteItems = resolvedItems
+        .map((item) => ({
+        name: item.name,
+        missing: missingRequiredNutritionFields(item)
+    }))
+        .filter((item) => item.missing.length > 0);
+    if (stillIncompleteItems.length > 0) {
+        throw new Error(`ChatGPT could not verify complete nutrition for: ${stillIncompleteItems
+            .map((item) => `${item.name} (${item.missing.join(", ")})`)
+            .join("; ")}. Search the catalog or create a custom food with calories, protein, carbs, and fat before logging.`);
+    }
+    const resolutionNotes = resolvedItems
+        .map((item) => item.resolutionNote)
+        .filter((note) => Boolean(note));
+    const parseSummary = {
+        itemCount: resolvedItems.length,
+        completeNutritionItemCount: resolvedItems.filter((item) => missingRequiredNutritionFields(item).length === 0).length,
+        catalogResolvedItemCount: resolvedItems.filter((item) => item.tags.includes("catalog_resolved")).length,
+        chatGptEstimatedItemCount: resolvedItems.filter((item) => item.tags.includes("chatgpt_estimate")).length,
+        chatGptValidatedItemCount: resolvedItems.filter((item) => item.tags.includes("chatgpt_validated")).length,
+        elapsedMs: Date.now() - parseStartedAt,
+        llmCallCount: 1 + nutritionCompletionLlmCallCount
+    };
     const candidate = {
         userId,
         loggedAt: parsedResult.loggedAt ?? parsed.mealTime ?? nowIso(),
         mealLabel: parsedResult.mealLabel || "ChatGPT parsed meal",
         source: parsed.imageRefs.length > 0 ? "photo" : "chatgpt",
         confirmationState: "candidate",
-        notes: parsedResult.uncertaintyReasons.join("; "),
+        notes: [
+            ...resolutionNotes,
+            ...validationNotes,
+            ...parsedResult.uncertaintyReasons
+        ].join("; "),
         imageRefs: parsed.imageRefs,
         parserProvenance: {
             provider: "openai-codex",
             model: profile.model,
             uncertaintyReasons: parsedResult.uncertaintyReasons,
             clarificationQuestions: parsedResult.clarificationQuestions,
+            parseSummary,
             rawText: parsed.text
         },
         links: [],
-        items: parsedResult.items.map((item) => ({
+        items: resolvedItems.map(({ resolutionNote: _resolutionNote, ...item }) => ({
             ...item,
-            nutrients: {},
             tags: Array.from(new Set([...item.tags, ...parsedResult.tags]))
         }))
     };
@@ -2270,6 +2576,7 @@ Use null for unknown nutrients. Prefer conservative estimates and mark uncertain
     return {
         candidate,
         log,
+        parseSummary,
         clarificationQuestions: parsedResult.clarificationQuestions,
         uncertaintyReasons: parsedResult.uncertaintyReasons
     };

package/dist/server/server/src/managers/platform/openai-responses-provider.js

@@ -521,7 +521,7 @@ export class OpenAiResponsesProvider {
                         ? "Connection test."
                         : "Reply with the single word ok.",
                     ...(isCodexProfile(profile) ? { stream: true, store: false } : {}),
-                    max_output_tokens: 24,
+                    ...(isCodexProfile(profile) ? {} : { max_output_tokens: 24 }),
                     reasoning: buildReasoningConfiguration(profile),
                     text: buildTextConfiguration({ profile })
                 })
@@ -628,7 +628,7 @@ export class OpenAiResponsesProvider {
                 ...(isCodexProfile(profile) ? { stream: true, store: false } : {}),
                 reasoning: buildReasoningConfiguration(profile),
                 text: buildTextConfiguration({ profile }),
-                max_output_tokens: 1200
+                ...(isCodexProfile(profile) ? {} : { max_output_tokens: 1200 })
             })
         });
         if (!response.ok) {

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

@@ -6152,9 +6152,10 @@ export function buildOpenApiDocument() {
                                     additionalProperties: false,
                                     properties: {
                                         text: { type: "string" },
-                                        imageDescription: { type: "string" },
-                                        loggedAt: { type: "string", format: "date-time" },
-                                        mealLabel: { type: "string" }
+                                        mealTime: { type: "string", format: "date-time" },
+                                        imageRefs: arrayOf({ type: "string" }),
+                                        connectionId: { type: "string" },
+                                        commitCandidate: { type: "boolean" }
                                     }
                                 }
                             }
@@ -6166,6 +6167,7 @@ export function buildOpenApiDocument() {
                             required: [
                                 "candidate",
                                 "log",
+                                "parseSummary",
                                 "clarificationQuestions",
                                 "uncertaintyReasons"
                             ],
@@ -6176,6 +6178,27 @@ export function buildOpenApiDocument() {
                                 log: nullable({
                                     $ref: "#/components/schemas/NutritionFoodLog"
                                 }),
+                                parseSummary: {
+                                    type: "object",
+                                    required: [
+                                        "itemCount",
+                                        "completeNutritionItemCount",
+                                        "catalogResolvedItemCount",
+                                        "chatGptEstimatedItemCount",
+                                        "chatGptValidatedItemCount",
+                                        "elapsedMs",
+                                        "llmCallCount"
+                                    ],
+                                    properties: {
+                                        itemCount: { type: "number" },
+                                        completeNutritionItemCount: { type: "number" },
+                                        catalogResolvedItemCount: { type: "number" },
+                                        chatGptEstimatedItemCount: { type: "number" },
+                                        chatGptValidatedItemCount: { type: "number" },
+                                        elapsedMs: { type: "number" },
+                                        llmCallCount: { type: "number" }
+                                    }
+                                },
                                 clarificationQuestions: arrayOf({ type: "string" }),
                                 uncertaintyReasons: arrayOf({ type: "string" })
                             }

package/dist/server/server/src/repositories/ai-connectors.js

@@ -778,7 +778,7 @@ async function runOpenAiConversationPrompt(input) {
             text: typeof input.profile.metadata.verbosity === "string"
                 ? { verbosity: input.profile.metadata.verbosity }
                 : undefined,
-            max_output_tokens: 1200
+            ...(isCodexProfile(input.profile) ? {} : { max_output_tokens: 1200 })
         })
     });
     if (!response.ok) {

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.3.12",
+  "version": "0.3.14",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "Apache-2.0",

package/skills/forge-openclaw/SKILL.md

@@ -193,6 +193,15 @@ Wiki rule:
 - Use the wiki tools when the user wants SQLite-backed reference pages, backlink-aware recall, ingest from a URL or local file, or wiki maintenance work such as unresolved-link cleanup.
 - `forge_ingest_wiki_source` now queues the ingest as background work; use the Forge UI handoff when the user wants to review or keep only selected wiki/entity candidates after the ingest finishes.
 - Keep evidence notes and wiki pages conceptually distinct: evidence notes are linked operating records, while wiki pages are curated long-form memory.
+- Ingestion policy for OpenClaw, Hermes, Codex, and Claude Code adapters:
+  - Before ingesting, call `forge_get_wiki_settings` so the agent knows the available spaces, LLM profiles, and embedding profiles. Prefer the shared wiki space for durable shared knowledge unless the current settings or user request clearly require another space.
+  - Use `forge_ingest_wiki_source` for raw text, local files, and URLs. Do not build an ad hoc importer or write raw source pages manually unless the Forge ingest tool is broken; if it is broken, fix the ingest path and tests before proceeding.
+  - Preserve source/evidence artifacts for audit, but do not make the wiki a transcript dump, movement log, release log, or repetitive check-in archive. Evidence supports knowledge; canonical wiki pages should be curated, readable, structured articles.
+  - Detect and propose durable pages for important people, organizations, projects, places, events, concepts, recurring relationship patterns, decisions, preferences, commitments, and timelines. A detected person or important concept should become or update a real wiki page, not disappear into one source note.
+  - Merge duplicates deliberately into one canonical page per real concept/person/project. Do not merely rename a page, hide a duplicate, or keep competing partial pages. Combine the durable information, preserve aliases and backlinks, and link the original evidence/source pages from the canonical page.
+  - Keep normal personal context when it is useful knowledge. Redact or omit actual secrets and security/payment credentials such as passwords, API keys, tokens, private auth links, card numbers, and similar material; do not over-redact ordinary names, relationships, work context, events, or preferences just because they are personal.
+  - After ingest or merge work, run `forge_sync_wiki_vault`, then use `forge_get_wiki_health`, search/list checks, and spot reads to verify created and updated pages, duplicate candidates, unresolved links, missing summaries, evidence links, and whether source material is reachable from canonical pages.
+  - Report what was created, updated, merged, left unresolved, and how evidence is preserved. If the user asked for reviewable candidates, hand off to the Forge UI ingest review instead of pretending the adapter can approve candidates inline.
 
 Wiki navigation and search rule:
 
@@ -263,6 +272,10 @@ Entity conversation rule:
 - Do not ask for optional tags, priority, status, dates, color, links, or assignees
   when accepted wording and meaningful body are enough unless that metadata changes
   accountability, retrieval, or execution.
+- After a read returns data and several next actions are plausible, choose the one
+  most directly supported by what was learned and ask only for the missing detail
+  that would permit that action. Do not hand the user a broad menu after the read has
+  already narrowed the work.
 - Let each question have one job. Know what you are trying to clarify before you ask it.
 - Before you ask, decide the exact missing thing you need and how that answer will help you name, place, or save the record.
 - Prefer a progression of:
@@ -335,6 +348,9 @@ Psyche interview rule:
 - Phrase interpretive hypotheses as collaborative and testable, not as verdicts. A good hypothesis says what the reaction may be protecting, predicting, relieving, or costing, then asks whether that lands or needs correction.
 - For Psyche hypotheses, reduce the formulation burden. After one concrete example, offer one tentative function, danger, protection, payoff, or cost hypothesis and ask one fit-or-correction question. Do not make the user prove the experience, list evidence, or design repair before the wording feels held.
 - Do not keep asking broad exploratory Psyche questions after the cue, meaning, protection, payoff, or cost is already visible. For `behavior_pattern`, `belief_entry`, `mode_profile`, `mode_guide_session`, and `trigger_report`, the next helpful move is usually one active formulation plus one correction question, not another passive reflection.
+- Do not leave the user with interpretation alone. Once the hypothesis lands or is
+  corrected, name the primary Forge record it becomes and ask one accuracy or consent
+  question that moves toward saving the corrected formulation.
 - Use the hypothesis timing checkpoint before asking a second or third deepening question: offer a hypothesis when one concrete episode, body cue, belief sentence, behavior, or mode voice is visible and the hypothesis would change the record shape, wording, links, or next action. Do not hypothesize yet when no concrete moment is visible, the user only wants a direct mechanical save, the user is flooded or unsafe, or the only available interpretation would be diagnosis-like, an origin story, or a certainty claim.
 - If several Psyche containers are plausible, do not ask the user to choose from a taxonomy menu first. Reflect the lived difference, offer one careful hypothesis when a concrete example is visible, then distinguish the options in plain language: one episode as a `trigger_report`, a recurring loop as a `behavior_pattern`, one repeated move as `behavior`, one sentence as `belief_entry`, a part-state as `mode_profile` or `mode_guide_session`, or reusable future-labeling as `event_type` or `emotion_definition`.
 - For Psyche updates, start with what feels newly true, newly visible, or newly inaccurate, then ask what should stay true before changing the formulation.
@@ -660,6 +676,12 @@ through `forge_create_entities` or `forge_update_entities`.
 - If you are unsure which specialized route family applies, check `forge_get_agent_onboarding` and use its `entityRouteModel.specializedDomainSurfaces` section before guessing.
 - If the truth of the current Movement, Life Force, or Workbench state is still unclear, prefer the dedicated read before the mutation so the correction stays truthful.
 - After a concrete Movement, Life Force, or Workbench correction, mutation, or result-producing run, read the relevant specialized view back when the user is trying to understand the result rather than only store it: timeline or place/settings detail for Movement, the Life Force overview for energy-planning impact, and flow detail, run detail, node result, latest node output, published output, or run history for Workbench.
+- After any dedicated Movement, Life Force, or Workbench read, translate the result
+  into one next action: no change, Movement overlay/place/settings/link, Life Force
+  workload/recovery/timebox/meeting/task-choice change, or Workbench
+  rerun/node-inspection/flow-edit/publish/preserve/stop. Ask only for the missing
+  span, place, weekday, flow, run, node, output, correction, preservation choice, or
+  confirmation that would change that action.
 
 Use live work tools for `task_run`:
 `forge_log_work`, `forge_start_task_run`, `forge_heartbeat_task_run`, `forge_focus_task_run`, `forge_complete_task_run`, `forge_release_task_run`

package/skills/forge-openclaw/entity_conversation_playbooks.md

@@ -222,6 +222,10 @@ worked.
 - Ask a follow-up only if it changes the next action: save, update, correct, link,
   schedule, run, publish, enrich, or open the UI. If the read already answers the
   question, close cleanly instead of asking a ceremonial "what next?"
+- If the read produces several possible actions, choose the one that most directly
+  answers the user's practical question and ask only for the missing detail that would
+  permit that action. Do not hand the user a broad menu after you just learned enough
+  to narrow the next move.
 - For Movement, Life Force, Workbench, calendar, health, and operator overviews,
   keep the follow-up anchored to the read result: the span that is missing, the
   weekday curve that needs correction, the failed run or node, the overloaded day, or
@@ -2023,6 +2027,10 @@ Direct action rules:
   object.
 - If the user is asking where they were during one uncertain window, prefer a timeline
   read before you create a correction. Mutate only after the lived truth is clear.
+- After a Movement read, translate the returned data into one next action: no change,
+  a manual overlay, a place boundary correction, a settings change, or a linked note.
+  Ask only for the missing span, place, boundary, or confirmation that enables that
+  action.
 - When the user has already given the real answer, for example "I stayed home during
   that missing block", do not ask a broad review question again. Confirm only the
   interval or place if that is still ambiguous, then act.
@@ -2167,6 +2175,10 @@ Direct action rules:
 - After a fatigue signal, profile patch, or weekday-template edit, verify through the
   Life Force overview when the next planning decision depends on the updated energy
   picture.
+- After a Life Force overview, translate the read into one planning implication before
+  asking for a write: lighter workload, added recovery, protected timebox, meeting
+  change, task-choice change, or no change. Ask for a profile, template, or signal
+  detail only when that implication requires a mutation.
 
 Ready to act when:
 
@@ -2273,6 +2285,11 @@ Direct action rules:
 - If the user wants to understand what inputs a flow can accept before editing or
   running it, read the box catalog or flow detail before asking for structured
   input details.
+- After a Workbench read, translate the returned artifact into one next action:
+  rerun with clearer input, inspect a specific node, edit the saved flow, publish or
+  preserve the output, or stop because the answer is already sufficient. Ask only for
+  the missing input, node, run, preservation choice, or confirmation that would change
+  that action.
 - For new flows, ask what the flow should reliably produce, what input contract it
   should accept, and what first node or box should anchor it. Do not start by asking
   for raw JSON.

package/skills/forge-openclaw/psyche_entity_playbooks.md

@@ -297,6 +297,9 @@ of leaving it as warm reflective prose.
   that.
 - Save through shared batch entity routes only after the user accepts the working
   wording or explicitly asks to save.
+- Do not leave the user with interpretation alone. Once the hypothesis lands or is
+  corrected, name the primary Forge record it becomes and ask one accuracy or consent
+  question that moves toward that save.
 
 ## Psyche progressive disclosure
 
@@ -317,6 +320,10 @@ should preserve momentum instead of making them retell the whole story.
   unclear.
 - If the working material is already accurate enough, ask one accuracy or consent
   question instead of reopening origin, evidence, or repair.
+- If the user accepts or corrects a hypothesis, immediately turn the corrected
+  interpretation into the nearest saveable shape: belief sentence, functional loop,
+  part voice, trigger chain, value phrase, event kind, emotion signature, or
+  flashcard message.
 - If the remaining unknown is optional therapeutic metadata, save a provisional
   version after one accuracy check and preserve nuance in a linked note when needed.