ofiere-openclaw-plugin 4.45.0 → 4.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.45.0",
+  "version": "4.46.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 16 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, and corporate frameworks",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/attachments.ts

@@ -15,7 +15,7 @@ import {
   invalidateAgentTier,
 } from "./agent-tier.js";
 import { issueAttachmentToken, verifyAttachmentToken } from "./attach-token.js";
-import { loadSubagentRow, buildStaffPersonaBlock, readDispatchSubagentId, loadChiefStaffDefaults, resolveStaffModels, type SubagentRow } from "./staffPersona.js";
+import { loadSubagentRow, buildStaffPersonaBlock, readDispatchSubagentId, loadChiefStaffDefaults, loadDispatchContextBySession, resolveStaffModels, type SubagentRow, type DispatchContextRow } from "./staffPersona.js";
 
 interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
@@ -427,7 +427,27 @@ export function registerAttachmentContextHook(args: {
         // Cycle 7b — staff persona injection. Only fires when subagent_id is
         // present in dispatch metadata (task-dispatcher / scheduler / explicit
         // dispatch params). Plain user chats with the chief never persona-swap.
-        const subagentId = readDispatchSubagentId(ctx);
+        //
+        // Cycle 7b BUGSHOOT-1 (BUG 2) — OpenClaw gateway core rejects unknown
+        // root key `metadata` on chat.send, so the dispatcher can't ride
+        // metadata through the wire. After the metadata path comes up empty,
+        // try the dispatch_context table keyed by sessionKey. The metadata
+        // path is preferred so a future gateway upgrade keeps working.
+        const sessionKey: string | null =
+          ctx?.sessionKey || ctx?.session_key ||
+          (typeof _event === "object" ? (_event?.sessionKey || _event?.context?.sessionKey || null) : null) ||
+          null;
+        let dispatchCtxRow: DispatchContextRow | null = null;
+        let subagentId = readDispatchSubagentId(ctx);
+        if (!subagentId && sessionKey) {
+          dispatchCtxRow = await loadDispatchContextBySession(supabase, userId, sessionKey).catch(() => null);
+          if (dispatchCtxRow?.subagent_id) {
+            subagentId = dispatchCtxRow.subagent_id;
+            api.logger?.debug?.(
+              `[ofiere-staff] subagent_id resolved via dispatch_context (session=${sessionKey})`,
+            );
+          }
+        }
         let staffPrefix = "";
         let staffRow: SubagentRow | null = null;
         if (subagentId) {
@@ -460,7 +480,23 @@ export function registerAttachmentContextHook(args: {
         // can stash explicit `attached_sop_ids` / `attached_framework_ids` on the
         // chat.send frame's metadata. When present, prefer them over the
         // most-recent-conversation lookup and bypass cache (per-dispatch ids).
-        const dispatchIds = readDispatchAttachmentIds(ctx);
+        let dispatchIds = readDispatchAttachmentIds(ctx);
+        // Cycle 7b BUGSHOOT-1 (BUG 2) — DB-backed dispatch-context fallback for
+        // attachment ids. Same rationale as the subagent_id fallback above.
+        if (!dispatchIds.sopIds.length && !dispatchIds.fwIds.length && sessionKey) {
+          if (!dispatchCtxRow) {
+            dispatchCtxRow = await loadDispatchContextBySession(supabase, userId, sessionKey).catch(() => null);
+          }
+          if (dispatchCtxRow && (dispatchCtxRow.attached_sop_ids.length || dispatchCtxRow.attached_framework_ids.length)) {
+            dispatchIds = {
+              sopIds: dispatchCtxRow.attached_sop_ids,
+              fwIds: dispatchCtxRow.attached_framework_ids,
+            };
+            api.logger?.debug?.(
+              `[ofiere-attach] dispatch ids via dispatch_context (session=${sessionKey}) sops=${dispatchIds.sopIds.length} fws=${dispatchIds.fwIds.length}`,
+            );
+          }
+        }
         if (dispatchIds.sopIds.length || dispatchIds.fwIds.length) {
           api.logger?.debug?.(
             `[ofiere-attach] dispatch ids agent=${resolvedAgentId} sops=${dispatchIds.sopIds.length} fws=${dispatchIds.fwIds.length}`,

package/src/staffPersona.ts

@@ -59,6 +59,50 @@ export function readDispatchSubagentId(ctx: any, event?: any): string | null {
   return null;
 }
 
+// Cycle 7b BUGSHOOT-1 (BUG 2) — DB-backed dispatch context fallback.
+// OpenClaw gateway core rejects unknown root key `metadata` on chat.send, so
+// the task-dispatcher edge function can't ride dispatch metadata through the
+// wire. The dispatcher writes a row to public.dispatch_context keyed by
+// (user_id, session_key) before chat.send fires; this loader reads it back
+// during before_prompt_build when the metadata path comes up empty.
+//
+// Returns the dispatch context for the most recent matching row, or null if
+// none exists. The metadata path is preferred so a future gateway upgrade
+// that natively accepts metadata keeps working with no flag day.
+export interface DispatchContextRow {
+  subagent_id: string | null;
+  attached_sop_ids: string[];
+  attached_framework_ids: string[];
+  task_id: string | null;
+}
+
+export async function loadDispatchContextBySession(
+  supabase: SupabaseClient,
+  userId: string,
+  sessionKey: string,
+): Promise<DispatchContextRow | null> {
+  if (!sessionKey) return null;
+  const { data, error } = await supabase
+    .from("dispatch_context")
+    .select("subagent_id, attached_sop_ids, attached_framework_ids, task_id")
+    .eq("user_id", userId)
+    .eq("session_key", sessionKey)
+    .order("created_at", { ascending: false })
+    .limit(1)
+    .maybeSingle();
+  if (error || !data) return null;
+  return {
+    subagent_id: (data.subagent_id as string | null) ?? null,
+    attached_sop_ids: Array.isArray(data.attached_sop_ids)
+      ? (data.attached_sop_ids as unknown[]).filter((x): x is string => typeof x === "string")
+      : [],
+    attached_framework_ids: Array.isArray(data.attached_framework_ids)
+      ? (data.attached_framework_ids as unknown[]).filter((x): x is string => typeof x === "string")
+      : [],
+    task_id: (data.task_id as string | null) ?? null,
+  };
+}
+
 export type StaffModelSlot =
   | "primary_model"
   | "coding_model"

package/src/tools.ts

@@ -653,6 +653,12 @@ async function handleCreateTask(
         if (!isNaN(parsedDate.getTime())) {
           // Valid date — check if it includes a meaningful time component
           const hasTimeInfo = /[T ]\d{2}:\d{2}/.test(startDate);
+          // BUG 4 fix (cycle 7b BUGSHOOT-1): if the input string already carries
+          // an explicit UTC marker (Z, +00, +0000, +00:00, UTC), the time
+          // component is NOT user-local — skip the local→UTC subtraction.
+          // Without this, a UTC-Z input like "2026-05-10T16:25:00Z" got mistaken
+          // for local 16:25 and stored as 09:25Z (off by TZ_OFFSET_HOURS).
+          const isUtcInput = /Z$|[+-]00:?00$|UTC$/i.test(startDate.trim());
 
           if (explicitScheduledTime) {
             // Agent explicitly passed a scheduled_time — treat as user’s local time
@@ -666,6 +672,15 @@ async function handleCreateTask(
             scheduledDateFinal = dateStr;
             // Normalize start_date to ISO UTC for consistent downstream parsing
             insertData.start_date = dt.toISOString();
+          } else if (isUtcInput) {
+            // Input is already UTC — no local→UTC conversion. Use parsedDate
+            // directly. scheduled_time is documented as user-local, so add the
+            // offset to recover the local-clock value.
+            nextRunAtEpoch = Math.floor(parsedDate.getTime() / 1000);
+            const localHour = (parsedDate.getUTCHours() + TZ_OFFSET_HOURS + 24) % 24;
+            scheduledTimeFinal = `${String(localHour).padStart(2, "0")}:${String(parsedDate.getUTCMinutes()).padStart(2, "0")}`;
+            scheduledDateFinal = parsedDate.toISOString().split("T")[0];
+            insertData.start_date = parsedDate.toISOString();
           } else if (hasTimeInfo) {
             // start_date already contains time — assume it’s in the user’s local timezone
             // Extract the local hour:minute from the string, NOT from UTC parsing
@@ -5387,14 +5402,36 @@ async function handleCreateSubagent(supabase: SupabaseClient, userId: string, pa
       return err(`Maximum ${MAX_SUBAGENTS_PER_CHIEF} subagents per department chief`);
     }
 
-    const role = (params.role as string) || "Staff";
-    const codename = (params.codename as string) ?? null;
-    const colorHex = (params.color_hex as string) || "#64748b";
+    // BUG 1 fix (cycle 7b BUGSHOOT-1): persist persona/model/MCP fields on
+    // create. Schema accepts them (see SUBAGENT_INPUT_SCHEMA above) but the
+    // previous insert dropped everything except identity/UI fields, forcing a
+    // follow-up update_subagent. Mirror the field whitelist used in
+    // handleUpdateSubagent so create/update stay in lockstep.
+    const insertRow: Record<string, unknown> = {
+      user_id: userId,
+      chief_agent_id: chiefAgentId,
+      name,
+      role: (params.role as string) || "Staff",
+      codename: (params.codename as string) ?? null,
+      color_hex: (params.color_hex as string) || "#64748b",
+    };
+    const personaFields = [
+      "system_prompt", "mission", "responsibilities", "instructions",
+      "primary_model", "coding_model", "tool_call_model", "function_call_model", "vision_model",
+    ] as const;
+    for (const key of personaFields) {
+      if (key in params && params[key] !== undefined) insertRow[key] = params[key];
+    }
+    if ("mcp_server_ids" in params && Array.isArray(params.mcp_server_ids)) {
+      insertRow.mcp_server_ids = (params.mcp_server_ids as unknown[]).filter(
+        (x): x is string => typeof x === "string",
+      );
+    }
 
     const { data, error } = await supabase
       .from("agent_subagents")
-      .insert({ user_id: userId, chief_agent_id: chiefAgentId, name, role, codename, color_hex: colorHex })
-      .select("id, user_id, chief_agent_id, name, role, codename, color_hex, created_at")
+      .insert(insertRow)
+      .select()
       .single();
     if (error) return err(error.message);
     return ok({ subagent: data, message: `Subagent "${name}" created under chief ${chiefAgentId}` });