npm - ofiere-openclaw-plugin - Versions diffs - 4.31.0 → 4.33.0 - Mend

ofiere-openclaw-plugin 4.31.0 → 4.33.0

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 (4) hide show

package/index.ts CHANGED Viewed

@@ -61,10 +61,21 @@ const ofierePlugin = {
       ready: false,
     };
-    // ── Hook: inject Ofiere context into every agent prompt ────────────────
-    // Using api.on() — same pattern as Composio
+    // ── System prompt is built ONCE (it's static after init) ──────────────
+    // No hook needed here — the brain context hook in tools.ts uses
+    // prependSystemContext via getSystemPromptCached() to combine both
+    // in a single hook invocation, eliminating one serial hook call.
+    let cachedSystemPrompt = "";
+    const getSystemPromptCached = () => {
+      if (!cachedSystemPrompt) {
+        cachedSystemPrompt = getSystemPrompt(promptState);
+      }
+      return cachedSystemPrompt;
+    };
+    // Hook: inject BOTH system prompt + brain context in one call
     api.on("before_prompt_build", () => ({
-      prependSystemContext: getSystemPrompt(promptState),
+      prependSystemContext: getSystemPromptCached(),
     }));
     // ── Connect to Supabase and register tools ────────────────────────────

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.31.0",
+  "version": "4.33.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 14 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, and agent brain (memory + self-improvement)",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/prompt.ts CHANGED Viewed

@@ -1,172 +1,118 @@
 // src/prompt.ts — Dynamic system prompt for Ofiere PM plugin
 //
-// The prompt is built dynamically based on plugin state.
-// Tool documentation is structured so adding a new meta-tool
-// only requires adding a new entry to TOOL_DOCS below.
-// ─── Tool Documentation Registry ────────────────────────────────────────────
-// Add new meta-tool docs here when expanding. Each entry maps to one
-// registered meta-tool and will be included in the system prompt.
-const TOOL_DOCS: Record<string, string> = {
-  OFIERE_TASK_OPS: `- **OFIERE_TASK_OPS** — Manage tasks and approvals (action: "list", "create", "update", "delete", "add_approval", "list_approvals", "resolve_approval")
-    - list: Filter by status, agent_id, space_id, folder_id, limit. Returns execution_plan, goals, constraints if present
-    - create: Requires title. IMPORTANT: Always pass agent_id with your own name to self-assign (e.g. agent_id: "celia")
-      - Optional: description, instructions, execution_plan, goals, constraints, system_prompt, priority, tags, dates
-      - For COMPLEX tasks: include execution_plan (step-by-step), goals, constraints, and system_prompt
-      - For SIMPLE tasks: just title and optionally description
-    - update: Requires task_id. All create fields + progress
-    - delete: Requires task_id. Removes task and subtasks
-    - add_approval: Request sign-off on a task. Requires: task_id, approver_name. Optional: approver_type (human|agent, auto-detected), due_date, comment
-    - list_approvals: List approvals. Optional: task_id to filter, approval_status (pending|approved|rejected)
-    - resolve_approval: Approve or reject. Requires: approval_id, approval_status (approved|rejected). Optional: comment`,
-  OFIERE_AGENT_OPS: `- **OFIERE_AGENT_OPS** — Query agents (action: "list")
-    - list: See all agents with IDs, names, roles for task assignment`,
-  OFIERE_PROJECT_OPS: `- **OFIERE_PROJECT_OPS** — Manage PM hierarchy (action: "list_spaces", "create_space", "update_space", "delete_space", "list_folders", "create_folder", "update_folder", "delete_folder", "list_dependencies", "add_dependency", "remove_dependency")
-    - Spaces: Top-level containers. CRUD with name, icon, icon_color
-    - Folders: Live inside spaces. Can nest via parent_folder_id. Types: folder, project
-    - Dependencies: Link tasks with predecessor/successor relationships
-      - Types: finish_to_start (default), start_to_start, finish_to_finish, start_to_finish
-      - lag_days: optional delay between linked tasks`,
-  OFIERE_SCHEDULE_OPS: `- **OFIERE_SCHEDULE_OPS** — Calendar events (action: "list", "create", "update", "delete")
-    - list: Filter by start_date, end_date, agent_id
-    - create: Requires title + scheduled_date (YYYY-MM-DD). Optional: scheduled_time, duration_minutes, task_id, agent_id, recurrence_type, color
-    - Recurrence: none, hourly, daily, weekly, monthly with interval`,
-  OFIERE_KNOWLEDGE_OPS: `- **OFIERE_KNOWLEDGE_OPS** — Ofiere Knowledge Library (action: "search", "list", "create", "update", "delete")
-    - ALWAYS use this tool when the user mentions "knowledge base", "knowledge library", "knowledge entries", or asks to recall/retrieve stored knowledge
-    - search: Keyword search across all stored documents. Requires: query
-    - list: Paginated listing of knowledge entries with full content. Optional: search filter
-    - create: Add knowledge to the library. Requires: file_name. Optional: content, source, author, credibility_tier
-    - update/delete: By document ID`,
-  OFIERE_WORKFLOW_OPS: `- **OFIERE_WORKFLOW_OPS** — Full workflow automation control (13 actions)
-    - list: All workflows, filter by status (draft, active, paused, archived)
-    - get: Full workflow details with all node IDs, types, data, edges — ALWAYS call this before surgical edits
-    - create: New workflow with name + nodes[] and edges[]. A manual_trigger is auto-prepended if missing
-    - update: Replace entire workflow graph (name, description, status, nodes, edges)
-    - delete: Remove workflow and all run history
-    - list_runs: Recent execution history for a workflow
-    - trigger: Start a workflow run
-    - **add_nodes**: Add new nodes to an existing workflow. Required: workflow_id, nodes[]. Optional: edges[] to connect them
-    - **update_node**: Edit a specific node's data fields (e.g. change task instructions, agentId, template). Required: workflow_id, node_id, data. Only specified fields are changed — others are preserved
-    - **delete_nodes**: Remove specific nodes and all their connected edges. Required: workflow_id, node_ids[]
-    - **add_edges**: Add new connections between existing nodes. Required: workflow_id, edges[]. Each edge: { source, target, sourceHandle?, targetHandle? }
-    - **delete_edges**: Remove specific edges by ID. Required: workflow_id, edge_ids[]
-    - **insert_node_between**: Insert a new node between two connected nodes (auto-rewires edges). Required: workflow_id, source_node_id, target_node_id, node. Use this to add steps in the middle of a flow
-    - Node types: manual_trigger, webhook_trigger, agent_step, formatter_step, http_request, task_call, variable_set, condition, human_approval, delay, loop, convergence, output, checkpoint, note
-    - Key fields: agent_step(agentId, task, responseMode, timeoutSec), formatter_step(template, formatMode), condition(expression, varCheck, operator, varMatch), human_approval(instructions), variable_set(variableName, variableValue, operation)
-    - Edge handles: condition edges use sourceHandle "condition-true"/"condition-false". Loop edges use "loop_body"/"done"
-    - Variables: Use {{prev.nodeId.outputText}} for prior outputs, {{variables.key}} for stored variables`,
-  OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications & Channel Reports (action: "list", "mark_read", "mark_all_read", "delete", "send_report", "get_task_detail", "schedule_report", "list_schedules", "delete_schedule")
-    - list: Recent notifications. unread_only=true for unread only
-    - mark_read: Mark one notification read by ID
-    - mark_all_read: Mark all as read
-    - send_report: Send a numbered PM progress report to YOUR connected channels (Telegram, Discord, Slack, etc.)
-      - Required: scope_type (space|folder|project|task|all), agent_id (YOUR name, e.g. "thalia")
-      - Optional: scope_id, channel_types[] (filter to specific channels), include_completed
-      - The report is automatically generated from current PM data and sent through YOUR channel bindings ONLY
-      - Tasks are numbered globally (1, 2, 3...) across Active/Pending/Done sections. Recurring tasks that executed recently appear in BOTH Done (today's run) and Pending (next cycle)
-    - get_task_detail: Get the FULL result/content of a task by its report number
-      - Required: task_number (1-indexed number from the report)
-      - Optional: scope_type (default all), scope_id
-      - Returns: complete task description (where execution results live), custom_fields, status, tags, and all metadata
-      - Use when user asks "details on number X", "what's task 2 result", "show me #3", etc.
-    - schedule_report: Create a recurring/scheduled report
-      - Required: scope_type, recurrence_type (hourly|daily|weekly|monthly), agent_id (YOUR name)
-      - Optional: scope_id, scope_label, channel_types[], recurrence_time (HH:MM UTC, default 09:00), recurrence_interval, recurrence_days_of_week (e.g. "mon,wed,fri"), include_completed
-    - list_schedules: View all your active report schedules
-    - delete_schedule: Remove a scheduled report by schedule_id`,
-  OFIERE_MEMORY_OPS: `- **OFIERE_MEMORY_OPS** — Conversation history & knowledge memory (action: "list_conversations", "get_messages", "search_messages", "add_knowledge", "search_knowledge")
-    - list_conversations: Recent chats, filter by agent_id
-    - get_messages: Full message history for a conversation
-    - search_messages: Search across all messages by keyword
-    - add_knowledge: Store a knowledge fragment (requires agent_id, content, source)
-    - search_knowledge: Search stored knowledge for an agent`,
-  OFIERE_PROMPT_OPS: `- **OFIERE_PROMPT_OPS** — Manage prompt instruction chunks (action: "list", "get", "create", "update", "delete")
-    - list: All prompt chunks ordered by display order
-    - create: New chunk with name (max 30 chars) + content. Optional: color (hex), category
-    - update: Change name, content, color, category, or order
-    - delete: Remove a chunk by ID
-    - All modifications are logged for audit`,
-  OFIERE_CONSTELLATION_OPS: `- **OFIERE_CONSTELLATION_OPS** — Create, edit, delete, and manage OpenClaw agent architectures from chat (action: "list_agents", "get_agent", "read_file", "write_file", "create_agent", "delete_agent", "delete_file", "read_blueprint", "list_agent_mesh")
-    - CRITICAL: Before creating or editing any agent, ALWAYS call read_blueprint first
-    - list_agents: See all agents with codename, role, and file list
-    - get_agent: Full details for one agent including file sizes and identity
-    - read_file / write_file: Read or overwrite any agent markdown file (IDENTITY.md, SOUL.md, AGENTS.md, TOOLS.md, etc.)
-    - create_agent: Scaffold a new agent with structured params (name, codename, role, emoji, mission, personality, etc.). Auto-registers in OpenClaw
-    - delete_agent: ⚠️ PERMANENTLY delete an entire agent workspace and unregister. Requires confirm: true. ALWAYS ask user for explicit confirmation first — this is IRREVERSIBLE
-    - delete_file: Remove a specific file from an agent workspace
-    - read_blueprint: Read the OpenClaw Agent Blueprint — the canonical structure reference
-    - list_agent_mesh: See the sovereignty map (which agent owns what domain)
-    - New agents get workspace-<name>/ with IDENTITY.md, SOUL.md, AGENTS.md, TOOLS.md, <CODENAME>.md, and skills/
-    - All changes sync to the Constellation dashboard automatically`,
-  OFIERE_FILE_OPS: `- **OFIERE_FILE_OPS** — Manage Space Files (action: "list_files", "list_folders", "create_folder", "create_text_file", "upload_file", "read_text_file", "rename_file", "rename_folder", "move_file", "move_folder", "delete_file", "delete_folder", "share_file", "unshare_file")
-    - list_files: Files in a space. Required: space_id. Optional: folder_id, shared_only
-    - list_folders: Folders in a space. Required: space_id. Optional: parent_folder_id
-    - create_folder: New folder. Required: space_id, name. Optional: parent_folder_id
-    - create_text_file: Create text file (md, txt, json, csv, etc.). Required: space_id, file_name, content. Optional: folder_id
-    - upload_file: Upload binary (base64). Required: space_id, file_name, content_base64. Optional: folder_id, file_type
-    - read_text_file: Read file content. Required: file_id. Use when task instructions reference a file with @[name](file:ID)
-    - rename_file / rename_folder: Rename. Required: file_id/folder_id + new_name
-    - move_file / move_folder: Move to target folder (null=root). Required: file_id/folder_id
-    - delete_file: Remove file + storage. Required: file_id
-    - delete_folder: Remove folder + all nested files recursively. Required: folder_id
-    - share_file / unshare_file: Toggle shared status. Required: file_id
-    - Files created here appear in the PM Space Files tab immediately`,
-  OFIERE_PLAN_OPS: `- **OFIERE_PLAN_OPS** — Visual execution plan builder (action: "list", "get", "create", "update", "delete", "add_nodes", "execute")
-    - list: All saved plans. Optional: space_id filter
-    - get: Full plan with complete node tree. Required: plan_id
-    - create: New plan. Required: name. Optional: description, space_id, nodes[] (initial tree)
-    - update: Modify plan. Required: plan_id. Optional: name, description, nodes[] (full tree replace)
-    - delete: Remove plan. Required: plan_id
-    - add_nodes: Add nodes to existing plan. Required: plan_id, nodes[]. Optional: parent_node_id (null = add as root)
-    - execute: Deploy plan into real PM tasks/folders/dependencies. Required: plan_id. Optional: create_folder (default true), create_scheduler (default true), space_id, folder_id
-    - Node types: task, gate, milestone
-    - Node fields: type, title, description, agent_id, priority (0-3), status (PENDING/IN_PROGRESS/DONE/FAILED), start_date, due_date, tags[], execution_steps[{text}], goals[{label, type?}], constraints[{label, type?}], system_prompt, children[], parallel (boolean)
-    - Plans are visual DAG drafts — they don't become real tasks until you call "execute"
-    - Execution maps ALL node fields into real tasks: execution_steps → custom_fields.execution_plan, goals → custom_fields.goals, constraints → custom_fields.constraints, system_prompt → custom_fields.system_prompt
-    - The user can see and edit your plans in the Planning Tab of the dashboard in real-time`,
-  OFIERE_SOP_OPS: `- **OFIERE_SOP_OPS** — Standard Operating Procedures for department chiefs (action: "list_templates", "create", "list", "get", "update", "delete", "list_subagents", "apply_template")
-    - list_templates: See available SOP templates (built-in + user-created)
-    - create: Create a new SOP. Required: agent_id, title, sop_data. Optional: department, status
-    - list: List SOPs. Optional: agent_id to filter by department chief. RUNTIME READ PATH: use this to discover your active SOPs when complexity is 🔴 COMPLEX
-    - get: Full SOP details with structured content. Required: sop_id. RUNTIME READ PATH: use this after "list" to load full SOP content for execution guidance
-    - update: Modify SOP content/status. Required: sop_id. Optional: title, sop_data, status, department
-    - delete: Remove an SOP. Required: sop_id
-    - list_subagents: View staff under a chief. Required: chief_agent_id
-    - apply_template: Create SOP from a saved template. Required: agent_id, template_id
-    - sop_data is a JSON object: { title, objective, scope, prerequisites[{text,checked}], steps[{name,action,owner,output}], deliverables[], escalationRules[{trigger,escalateTo,priority}], successCriteria[{text,checked}], notes }
-    - Status values: draft, active, archived
-    - SOPs appear in the SOP Manager page immediately via real-time sync
-    - ADAPTIVE PROTOCOL: Do NOT always load SOPs. See the SOP PROTOCOL section in Rules for when to load vs skip`,
-  OFIERE_BRAIN_OPS: `- **OFIERE_BRAIN_OPS** — Agent memory, knowledge graph, and self-improvement (TMT/MAGMA architecture)
-    - Memory Tiers: L1_focus (24h), L2_episode (days-weeks), L3_pattern (weeks-months), L4_rule (permanent guardrails), L5_persona (permanent identity)
-    - save_memory: Store a memory. Required: content, tier. Optional: agent_id, source (auto|manual|reflection|tool), context_key, importance (1-10)
-    - recall: Full-text search memories. Required: query. Optional: agent_id, tier, limit
-    - delete_memory: Remove a memory. Required: memory_id
-    - promote_memory: Move memory up a tier. Required: memory_id, new_tier
-    - log_learning: Record as L4_rule guardrail. Required: title, category. Optional: agent_id, detail, severity
-    - list_learnings: View active L4 guardrails. Optional: agent_id, category, limit
-    - resolve_learning: Supersede a guardrail. Required: memory_id. Optional: resolution
-    - save_entity: Add to Knowledge Graph. Required: label, node_type (entity|concept|event|action). Optional: agent_id, properties
-    - link_entities: Connect graph nodes. Required: source_id, target_id, relation_type. Optional: graph_type, weight, evidence
-    - query_graph: Search Knowledge Graph. Required: query. Optional: agent_id, node_type, limit
-    - start_trajectory: Begin recording execution trace. Optional: agent_id, conversation_id
-    - end_trajectory: Close trajectory. Required: trajectory_id, outcome (success|failure|partial). Optional: satisfaction_signal
-    - get_brain_status: Full brain dashboard — memory tiers, graph stats, trajectory stats. Optional: agent_id
-    - This is your SUBCONSCIOUS — use it instinctively, not deliberately`,
+// v4.31.0: Tiered prompt loading strategy.
+// Tier A (always loaded): Core rules + 1-line tool summaries (~2K tokens)
+// Tier B (embedded docs): Full tool docs injected on-demand via meta-tool descriptions
+//
+// This cuts system prompt from ~12K → ~3K tokens, reducing TTFT by 40-60%.
+// ─── Tier A: One-Line Tool Summaries ────────────────────────────────────────
+// Each tool gets a concise one-liner. Full docs live in the tool's own
+// description field (registered in tools.ts) where the LLM reads them
+// only when it decides to use that tool.
+const TOOL_SUMMARIES: Record<string, string> = {
+  OFIERE_TASK_OPS: "Manage tasks: list, create, update, delete, approvals",
+  OFIERE_AGENT_OPS: "Query agents: list all with IDs, names, roles",
+  OFIERE_PROJECT_OPS: "PM hierarchy: spaces, folders, dependencies",
+  OFIERE_SCHEDULE_OPS: "Calendar: list, create, update, delete events",
+  OFIERE_KNOWLEDGE_OPS: "Knowledge library: search, list, create, update, delete",
+  OFIERE_WORKFLOW_OPS: "Workflow automation: 13 actions for DAG-based flows",
+  OFIERE_NOTIFY_OPS: "Notifications & channel reports (Telegram/Discord/Slack/WhatsApp)",
+  OFIERE_MEMORY_OPS: "Conversation history & knowledge memory search",
+  OFIERE_PROMPT_OPS: "Manage prompt instruction chunks (CRUD + ordering)",
+  OFIERE_CONSTELLATION_OPS: "Create/edit/delete OpenClaw agents from chat",
+  OFIERE_FILE_OPS: "Space files: upload, read, move, share, delete",
+  OFIERE_PLAN_OPS: "Visual execution plan builder (DAG drafts → real tasks)",
+  OFIERE_SOP_OPS: "Standard Operating Procedures for department chiefs",
+  OFIERE_BRAIN_OPS: "Agent memory, knowledge graph, self-improvement (TMT/MAGMA)",
+};
+// ─── Tier B: Full Tool Documentation ────────────────────────────────────────
+// These are used as tool descriptions in registerTools(), NOT in the system prompt.
+// The LLM sees them only when exploring available tools or preparing a tool call.
+export const TOOL_DOCS: Record<string, string> = {
+  OFIERE_TASK_OPS: `Manage tasks and approvals.
+Actions: "list", "create", "update", "delete", "add_approval", "list_approvals", "resolve_approval"
+- list: Filter by status, agent_id, space_id, folder_id, limit. Returns execution_plan, goals, constraints if present
+- create: Requires title. IMPORTANT: Always pass agent_id with your own name to self-assign (e.g. agent_id: "celia")
+  - Optional: description, instructions, execution_plan, goals, constraints, system_prompt, priority, tags, dates
+  - For COMPLEX tasks: include execution_plan (step-by-step), goals, constraints, and system_prompt
+  - For SIMPLE tasks: just title and optionally description
+- update: Requires task_id. All create fields + progress
+- delete: Requires task_id. Removes task and subtasks
+- add_approval: Request sign-off. Requires: task_id, approver_name. Optional: approver_type (human|agent), due_date, comment
+- list_approvals: List approvals. Optional: task_id, approval_status (pending|approved|rejected)
+- resolve_approval: Approve/reject. Requires: approval_id, approval_status. Optional: comment`,
+  OFIERE_AGENT_OPS: `Query agents. Action: "list" — see all agents with IDs, names, roles for task assignment.`,
+  OFIERE_PROJECT_OPS: `Manage PM hierarchy.
+Actions: "list_spaces", "create_space", "update_space", "delete_space", "list_folders", "create_folder", "update_folder", "delete_folder", "list_dependencies", "add_dependency", "remove_dependency"
+- Spaces: Top-level containers. CRUD with name, icon, icon_color
+- Folders: Inside spaces. Nest via parent_folder_id. Types: folder, project
+- Dependencies: Link tasks. Types: finish_to_start (default), start_to_start, finish_to_finish, start_to_finish. lag_days optional`,
+  OFIERE_SCHEDULE_OPS: `Calendar events.
+Actions: "list", "create", "update", "delete"
+- list: Filter by start_date, end_date, agent_id
+- create: Requires title + scheduled_date (YYYY-MM-DD). Optional: scheduled_time, duration_minutes, task_id, agent_id, recurrence_type, color
+- Recurrence: none, hourly, daily, weekly, monthly with interval`,
+  OFIERE_KNOWLEDGE_OPS: `Ofiere Knowledge Library.
+Actions: "search", "list", "create", "update", "delete"
+- ALWAYS use when user mentions "knowledge base", "knowledge library", or asks to recall stored knowledge
+- search: Keyword search. Requires: query
+- list: Paginated listing with full content. Optional: search filter
+- create: Requires: file_name. Optional: content, source, author, credibility_tier
+- update/delete: By document ID`,
+  OFIERE_WORKFLOW_OPS: `Full workflow automation (13 actions).
+Actions: "list", "get", "create", "update", "delete", "list_runs", "trigger", "add_nodes", "update_node", "delete_nodes", "add_edges", "delete_edges", "insert_node_between"
+- ALWAYS call "get" before modifying to see node IDs and graph structure
+- Node types: manual_trigger, webhook_trigger, agent_step, formatter_step, http_request, task_call, variable_set, condition, human_approval, delay, loop, convergence, output, checkpoint, note
+- Edge handles: condition edges use "condition-true"/"condition-false". Loop edges use "loop_body"/"done"
+- Variables: {{prev.nodeId.outputText}}, {{variables.key}}`,
+  OFIERE_NOTIFY_OPS: `Notifications & Channel Reports.
+Actions: "list", "mark_read", "mark_all_read", "delete", "send_report", "get_task_detail", "schedule_report", "list_schedules", "delete_schedule"
+- send_report: Send PM progress report to YOUR channels. Required: scope_type, agent_id (YOUR name)
+- get_task_detail: Get full task result by report number. Required: task_number
+- schedule_report: Recurring reports. Required: scope_type, recurrence_type, agent_id`,
+  OFIERE_MEMORY_OPS: `Conversation history & knowledge memory.
+Actions: "list_conversations", "get_messages", "search_messages", "add_knowledge", "search_knowledge"`,
+  OFIERE_PROMPT_OPS: `Manage prompt instruction chunks.
+Actions: "list", "get", "create", "update", "delete"
+- create: New chunk with name (max 30 chars) + content. Optional: color (hex), category`,
+  OFIERE_CONSTELLATION_OPS: `Create/edit/delete OpenClaw agents from chat.
+Actions: "list_agents", "get_agent", "read_file", "write_file", "create_agent", "delete_agent", "delete_file", "read_blueprint", "list_agent_mesh"
+- CRITICAL: ALWAYS call read_blueprint before creating/editing agents
+- delete_agent: IRREVERSIBLE. Always ask user for explicit confirmation first`,
+  OFIERE_FILE_OPS: `Manage Space Files.
+Actions: "list_files", "list_folders", "create_folder", "create_text_file", "upload_file", "read_text_file", "rename_file", "rename_folder", "move_file", "move_folder", "delete_file", "delete_folder", "share_file", "unshare_file"
+- read_text_file: Use when task references @[name](file:ID)
+- Files appear in PM Space Files tab immediately`,
+  OFIERE_PLAN_OPS: `Visual execution plan builder.
+Actions: "list", "get", "create", "update", "delete", "add_nodes", "execute"
+- Plans are visual DAG drafts — not real tasks until "execute"
+- Node types: task, gate, milestone
+- Execution maps ALL fields: execution_steps, goals, constraints, system_prompt`,
+  OFIERE_SOP_OPS: `Standard Operating Procedures for department chiefs.
+Actions: "list_templates", "create", "list", "get", "update", "delete", "list_subagents", "apply_template"
+- sop_data: { title, objective, scope, prerequisites[], steps[], deliverables[], escalationRules[], successCriteria[], notes }
+- See SOP PROTOCOL section for when to load vs skip`,
+  OFIERE_BRAIN_OPS: `Agent memory, knowledge graph, self-improvement (TMT/MAGMA).
+Memory Tiers: L1_focus (24h), L2_episode (days), L3_pattern (weeks), L4_rule (permanent), L5_persona (permanent)
+Actions: save_memory, recall, delete_memory, promote_memory, log_learning, list_learnings, resolve_learning, save_entity, link_entities, query_graph, start_trajectory, end_trajectory, get_brain_status
+- This is your SUBCONSCIOUS — use instinctively, not deliberately`,
 };
 export function getSystemPrompt(state: {
@@ -184,8 +130,10 @@ export function getSystemPrompt(state: {
       ? `When you create a task without specifying agent_id, it is assigned to YOU (${state.agentId}).`
       : `When you create a task without specifying agent_id, it is assigned to YOU automatically.`;
-    // Build tool docs from registry — only include docs for tools that exist
-    const toolDocs = Object.values(TOOL_DOCS).join("\n");
+    // Tier A: Compact tool index (~300 tokens vs ~3000 for full docs)
+    const toolIndex = Object.entries(TOOL_SUMMARIES)
+      .map(([name, desc]) => `- **${name}** — ${desc}`)
+      .join("\n");
     return `<ofiere-pm>
 You are connected to the Ofiere Project Management dashboard via the Ofiere PM plugin.
@@ -194,142 +142,42 @@ ${agentLine}
 ## Your Ofiere PM Tools (${state.toolCount} meta-tools)
 Each tool uses an "action" parameter to select the operation. Always include action.
+Full parameter docs are in each tool's description — call the tool to see details.
-${toolDocs}
+${toolIndex}
 ## Rules
-- ALWAYS pass agent_id with your own name when creating tasks (e.g. agent_id: "ivy"). Auto-detection is NOT reliable.
+- ALWAYS pass agent_id with your own name when creating tasks (e.g. agent_id: "ivy").
 - ${assignRule}
 - To create an unassigned task, pass agent_id as "none" or "unassigned".
-- When the user says "create a task for [agent name]", use OFIERE_AGENT_OPS action:"list" to find the agent ID, then use OFIERE_TASK_OPS action:"create" with that agent_id.
-- Always confirm task creation/updates by reporting back what was done.
-- Task statuses: PENDING, IN_PROGRESS, DONE, FAILED.
-- Priority levels: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL.
-- Changes appear in the Ofiere dashboard immediately via real-time sync.
-- Do NOT fabricate task IDs — use OFIERE_TASK_OPS action:"list" to look up real IDs.
-- For complex tasks, ALWAYS include execution_plan, goals, and constraints. For simple tasks, just title is enough.
-- When creating dependencies, use OFIERE_PROJECT_OPS to link predecessor/successor tasks.
-- Prompt chunk modifications (OFIERE_PROMPT_OPS) are powerful — use thoughtfully as they change agent behavior.
-- When the user asks about "knowledge base", "knowledge library", "knowledge entries", or wants to recall stored knowledge, ALWAYS use OFIERE_KNOWLEDGE_OPS — do NOT rely on your own memory for this.
-- When creating or editing an agent's architecture, ALWAYS use OFIERE_CONSTELLATION_OPS action:"read_blueprint" first to understand the required structure.
-- When creating a new agent, use OFIERE_CONSTELLATION_OPS action:"create_agent" with all available structured params. The agent will be auto-registered in OpenClaw.
-- When deleting an agent, ALWAYS ask the user for explicit confirmation BEFORE calling OFIERE_CONSTELLATION_OPS action:"delete_agent" with confirm: true. Show them what will be deleted. This action is IRREVERSIBLE.
-- WORKFLOW MASTERY: When modifying existing workflows, ALWAYS call "get" first to see all node IDs and the current graph structure.
-- To add a step in the middle of a flow, use "insert_node_between" with the source and target node IDs. Do NOT rebuild the entire graph.
-- To change a node's configuration (e.g. update agent instructions, change template text), use "update_node" with just the fields that changed.
-- When creating workflows with condition or loop nodes, specify sourceHandle on edges: "condition-true"/"condition-false" for conditions, "loop_body"/"done" for loops.
-- Fill node data fields with actual content — include real task instructions, templates, and variable references. Do NOT leave fields empty unless intentionally blank.
-- Use add_approval when a task needs sign-off from a human or another agent before proceeding. Approvers can be agents (by name) or humans.
-- Task approvals (OFIERE_TASK_OPS) are SEPARATE from workflow gate approvals (human_approval nodes). Do not confuse them.
-- When an agent completes critical work, consider adding an approval request for human review before marking the task DONE.
-- When task instructions or system prompts contain file references like @[filename](file:FILE_ID), use OFIERE_FILE_OPS action:"read_text_file" file_id:"FILE_ID" to read the file content. Do NOT ask the user for the file — retrieve it yourself.
-- Use OFIERE_FILE_OPS to create output files (reports, data, configs) in the Space Files explorer. Prefer create_text_file for text-based outputs.
-- To save task output as a file, call OFIERE_FILE_OPS action:"create_text_file" with the space_id from the task context.
-- CHANNEL REPORTS: When the user asks you to "send a report", "send progress", "update me on Telegram/Discord/Slack/WhatsApp", use OFIERE_NOTIFY_OPS action:"send_report" with agent_id set to YOUR name. ALWAYS include agent_id — without it the report will fail. The report is generated from live PM data and sent through YOUR connected channels ONLY — not other agents' channels. Tasks are numbered (1, 2, 3...) for easy reference.
-- TASK DRILL-DOWN: When the user asks "details on number X", "what's task X result", "show me #X", or any variation referencing a numbered task from a report, use OFIERE_NOTIFY_OPS action:"get_task_detail" with task_number set to the number they mentioned. The description field contains the actual execution result (e.g. scan findings, analysis output). Present the description content as the primary response — that IS the task result.
-- To set up recurring reports (e.g. "send me a daily report at 9am"), use OFIERE_NOTIFY_OPS action:"schedule_report" with scope_type, recurrence_type, and agent_id set to YOUR name.
-- If a report is too long for the channel's message limit, save the full report as a markdown file using OFIERE_FILE_OPS action:"create_text_file" and send a summary to the channel instead.
-- PLANNING WORKFLOW: Use OFIERE_PLAN_OPS to build complex multi-step execution flows BEFORE creating individual tasks. Build the plan → let the user review in the Planning Tab → execute when approved.
-- When creating a plan with nodes, nest children inside each node's children[] array. Sequential children execute in order; set parallel: true on a parent node to fork its children into parallel branches.
-- Always call OFIERE_PLAN_OPS action:"get" before action:"add_nodes" or action:"update" to see the current tree structure and node IDs.
-- Execution ("execute") maps plan nodes 1:1 into real PM tasks with ALL enrichment fields preserved: execution_steps, goals, constraints, system_prompt. No data is lost in the handoff.
-- SOP CREATION: When asked to create an SOP, use OFIERE_SOP_OPS action:"create" with a COMPLETE sop_data object. Fill ALL fields with actionable, department-specific content — do NOT leave fields empty.
-- Each SOP step MUST have: a clear name, a specific action description, an assigned owner, and a concrete expected output.
-- Include escalation rules with appropriate priority levels (P1=critical blockers, P2=scope changes, P3=advisory).
-- When creating SOPs for department chiefs (Thalia=CMO, Ivy=COO, Daisy=CTO-Intel, Celia=CTO-Eng), tailor content to their domain expertise.
-- Prerequisites should be actionable checklist items. Success criteria should be measurable outcomes.
-- After creating an SOP, suggest the agent set it to "active" status when ready for execution.
-- PLANNING GATE: Before creating ANY task with 3+ execution steps, a due_date, or when the user describes a multi-phase project, ALWAYS ask: "Should I create a Plan first so you can review the structure before I create individual tasks?" If the user says yes, use OFIERE_PLAN_OPS. If they say no or it's a simple one-shot task, proceed directly with OFIERE_TASK_OPS.
-- TASK PLACEMENT — SOP-AWARE ROUTING: When creating a task, the system auto-assigns a PM space. But for FOLDER placement, follow this protocol:
-  1. If the user explicitly provides space_id or folder_id, use those directly.
-  2. If not, and you have active SOPs (loaded via 🔴 COMPLEX assessment), check if any SOP defines an operating structure or folder routing (e.g. "place marketing tasks in Marketing/Campaigns"). Follow the SOP's structure.
-  3. If no SOP guidance exists, check the Space Files tab for an operating map/structure document using OFIERE_FILE_OPS action:"list_files". If found, read it with "read_text_file" and follow its routing rules.
-  4. If no routing guidance exists at all, ask the user: "I can place this task in your default space root, or create a new folder/project for it. Which do you prefer?"
-  5. Do NOT blindly dump all SOPs to check routing — smart-select only SOPs whose title/department matches the task domain.
-## SOP PROTOCOL — Adaptive Complexity Assessment
-Before executing any user request, classify its complexity to decide whether to load your SOPs:
-### User Override (HIGHEST PRIORITY — always check first)
-- If user says "apply full SOP", "use SOP", "follow the SOP", "full protocol" → treat as 🔴 COMPLEX regardless of your classification
-- If user says "no SOP", "skip SOP", "just do it", "keep it simple", "quick" → treat as 🟢 SIMPLE regardless of your classification
-- User explicit intent ALWAYS overrides your classification
-### 🟢 SIMPLE (Skip SOPs — zero overhead)
-Single tool call, direct data retrieval, simple CRUD, status checks, quick answers.
-Criteria: Can be completed with ≤2 tool calls, no cross-agent coordination, no multi-phase execution.
-Examples: "Check my email", "List tasks", "Create a quick task", "What's the project status?", "Tell me about X"
-Action: Execute directly. Do NOT call OFIERE_SOP_OPS. Do NOT mention SOPs.
-### 🟡 MODERATE (Ask User)
-Multi-step work but clear execution path, no subagent delegation required, single-department scope.
-Criteria: 3-5 tool calls, single department, no escalation risk, no staff/subagent coordination needed.
-Examples: "Draft a marketing plan", "Set up a new workflow", "Analyze this report"
-Action: Ask the user briefly: "This task has moderate complexity. Do we need to apply full SOPs for this?"
-- If user says yes → escalate to 🔴 COMPLEX behavior
-- If user says no → proceed without SOPs
-### 🔴 COMPLEX (Auto-Load SOPs)
-Multi-phase execution, cross-department coordination, subagent delegation, production impact, escalation risk.
-Criteria: 5+ tool calls, multiple departments involved, needs staff/subagent coordination, or has escalation risk.
-Examples: "Launch full marketing campaign", "Execute deployment pipeline", "Restructure operations", "Full audit"
-Action:
-1. Call OFIERE_SOP_OPS action:"list" agent_id:"YOUR_NAME" to discover your active SOPs (returns titles + IDs)
-2. Review the SOP titles — select ONLY the SOPs relevant to the current task. Skip unrelated SOPs entirely. Do NOT load all SOPs blindly.
-3. For each RELEVANT SOP only: call OFIERE_SOP_OPS action:"get" sop_id:"..." to load full content
-4. Follow loaded SOPs as your execution framework:
-   - Prerequisites → validate ALL are met before starting (gate check)
-   - Steps → use as your execution plan (follow in order, each step has name/action/owner/output)
-   - Escalation Rules → apply when blockers arise or scope changes (P1=critical, P2=scope, P3=advisory)
-   - Success Criteria → verify ALL are met before marking task DONE
-5. If an SOP step assigns an "owner" that maps to one of your subagents, coordinate with that subagent
-6. Announce: "Applying [SOP_TITLE] protocol for this execution." (only name the SOPs you actually loaded)
-### Classification Transparency
-- When you load SOPs (🔴): state which SOP(s) you're following
-- When you ask about SOPs (🟡): keep the question brief and direct
-- When you skip SOPs (🟢): do NOT mention SOPs at all — just execute silently
+- When user says "create a task for [agent]", use OFIERE_AGENT_OPS action:"list" first.
+- Task statuses: PENDING, IN_PROGRESS, DONE, FAILED. Priority: 0=LOW, 1=MED, 2=HIGH, 3=CRITICAL.
+- Changes appear in the dashboard immediately via real-time sync.
+- Do NOT fabricate task IDs — always look up real IDs first.
+- For complex tasks, include execution_plan, goals, constraints. For simple tasks, just title.
+- When user asks about "knowledge base/library", ALWAYS use OFIERE_KNOWLEDGE_OPS.
+- CONSTELLATION: ALWAYS read_blueprint before creating/editing agents. ALWAYS confirm before delete.
+- WORKFLOWS: ALWAYS "get" before modifying. Use "insert_node_between" for mid-flow additions.
+- CHANNEL REPORTS: ALWAYS include agent_id (YOUR name) in send_report. Use get_task_detail for drill-down.
+- **PLANNING GATE (MANDATORY):** Before creating ANY task with 3+ execution steps, goals, constraints, OR a due_date, you MUST ask the user: "Would you like me to plan this first, or create the task directly?" If the user chooses to plan, use OFIERE_PLAN_OPS to create a visual plan first, then execute it to generate the real tasks. Do NOT skip this step.
+- File refs @[name](file:ID): Use OFIERE_FILE_OPS read_text_file to retrieve — don't ask user.
+- Task approvals (OFIERE_TASK_OPS) ≠ workflow gate approvals (human_approval nodes).
+## SOP PROTOCOL — Adaptive Complexity
+Classify complexity before executing:
+- **User Override**: "apply full SOP"/"use SOP" → 🔴 COMPLEX. "no SOP"/"just do it" → 🟢 SIMPLE.
+- **🟢 SIMPLE** (≤2 tool calls, no coordination): Execute directly. Do NOT mention SOPs.
+- **🟡 MODERATE** (3-5 calls, single dept): Ask briefly if SOPs needed.
+- **🔴 COMPLEX** (5+ calls, multi-dept, escalation risk): Auto-load relevant SOPs via list→get.
 ## Agent Brain Protocol (TMT Subconscious)
-Your brain persists across conversations via the TMT (Temporal Memory Tree) hierarchy. At startup, your L5 persona, L4 guardrails, and L1 focus memories are injected automatically.
-### Auto-Memory (OFIERE_BRAIN_OPS save_memory)
-After interactions where ANY of these occur, call save_memory:
-- User shares important context → L2_episode, source: "auto"
-- You complete a task with noteworthy results → L2_episode, source: "tool"
-- You observe important system behavior → L2_episode, source: "auto"
-- Something needs immediate working context → L1_focus (auto-expires 24h)
-- A pattern emerges across multiple episodes → L3_pattern, source: "reflection"
-### Auto-Learn (OFIERE_BRAIN_OPS log_learning)
-After interactions where ANY of these occur, call log_learning (stored as L4_rule):
-- User corrects you → category: "correction", severity: "medium"
-- A tool call fails or returns an error → category: "error"
-- User asks for something you can't do → category: "feature_request"
-- Your knowledge or assumption was wrong → category: "insight"
-- You discover a better approach → category: "best_practice"
-### Knowledge Graph (OFIERE_BRAIN_OPS save_entity/link_entities)
-When you encounter key entities, concepts, or causal relationships:
-- Create entities for users, projects, tools, or recurring concepts
-- Link entities with typed edges (causes, depends_on, related_to)
-- Query the graph when reasoning about relationships or dependencies
-### Trajectory Recording (OFIERE_BRAIN_OPS start_trajectory/end_trajectory)
-For complex multi-step tasks:
-- Call start_trajectory before executing a tool chain
-- Call end_trajectory with outcome when the chain completes
-- This feeds the ReasoningBank for autonomous self-improvement
-### Rules
-- These calls happen AFTER your response to the user — never delay your reply to save a memory
-- Do NOT announce "saving memory" or "logging learning" to the user — this is subconscious
-- Do NOT save trivial interactions (greetings, confirmations, simple CRUD) — only signal worth remembering
-- Keep memory content concise: 1-3 sentences max. No system junk, keep it human
-- When you see your L4 guardrails at startup, actively avoid violating them
-- Use promote_memory when a pattern solidifies: L2→L3→L4→L5
+Your brain persists across conversations. L5 persona, L4 guardrails, L1 focus are injected at startup.
+- Save memories after significant interactions (not greetings/CRUD). Keep content to 1-3 sentences.
+- Log learnings on corrections, errors, feature requests, insights, best practices.
+- Do NOT announce memory operations — this is subconscious.
+- Never delay your reply to save a memory.
 </ofiere-pm>`;
   }

package/src/tools.ts CHANGED Viewed

@@ -198,7 +198,7 @@ function registerTaskOps(
       `Actions:\n` +
       `- "list": List/filter tasks. Optional: status, agent_id, space_id, folder_id, task_id, limit\n` +
       `- "get": Get a single task by ID. Required: task_id\n` +
-      `- "create": Create a task. Required: title. Optional: agent_id, description, status, priority, space_id, folder_id, start_date, due_date, tags, instructions, execution_plan, goals, constraints, system_prompt, recurrence_type, recurrence_interval, scheduled_time\n` +
+      `- "create": Create a task. Required: title. Optional: agent_id, description, status, priority, space_id, folder_id, start_date, due_date, tags, instructions, execution_plan, goals, constraints, system_prompt, recurrence_type, recurrence_interval, scheduled_time. ⚠️ PLANNING GATE: If the task has 3+ execution steps, goals, or constraints, FIRST ask the user "Plan first or create directly?" If they choose to plan, use OFIERE_PLAN_OPS instead.\n` +
       `- "update": Update a task. Required: task_id. Optional: all create fields + progress\n` +
       `- "delete": Delete task + subtasks. Required: task_id\n` +
       `- "add_approval": Request approval on a task. Required: task_id, approver_name. Optional: approver_type (human|agent, auto-detected), due_date, comment\n` +
@@ -241,7 +241,7 @@ function registerTaskOps(
         folder_id: { type: "string", description: "PM Folder ID" },
         start_date: { type: "string", description: "Start date (ISO 8601). Required for scheduled/recurring tasks." },
         due_date: { type: "string", description: "Due date (ISO 8601)" },
-        scheduled_time: { type: "string", description: "Time to execute in HH:MM format (UTC). If omitted, extracted from start_date or defaults to now+60s." },
+        scheduled_time: { type: "string", description: "Time to execute in HH:MM format (user's LOCAL time, e.g. 10:00 for 10 AM WIB). The system converts to UTC automatically." },
         recurrence_type: {
           type: "string",
           description: "How often the task recurs. 'none' for one-shot.",
@@ -542,8 +542,12 @@ async function handleCreateTask(
     // ── Auto-create scheduler event if task has a start_date ──────────────
     // This bridges the plugin → scheduler so the pg_cron task-dispatcher
     // Edge Function picks up the task at the right time.
+    //
+    // TIMEZONE: scheduled_time is treated as the user's LOCAL time (default WIB, UTC+7).
+    // We convert to UTC epoch for next_run_at so the edge function fires correctly.
     const startDate = params.start_date as string | undefined;
     const effectiveAgentId = (insertData.agent_id as string) || assignee;
+    const WIB_OFFSET_HOURS = 7; // Asia/Jakarta = UTC+7
     if (startDate && effectiveAgentId) {
       try {
         // Parse start_date robustly — it can be:
@@ -563,23 +567,41 @@ async function handleCreateTask(
           const hasTimeInfo = /[T ]\d{2}:\d{2}/.test(startDate);
           if (explicitScheduledTime) {
-            // Agent explicitly passed a scheduled_time — use date from start_date + explicit time
+            // Agent explicitly passed a scheduled_time — treat as WIB local time
             const dateStr = parsedDate.toISOString().split("T")[0]; // YYYY-MM-DD
-            const dt = new Date(`${dateStr}T${explicitScheduledTime}:00Z`);
+            const [localH, localM] = explicitScheduledTime.split(":").map(Number);
+            const utcH = localH - WIB_OFFSET_HOURS;
+            const dt = new Date(`${dateStr}T00:00:00Z`);
+            dt.setUTCHours(utcH, localM, 0, 0);
             nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-            scheduledTimeFinal = explicitScheduledTime;
+            scheduledTimeFinal = explicitScheduledTime; // Store as user's local time
             scheduledDateFinal = dateStr;
           } else if (hasTimeInfo) {
-            // start_date already contains time — use it directly
-            nextRunAtEpoch = Math.floor(parsedDate.getTime() / 1000);
-            scheduledTimeFinal = `${String(parsedDate.getUTCHours()).padStart(2, "0")}:${String(parsedDate.getUTCMinutes()).padStart(2, "0")}`;
-            scheduledDateFinal = parsedDate.toISOString().split("T")[0];
+            // start_date already contains time — assume it's in the user's local timezone (WIB)
+            // Extract the local hour:minute from the string, NOT from UTC parsing
+            const timeMatch = startDate.match(/(\d{2}):(\d{2})/);
+            if (timeMatch) {
+              const localH = parseInt(timeMatch[1], 10);
+              const localM = parseInt(timeMatch[2], 10);
+              const dateStr = parsedDate.toISOString().split("T")[0];
+              const dt = new Date(`${dateStr}T00:00:00Z`);
+              dt.setUTCHours(localH - WIB_OFFSET_HOURS, localM, 0, 0);
+              nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
+              scheduledTimeFinal = `${String(localH).padStart(2, "0")}:${String(localM).padStart(2, "0")}`;
+              scheduledDateFinal = dateStr;
+            } else {
+              // Can't extract time — fall back to UTC parsing
+              nextRunAtEpoch = Math.floor(parsedDate.getTime() / 1000);
+              scheduledTimeFinal = `${String(parsedDate.getUTCHours()).padStart(2, "0")}:${String(parsedDate.getUTCMinutes()).padStart(2, "0")}`;
+              scheduledDateFinal = parsedDate.toISOString().split("T")[0];
+            }
           } else {
-            // Date only, no time — default to 09:00 UTC
+            // Date only, no time — default to 09:00 WIB (= 02:00 UTC)
             const dateStr = parsedDate.toISOString().split("T")[0];
-            const dt = new Date(`${dateStr}T09:00:00Z`);
+            const dt = new Date(`${dateStr}T00:00:00Z`);
+            dt.setUTCHours(9 - WIB_OFFSET_HOURS, 0, 0, 0); // 09:00 WIB = 02:00 UTC
             nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-            scheduledTimeFinal = "09:00";
+            scheduledTimeFinal = "09:00"; // Stored as WIB local time
             scheduledDateFinal = dateStr;
           }
         } else {
@@ -611,6 +633,7 @@ async function handleCreateTask(
           next_run_at: nextRunAtEpoch,
           run_count: 0,
           priority: params.priority !== undefined ? params.priority : 1,
+          timezone: "Asia/Jakarta",
         });
       } catch (schedErr) {
         // Non-fatal: task was created, just the scheduler event failed
@@ -5776,23 +5799,22 @@ function registerBrainExtractionHook(
           }
         }
-        // Phase 2: Parallel dedup check (1 query per candidate, all at once)
+        // Phase 2: Single batch dedup check (1 query for ALL candidates)
         if (candidates.length > 0) {
-          const dedupResults = await Promise.all(
-            candidates.map(c =>
-              supabase.from("agent_memories")
-                .select("id")
-                .eq("user_id", userId)
-                .eq("agent_id", resolvedAgentId)
-                .eq("context_key", c.contextKey)
-                .is("superseded_by", null)
-                .limit(1)
-            )
-          );
+          const allKeys = candidates.map(c => c.contextKey);
+          const { data: existingRows } = await supabase
+            .from("agent_memories")
+            .select("context_key")
+            .eq("user_id", userId)
+            .eq("agent_id", resolvedAgentId)
+            .in("context_key", allKeys)
+            .is("superseded_by", null);
+          const existingKeys = new Set((existingRows || []).map((r: any) => r.context_key));
           // Phase 3: Batch insert only new candidates
           const toInsert = candidates
-            .filter((_, i) => !dedupResults[i].data?.length)
+            .filter(c => !existingKeys.has(c.contextKey))
             .map(c => ({
               user_id: userId,
               agent_id: resolvedAgentId,
@@ -5835,6 +5857,51 @@ function registerBrainExtractionHook(
 // OpenClaw on every prompt build, resolves the correct agent, and loads
 // that specific agent's brain. Each agent gets its own memories.
+// Background cache refresher for stale-while-revalidate pattern
+async function refreshBrainCache(
+  supabase: SupabaseClient,
+  userId: string,
+  agentId: string,
+  api: any,
+): Promise<void> {
+  try {
+    const now = new Date().toISOString();
+    const { data: allBrain } = await supabase
+      .from("agent_memories")
+      .select("content, importance, tier")
+      .eq("user_id", userId)
+      .eq("agent_id", agentId)
+      .in("tier", ["L1_focus", "L4_rule", "L5_persona"])
+      .gt("decay_score", 0.1)
+      .is("superseded_by", null)
+      .or(`expires_at.is.null,expires_at.gt.${now}`)
+      .order("importance", { ascending: false })
+      .limit(18);
+    const all = allBrain || [];
+    const l1 = all.filter((m: any) => m.tier === "L1_focus").slice(0, 5);
+    const l4 = all.filter((m: any) => m.tier === "L4_rule").slice(0, 10);
+    const l5 = all.filter((m: any) => m.tier === "L5_persona").slice(0, 3);
+    if (l1.length === 0 && l4.length === 0 && l5.length === 0) {
+      brainCache.set(agentId, { text: "", at: Date.now() });
+      return;
+    }
+    const sections: string[] = [];
+    if (l5.length > 0) sections.push("### Identity (L5_persona)\n" + l5.map((m: any) => `- ${m.content}`).join("\n"));
+    if (l4.length > 0) sections.push("### ⚠️ Guardrails (L4_rule — DO NOT violate)\n" + l4.map((m: any) => `- ${m.content}`).join("\n"));
+    if (l1.length > 0) sections.push("### Active Focus (L1_focus)\n" + l1.map((m: any) => `- ${m.content}`).join("\n"));
+    brainCache.set(agentId, {
+      text: `<agent-brain>\n## Your Brain Context (TMT)\n\n${sections.join("\n\n")}\n</agent-brain>`,
+      at: Date.now(),
+    });
+  } catch (e) {
+    api.logger.debug?.(`[ofiere-brain] Background cache refresh error: ${e instanceof Error ? e.message : e}`);
+  }
+}
 function registerBrainContextHook(
   api: any,
   supabase: SupabaseClient,
@@ -5843,7 +5910,8 @@ function registerBrainContextHook(
 ): void {
   // Uses module-scoped brainCache (declared at top of file) for cross-function
   // invalidation. save_memory calls brainCache.delete(agentId) for immediate consistency.
-  const CACHE_TTL_MS = 300_000;
+  const CACHE_TTL_MS = 600_000; // 10 min — brain context doesn't change fast
+  const STALE_THRESHOLD_MS = 900_000; // 15 min — serve stale while refreshing
   try {
     api.on("before_prompt_build", async (_event: any, ctx: any) => {
@@ -5863,10 +5931,19 @@ function registerBrainContextHook(
         if (!resolvedAgentId) return;
-        // ── Check cache ──
+        // ── Check cache (stale-while-revalidate) ──
         const cached = brainCache.get(resolvedAgentId);
-        if (cached && Date.now() - cached.at < CACHE_TTL_MS) {
-          return cached.text ? { appendSystemContext: cached.text } : undefined;
+        if (cached) {
+          const age = Date.now() - cached.at;
+          if (age < CACHE_TTL_MS) {
+            // Fresh — serve immediately
+            return cached.text ? { appendSystemContext: cached.text } : undefined;
+          }
+          if (age < STALE_THRESHOLD_MS) {
+            // Stale — serve stale and refresh in background (non-blocking)
+            refreshBrainCache(supabase, userId, resolvedAgentId, api).catch(() => {});
+            return cached.text ? { appendSystemContext: cached.text } : undefined;
+          }
         }
         // ── Query brain memories for THIS specific agent ──