ofiere-openclaw-plugin 4.44.0 → 4.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.44.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, 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,15 +427,37 @@ 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) {
           staffRow = await loadSubagentRow(supabase, userId, subagentId);
           if (staffRow && staffRow.chief_agent_id === resolvedAgentId) {
-            staffPrefix = buildStaffPersonaBlock(staffRow) + "\n\n---\n\n";
+            const chiefDefaults = await loadChiefStaffDefaults(supabase, userId, staffRow.chief_agent_id).catch(() => null);
+            const resolved = resolveStaffModels(staffRow, chiefDefaults);
+            staffPrefix = buildStaffPersonaBlock(staffRow, resolved) + "\n\n---\n\n";
             api.logger?.debug?.(
-              `[ofiere-staff] subagent ${subagentId} (${staffRow.name}) reporting to ${resolvedAgentId} — persona injected`,
+              `[ofiere-staff] subagent ${subagentId} (${staffRow.name}) reporting to ${resolvedAgentId} — persona injected; resolved models: ${JSON.stringify(resolved)}`,
             );
           } else if (staffRow) {
             api.logger?.warn?.(
@@ -458,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,7 +59,149 @@ export function readDispatchSubagentId(ctx: any, event?: any): string | null {
   return null;
 }
 
-export function buildStaffPersonaBlock(staff: SubagentRow): string {
+// 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"
+  | "tool_call_model"
+  | "function_call_model"
+  | "vision_model";
+
+export interface ChiefStaffDefaultsRow {
+  chief_agent_id: string;
+  primary_model: string | null;
+  coding_model: string | null;
+  tool_call_model: string | null;
+  function_call_model: string | null;
+  vision_model: string | null;
+}
+
+export interface ResolvedStaffModels {
+  primary_model: string | null;
+  coding_model: string | null;
+  tool_call_model: string | null;
+  function_call_model: string | null;
+  vision_model: string | null;
+  source: Record<StaffModelSlot, "staff" | "chief_default" | "chief_fallback" | null>;
+}
+
+const SLOTS: StaffModelSlot[] = [
+  "primary_model",
+  "coding_model",
+  "tool_call_model",
+  "function_call_model",
+  "vision_model",
+];
+
+export async function loadChiefStaffDefaults(
+  supabase: SupabaseClient,
+  userId: string,
+  chiefAgentId: string,
+): Promise<ChiefStaffDefaultsRow | null> {
+  const { data, error } = await supabase
+    .from("chief_staff_defaults")
+    .select(
+      "chief_agent_id, primary_model, coding_model, tool_call_model, function_call_model, vision_model",
+    )
+    .eq("user_id", userId)
+    .eq("chief_agent_id", chiefAgentId)
+    .maybeSingle();
+  if (error || !data) return null;
+  return data as ChiefStaffDefaultsRow;
+}
+
+/**
+ * Resolution chain at delegate_to_staff time:
+ *   staff.<slot>          (per-staff override on agent_subagents)
+ *   ?? chief_staff_defaults.<slot>     (chief-level "STAFF MODEL")
+ *   ?? null   (caller falls back to the chief's own model — that lookup
+ *              happens in the OpenClaw runtime, not here).
+ *
+ * The chief's own model is intentionally not touched. Empty staff slot +
+ * empty chief STAFF MODEL = inherit chief's primary_model (gateway default).
+ */
+export function resolveStaffModels(
+  staff: SubagentRow,
+  chiefDefaults: ChiefStaffDefaultsRow | null,
+): ResolvedStaffModels {
+  const out: ResolvedStaffModels = {
+    primary_model: null,
+    coding_model: null,
+    tool_call_model: null,
+    function_call_model: null,
+    vision_model: null,
+    source: {
+      primary_model: null,
+      coding_model: null,
+      tool_call_model: null,
+      function_call_model: null,
+      vision_model: null,
+    },
+  };
+  for (const slot of SLOTS) {
+    const staffVal = (staff as any)[slot] as string | null | undefined;
+    const chiefVal = chiefDefaults ? (chiefDefaults as any)[slot] as string | null | undefined : null;
+    if (staffVal && staffVal.trim()) {
+      out[slot] = staffVal;
+      out.source[slot] = "staff";
+    } else if (chiefVal && chiefVal.trim()) {
+      out[slot] = chiefVal;
+      out.source[slot] = "chief_default";
+    } else {
+      out[slot] = null;
+      out.source[slot] = "chief_fallback";
+    }
+  }
+  return out;
+}
+
+export function buildStaffPersonaBlock(
+  staff: SubagentRow,
+  resolved?: ResolvedStaffModels,
+): string {
   const lines: string[] = [];
   lines.push(`# STAFF IDENTITY`);
   lines.push(
@@ -80,5 +222,18 @@ export function buildStaffPersonaBlock(staff: SubagentRow): string {
   if (staff.instructions?.trim()) {
     lines.push(``, `## Operating Instructions`, staff.instructions.trim());
   }
+  if (resolved && (resolved.primary_model || resolved.coding_model || resolved.tool_call_model || resolved.function_call_model || resolved.vision_model)) {
+    const sourceLabel = (s: "staff" | "chief_default" | "chief_fallback" | null) =>
+      s === "staff" ? "per-staff override" : s === "chief_default" ? "chief STAFF MODEL" : "inherits chief";
+    const rows: string[] = [];
+    if (resolved.primary_model) rows.push(`- primary: \`${resolved.primary_model}\` (${sourceLabel(resolved.source.primary_model)})`);
+    if (resolved.coding_model) rows.push(`- coding: \`${resolved.coding_model}\` (${sourceLabel(resolved.source.coding_model)})`);
+    if (resolved.tool_call_model) rows.push(`- tool_call: \`${resolved.tool_call_model}\` (${sourceLabel(resolved.source.tool_call_model)})`);
+    if (resolved.function_call_model) rows.push(`- function_call: \`${resolved.function_call_model}\` (${sourceLabel(resolved.source.function_call_model)})`);
+    if (resolved.vision_model) rows.push(`- vision: \`${resolved.vision_model}\` (${sourceLabel(resolved.source.vision_model)})`);
+    if (rows.length) {
+      lines.push(``, `## Configured Models`, ...rows);
+    }
+  }
   return lines.join("\n");
 }

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}` });