ofiere-openclaw-plugin 4.45.0 → 4.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.45.0",
+  "version": "4.47.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,52 @@ 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;
+  conversation_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, conversation_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,
+    conversation_id: (data.conversation_id as string | null) ?? null,
+  };
+}
+
 export type StaffModelSlot =
   | "primary_model"
   | "coding_model"

package/src/tools.ts

@@ -19,7 +19,7 @@ import {
   registerAttachmentContextHook,
 } from "./attachments.js";
 import { invalidateAgentTier } from "./agent-tier.js";
-import { loadSubagentRow, readDispatchSubagentId } from "./staffPersona.js";
+import { loadSubagentRow, readDispatchSubagentId, loadDispatchContextBySession, type DispatchContextRow } from "./staffPersona.js";
 
 // ─── Tool result shape (matches OpenClaw SDK) ────────────────────────────────
 
@@ -458,12 +458,145 @@ async function handleListTasks(
   }
 }
 
+// Cycle 7b BUGSHOOT-2 (BUG 5) — IANA timezone offset in hours. Works regardless
+// of the VPS clock TZ because Intl.DateTimeFormat resolves the IANA zone
+// directly without going through `new Date(local-string)` parsing.
+function getTimezoneOffsetHours(tz: string): number {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      timeZoneName: "shortOffset",
+    }).formatToParts(new Date());
+    const offsetPart = parts.find((p) => p.type === "timeZoneName");
+    const txt = offsetPart?.value || "GMT+0";
+    const m = txt.match(/GMT([+-]\d{1,2})(?::?(\d{2}))?/i);
+    if (!m) return 0;
+    const hours = parseInt(m[1], 10);
+    const minutes = m[2] ? parseInt(m[2], 10) : 0;
+    return hours + (hours < 0 ? -minutes / 60 : minutes / 60);
+  } catch {
+    return 7;
+  }
+}
+
+// Cycle 7b BUGSHOOT-2 (BUG 5) — load the caller's IANA timezone from their
+// profile row. The dashboard writes it on sign-in (browser-detected). Falls
+// back to the plugin-config default if unset/missing.
+async function loadUserTimezone(
+  supabase: SupabaseClient,
+  userId: string,
+  fallback: string,
+): Promise<string> {
+  try {
+    const { data } = await supabase
+      .from("profiles")
+      .select("timezone")
+      .eq("id", userId)
+      .maybeSingle();
+    const tz = typeof data?.timezone === "string" && data.timezone.trim()
+      ? data.timezone.trim()
+      : null;
+    return tz || fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// Cycle 7b BUGSHOOT-2 (BUG 5) — normalize a start_date string to UTC against
+// the user's IANA timezone. Returns the canonical UTC ISO string, the epoch
+// for next_run_at, and the local clock components for scheduler_events.
+//
+// Three input shapes are handled:
+//   - explicit UTC marker (Z, +00, +0000, +00:00, UTC) → no conversion
+//   - has time component, no UTC marker → treat as user-local, subtract offset
+//   - date only → default to 09:00 user-local, subtract offset
+//
+// Critical: parses date/time COMPONENTS from the raw string via regex, NOT via
+// `new Date(str)`. JS Date parsing of naive strings is TZ-dependent on the
+// host clock — the VPS may be WIB or UTC, and we cannot trust either.
+function normalizeStartDate(
+  startDate: string,
+  explicitScheduledTime: string | undefined,
+  tzOffsetHours: number,
+): {
+  startDateUTC: string;
+  nextRunAtEpoch: number;
+  scheduledTimeLocal: string;
+  scheduledDateLocal: string;
+} | null {
+  const trimmed = startDate.trim();
+  const dateMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (!dateMatch) return null;
+  const year = parseInt(dateMatch[1], 10);
+  const month = parseInt(dateMatch[2], 10);
+  const day = parseInt(dateMatch[3], 10);
+
+  const utcMarker = /Z$|[+-]00:?00$|UTC$/i.test(trimmed);
+  const timeMatch = trimmed.match(/[T ](\d{2}):(\d{2})(?::(\d{2}))?/);
+  const offsetMin = Math.round(tzOffsetHours * 60);
+  const pad = (n: number) => String(n).padStart(2, "0");
+
+  // explicit scheduled_time: agent passed local time alongside a date.
+  if (explicitScheduledTime) {
+    const stMatch = explicitScheduledTime.match(/^(\d{2}):(\d{2})/);
+    const localH = stMatch ? parseInt(stMatch[1], 10) : 0;
+    const localM = stMatch ? parseInt(stMatch[2], 10) : 0;
+    const utcMs = Date.UTC(year, month - 1, day, localH, localM, 0) - offsetMin * 60 * 1000;
+    return {
+      startDateUTC: new Date(utcMs).toISOString(),
+      nextRunAtEpoch: Math.floor(utcMs / 1000),
+      scheduledTimeLocal: `${pad(localH)}:${pad(localM)}`,
+      scheduledDateLocal: `${year}-${pad(month)}-${pad(day)}`,
+    };
+  }
+
+  if (utcMarker && timeMatch) {
+    // Input is already UTC. Use components verbatim.
+    const utcH = parseInt(timeMatch[1], 10);
+    const utcM = parseInt(timeMatch[2], 10);
+    const utcS = timeMatch[3] ? parseInt(timeMatch[3], 10) : 0;
+    const utcMs = Date.UTC(year, month - 1, day, utcH, utcM, utcS);
+    // Recover local clock by adding the user's offset.
+    const localMs = utcMs + offsetMin * 60 * 1000;
+    const local = new Date(localMs);
+    return {
+      startDateUTC: new Date(utcMs).toISOString(),
+      nextRunAtEpoch: Math.floor(utcMs / 1000),
+      scheduledTimeLocal: `${pad(local.getUTCHours())}:${pad(local.getUTCMinutes())}`,
+      scheduledDateLocal: `${local.getUTCFullYear()}-${pad(local.getUTCMonth() + 1)}-${pad(local.getUTCDate())}`,
+    };
+  }
+
+  if (timeMatch) {
+    // Local-no-Z input: user-local time, subtract offset to get UTC.
+    const localH = parseInt(timeMatch[1], 10);
+    const localM = parseInt(timeMatch[2], 10);
+    const localS = timeMatch[3] ? parseInt(timeMatch[3], 10) : 0;
+    const utcMs = Date.UTC(year, month - 1, day, localH, localM, localS) - offsetMin * 60 * 1000;
+    return {
+      startDateUTC: new Date(utcMs).toISOString(),
+      nextRunAtEpoch: Math.floor(utcMs / 1000),
+      scheduledTimeLocal: `${pad(localH)}:${pad(localM)}`,
+      scheduledDateLocal: `${year}-${pad(month)}-${pad(day)}`,
+    };
+  }
+
+  // Date-only input — default to 09:00 user-local.
+  const utcMs = Date.UTC(year, month - 1, day, 9, 0, 0) - offsetMin * 60 * 1000;
+  return {
+    startDateUTC: new Date(utcMs).toISOString(),
+    nextRunAtEpoch: Math.floor(utcMs / 1000),
+    scheduledTimeLocal: "09:00",
+    scheduledDateLocal: `${year}-${pad(month)}-${pad(day)}`,
+  };
+}
+
 async function handleCreateTask(
   supabase: SupabaseClient,
   userId: string,
   resolveAgent: (id?: string) => Promise<string | null>,
   params: Record<string, unknown>,
-  timezone: string = "Asia/Jakarta",
+  fallbackTimezone: string = "Asia/Jakarta",
 ): Promise<ToolResult> {
   try {
     if (!params.title) return err("Missing required field: title");
@@ -471,6 +604,11 @@ async function handleCreateTask(
     const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const now = new Date().toISOString();
 
+    // BUG 5 fix: resolve user's IANA timezone from their profile row. Plugin
+    // config default is only used when the profile row is missing/unset.
+    const timezone = await loadUserTimezone(supabase, userId, fallbackTimezone);
+    const TZ_OFFSET_HOURS = getTimezoneOffsetHours(timezone);
+
     // Handle explicit "none"/"unassigned"
     const rawAgentId = params.agent_id as string | undefined;
     const isUnassigned =
@@ -576,6 +714,17 @@ async function handleCreateTask(
       }
     }
 
+    // BUG 5 fix (cycle 7b BUGSHOOT-2): normalize start_date BEFORE the INSERT
+    // so DB and tool-response carry the SAME canonical UTC ISO. Old code
+    // INSERTed the raw input then reassigned insertData.start_date afterward,
+    // which left the DB row with the unconverted value and the response with
+    // the converted one — confusing and unsafe for the scheduler.
+    const rawStartDate = (params.start_date as string) || null;
+    const normalized = rawStartDate
+      ? normalizeStartDate(rawStartDate, params.scheduled_time as string | undefined, TZ_OFFSET_HOURS)
+      : null;
+    const canonicalStartDate = normalized?.startDateUTC ?? rawStartDate;
+
     const insertData: Record<string, unknown> = {
       id,
       user_id: userId,
@@ -588,8 +737,8 @@ async function handleCreateTask(
       priority: params.priority !== undefined ? params.priority : 1,
       space_id: resolvedSpaceId,
       folder_id: resolvedFolderId,
-      start_date: (params.start_date as string) || null,
-      due_date: (params.due_date as string) || (params.start_date as string) || null,
+      start_date: canonicalStartDate,
+      due_date: (params.due_date as string) || canonicalStartDate || null,
       tags: (params.tags as string[]) || [],
       progress: 0,
       sort_order: 0,
@@ -615,98 +764,15 @@ 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;
+    // start_date is already normalized above. Scheduler event uses the same
+    // canonical UTC ISO + the local-clock components for the dashboard UI.
+    const startDate = rawStartDate;
     const effectiveAgentId = (insertData.agent_id as string) || assignee;
-
-    // Resolve timezone offset from IANA timezone string (configurable per user)
-    const getTimezoneOffsetHours = (tz: string): number => {
-      try {
-        const now = new Date();
-        const utcStr = now.toLocaleString('en-US', { timeZone: 'UTC' });
-        const tzStr = now.toLocaleString('en-US', { timeZone: tz });
-        const diffMs = new Date(tzStr).getTime() - new Date(utcStr).getTime();
-        return Math.round(diffMs / 3600000);
-      } catch {
-        return 7; // Fallback to WIB (UTC+7)
-      }
-    };
-    const TZ_OFFSET_HOURS = getTimezoneOffsetHours(timezone);
-    if (startDate && effectiveAgentId) {
+    if (startDate && effectiveAgentId && normalized) {
       try {
-        // Parse start_date robustly — it can be:
-        //   "2026-04-19"                    (date only)
-        //   "2026-04-19T18:45:00"           (local datetime)
-        //   "2026-04-19 11:45:00+00"        (Supabase timestamptz)
-        //   "2026-04-19T11:45:00.000Z"      (ISO UTC)
-        const parsedDate = new Date(startDate);
-        const explicitScheduledTime = params.scheduled_time as string | undefined;
-
-        let nextRunAtEpoch: number;
-        let scheduledTimeFinal: string;
-        let scheduledDateFinal: string;
-
-        if (!isNaN(parsedDate.getTime())) {
-          // Valid date — check if it includes a meaningful time component
-          const hasTimeInfo = /[T ]\d{2}:\d{2}/.test(startDate);
-
-          if (explicitScheduledTime) {
-            // Agent explicitly passed a scheduled_time — treat as user’s local time
-            const dateStr = parsedDate.toISOString().split("T")[0]; // YYYY-MM-DD
-            const [localH, localM] = explicitScheduledTime.split(":").map(Number);
-            const utcH = localH - TZ_OFFSET_HOURS;
-            const dt = new Date(`${dateStr}T00:00:00Z`);
-            dt.setUTCHours(utcH, localM, 0, 0);
-            nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-            scheduledTimeFinal = explicitScheduledTime; // Store as user's local time
-            scheduledDateFinal = dateStr;
-            // Normalize start_date to ISO UTC for consistent downstream parsing
-            insertData.start_date = dt.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
-            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 - TZ_OFFSET_HOURS, localM, 0, 0);
-              nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-              scheduledTimeFinal = `${String(localH).padStart(2, "0")}:${String(localM).padStart(2, "0")}`;
-              scheduledDateFinal = dateStr;
-              // Normalize start_date to ISO UTC
-              insertData.start_date = dt.toISOString();
-            } 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 user local time
-            const dateStr = parsedDate.toISOString().split("T")[0];
-            const dt = new Date(`${dateStr}T00:00:00Z`);
-            dt.setUTCHours(9 - TZ_OFFSET_HOURS, 0, 0, 0); // 09:00 local = UTC - offset
-            nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-            scheduledTimeFinal = "09:00"; // Stored as user's local time
-            scheduledDateFinal = dateStr;
-            // Normalize start_date to ISO UTC
-            insertData.start_date = dt.toISOString();
-          }
-        } else {
-          // Unparseable date — fallback to now + 60s
-          nextRunAtEpoch = Math.floor(Date.now() / 1000) + 60;
-          scheduledTimeFinal = "00:00";
-          scheduledDateFinal = new Date().toISOString().split("T")[0];
-        }
-
-        // Safety net: if computed time is in the past, schedule for now + 60s
+        let { nextRunAtEpoch } = normalized;
         const nowEpoch = Math.floor(Date.now() / 1000);
+        // Safety net: if computed time is in the past, schedule for now + 60s
         if (nextRunAtEpoch <= nowEpoch) {
           nextRunAtEpoch = nowEpoch + 60;
         }
@@ -719,8 +785,8 @@ async function handleCreateTask(
           subagent_id: subagentId,
           title: params.title,
           description: (params.description as string) || (params.instructions as string) || null,
-          scheduled_date: scheduledDateFinal,
-          scheduled_time: scheduledTimeFinal,
+          scheduled_date: normalized.scheduledDateLocal,
+          scheduled_time: normalized.scheduledTimeLocal,
           duration_minutes: 30,
           recurrence_type: (params.recurrence_type as string) || "none",
           recurrence_interval: (params.recurrence_interval as number) || 1,
@@ -5387,14 +5453,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}` });
@@ -6536,7 +6624,24 @@ function registerBrainExtractionHook(
         // scoped memory note ("Staff X reported on task Y: ...") and POST a
         // webhook so the dashboard can surface the report. The staff itself
         // gets no memory entry (req 3 — staff has no memory of its own).
-        const staffDispatchSubagentId = readDispatchSubagentId(ctx, event);
+        //
+        // Cycle 7b BUGSHOOT-2 (BUG 7) — metadata path is dead since BUG 2 made
+        // the dispatcher stop sending `metadata` on chat.send. Fall back to
+        // the dispatch_context row keyed by sessionKey before giving up.
+        let staffDispatchSubagentId = readDispatchSubagentId(ctx, event);
+        let dispatchCtxRow: DispatchContextRow | null = null;
+        let dispatchTaskIdFromCtx: string | null = null;
+        let dispatchConversationIdFromCtx: string | null = null;
+        if (sessionKey) {
+          dispatchCtxRow = await loadDispatchContextBySession(supabase, userId, sessionKey).catch(() => null);
+          if (dispatchCtxRow) {
+            if (!staffDispatchSubagentId && dispatchCtxRow.subagent_id) {
+              staffDispatchSubagentId = dispatchCtxRow.subagent_id;
+            }
+            dispatchTaskIdFromCtx = dispatchCtxRow.task_id;
+            dispatchConversationIdFromCtx = dispatchCtxRow.conversation_id;
+          }
+        }
         if (staffDispatchSubagentId) {
           (async () => {
             try {
@@ -6549,9 +6654,12 @@ function registerBrainExtractionHook(
                 api.logger.warn?.(`[ofiere-staff-report] chief_mismatch (subagent ${staffDispatchSubagentId} reports to ${staff.chief_agent_id}, run was on ${resolvedAgentId}) — skipping report`);
                 return;
               }
+              // BUG 7 fix (BUGSHOOT-2): include dispatch_context.task_id as a
+              // fallback now that metadata is dead on the wire.
               const taskId =
                 ctx?.metadata?.task_id || ctx?.metadata?.dispatch?.task_id ||
-                event?.metadata?.task_id || event?.context?.metadata?.task_id || null;
+                event?.metadata?.task_id || event?.context?.metadata?.task_id ||
+                dispatchTaskIdFromCtx || null;
               const excerpt = lastAssistant.slice(0, 1500);
               const reportBody = taskId
                 ? `Staff ${staff.name}${staff.role ? ` (${staff.role})` : ""} reported on task ${taskId}:\n\n${excerpt}`
@@ -6567,6 +6675,54 @@ function registerBrainExtractionHook(
               });
               api.logger.info?.(`[ofiere-staff-report] memory written for chief ${staff.chief_agent_id} from staff ${staff.name}`);
 
+              // BUG 9 fix (BUGSHOOT-2): mark task_dispatch_log row complete
+              // with the assistant's response preview. Without this the log
+              // stays at status='dispatched' forever, breaking dashboard
+              // dispatch-history views and audit trails.
+              if (taskId) {
+                try {
+                  await supabase.from("task_dispatch_log")
+                    .update({
+                      status: "completed",
+                      response_preview: excerpt.slice(0, 500),
+                      completed_at: new Date().toISOString(),
+                    })
+                    .eq("task_id", taskId)
+                    .eq("status", "dispatched");
+                } catch (logErr) {
+                  api.logger.debug?.(`[ofiere-staff-report] dispatch_log update failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+                }
+              }
+
+              // BUG 6 fix (BUGSHOOT-2): mirror the assistant turn into the
+              // dashboard's hidden conversation_messages so the dashboard can
+              // render staff-run history. Dispatcher pre-created the
+              // conversations row and stamped its id on dispatch_context.
+              if (dispatchConversationIdFromCtx) {
+                try {
+                  await supabase.from("conversation_messages").insert({
+                    conversation_id: dispatchConversationIdFromCtx,
+                    user_id: userId,
+                    role: "user",
+                    content: lastUser.slice(0, 4000),
+                    created_at: new Date(Date.now() - 1000).toISOString(),
+                  });
+                  await supabase.from("conversation_messages").insert({
+                    conversation_id: dispatchConversationIdFromCtx,
+                    user_id: userId,
+                    role: "assistant",
+                    content: excerpt,
+                    created_at: new Date().toISOString(),
+                  });
+                  await supabase.from("conversations")
+                    .update({ updated_at: new Date().toISOString() })
+                    .eq("id", dispatchConversationIdFromCtx)
+                    .eq("user_id", userId);
+                } catch (cmErr) {
+                  api.logger.debug?.(`[ofiere-staff-report] conversation_messages insert failed: ${cmErr instanceof Error ? cmErr.message : String(cmErr)}`);
+                }
+              }
+
               // Best-effort webhook to dashboard (existing OPENCLAW_WEBHOOK_SECRET).
               const webhookUrl = process.env.OFIERE_DASHBOARD_WEBHOOK_URL || "";
               const webhookSecret = process.env.OPENCLAW_WEBHOOK_SECRET || "";
@@ -6602,6 +6758,24 @@ function registerBrainExtractionHook(
           return;
         }
 
+        // BUG 9 fix (BUGSHOOT-2): mark task_dispatch_log row complete for
+        // non-staff scheduled dispatches too. Without this the log row stays
+        // at 'dispatched' even after the chief finished the run.
+        if (dispatchTaskIdFromCtx) {
+          try {
+            await supabase.from("task_dispatch_log")
+              .update({
+                status: "completed",
+                response_preview: lastAssistant.slice(0, 500),
+                completed_at: new Date().toISOString(),
+              })
+              .eq("task_id", dispatchTaskIdFromCtx)
+              .eq("status", "dispatched");
+          } catch (logErr) {
+            api.logger.debug?.(`[ofiere-brain] dispatch_log update failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+          }
+        }
+
         // ── Fast Stream: Write L1_focus + L2_episode in parallel ──
         const rawContent = `User: ${lastUser}\nAssistant: ${lastAssistant}`;
         const immediateWrites: PromiseLike<any>[] = [];