ofiere-openclaw-plugin 4.46.0 → 4.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.46.0",
+  "version": "4.48.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, loadDispatchContextBySession, resolveStaffModels, type SubagentRow, type DispatchContextRow } from "./staffPersona.js";
+import { loadSubagentRow, buildStaffPersonaBlock, readDispatchSubagentId, loadChiefStaffDefaults, loadChiefAgentConfig, loadDispatchContextBySession, resolveStaffModels, type SubagentRow, type DispatchContextRow } from "./staffPersona.js";
 
 interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
@@ -453,8 +453,11 @@ export function registerAttachmentContextHook(args: {
         if (subagentId) {
           staffRow = await loadSubagentRow(supabase, userId, subagentId);
           if (staffRow && staffRow.chief_agent_id === resolvedAgentId) {
-            const chiefDefaults = await loadChiefStaffDefaults(supabase, userId, staffRow.chief_agent_id).catch(() => null);
-            const resolved = resolveStaffModels(staffRow, chiefDefaults);
+            const [chiefDefaults, chiefConfig] = await Promise.all([
+              loadChiefStaffDefaults(supabase, userId, staffRow.chief_agent_id).catch(() => null),
+              loadChiefAgentConfig(supabase, userId, staffRow.chief_agent_id).catch(() => null),
+            ]);
+            const resolved = resolveStaffModels(staffRow, chiefDefaults, chiefConfig);
             staffPrefix = buildStaffPersonaBlock(staffRow, resolved) + "\n\n---\n\n";
             api.logger?.debug?.(
               `[ofiere-staff] subagent ${subagentId} (${staffRow.name}) reporting to ${resolvedAgentId} — persona injected; resolved models: ${JSON.stringify(resolved)}`,

package/src/staffPersona.ts

@@ -74,6 +74,7 @@ export interface DispatchContextRow {
   attached_sop_ids: string[];
   attached_framework_ids: string[];
   task_id: string | null;
+  conversation_id: string | null;
 }
 
 export async function loadDispatchContextBySession(
@@ -84,7 +85,7 @@ export async function loadDispatchContextBySession(
   if (!sessionKey) return null;
   const { data, error } = await supabase
     .from("dispatch_context")
-    .select("subagent_id, attached_sop_ids, attached_framework_ids, task_id")
+    .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 })
@@ -100,6 +101,7 @@ export async function loadDispatchContextBySession(
       ? (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,
   };
 }
 
@@ -125,7 +127,7 @@ export interface ResolvedStaffModels {
   tool_call_model: string | null;
   function_call_model: string | null;
   vision_model: string | null;
-  source: Record<StaffModelSlot, "staff" | "chief_default" | "chief_fallback" | null>;
+  source: Record<StaffModelSlot, "staff" | "chief_default" | "chief_primary" | "chief_fallback" | null>;
 }
 
 const SLOTS: StaffModelSlot[] = [
@@ -136,6 +138,17 @@ const SLOTS: StaffModelSlot[] = [
   "vision_model",
 ];
 
+// Cycle 7b BUGSHOOT-3 — chief's own ofie_agent_config row, used as the third
+// fallback tier when neither the staff slot nor the chief STAFF MODEL slot is
+// set. Mirrors the dispatcher's loadStaffPrimaryModel chain.
+export interface ChiefAgentConfigRow {
+  agent_id: string;
+  primary_model: string | null;
+  coding_model: string | null;
+  tool_call_model: string | null;
+  vision_model: string | null;
+}
+
 export async function loadChiefStaffDefaults(
   supabase: SupabaseClient,
   userId: string,
@@ -153,19 +166,42 @@ export async function loadChiefStaffDefaults(
   return data as ChiefStaffDefaultsRow;
 }
 
+export async function loadChiefAgentConfig(
+  supabase: SupabaseClient,
+  userId: string,
+  chiefAgentId: string,
+): Promise<ChiefAgentConfigRow | null> {
+  const { data, error } = await supabase
+    .from("ofie_agent_config")
+    .select("agent_id, primary_model, coding_model, tool_call_model, vision_model")
+    .eq("user_id", userId)
+    .eq("agent_id", chiefAgentId)
+    .maybeSingle();
+  if (error || !data) return null;
+  return data as ChiefAgentConfigRow;
+}
+
 /**
- * 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).
+ * Resolution chain at delegate_to_staff time (BUGSHOOT-3):
+ *   1. staff.<slot>                       (per-staff override)
+ *   2. chief_staff_defaults.<slot>        (chief-level STAFF MODEL)
+ *   3. ofie_agent_config.<slot>           (chief's OWN slot, NEW)
+ *   4. ofie_agent_config.primary_model    (chief's primary, last-resort sub)
+ *   5. null                               (gateway picks gateway default)
+ *
+ * Tier 3 was added in BUGSHOOT-3 because the prior chain stopped at tier 2 and
+ * relied on an implicit "gateway default" — which is opaque and led to BUG 10
+ * when the staff override held a model id the gateway rejected. With tier 3,
+ * an empty staff slot deterministically inherits the chief's actual model.
  *
- * The chief's own model is intentionally not touched. Empty staff slot +
- * empty chief STAFF MODEL = inherit chief's primary_model (gateway default).
+ * Tier 4 (slot → primary_model fallback) handles the common case where chief
+ * has only a primary_model set and no per-slot routing — a staff with
+ * coding_model blank still inherits chief's primary_model rather than null.
  */
 export function resolveStaffModels(
   staff: SubagentRow,
   chiefDefaults: ChiefStaffDefaultsRow | null,
+  chiefConfig?: ChiefAgentConfigRow | null,
 ): ResolvedStaffModels {
   const out: ResolvedStaffModels = {
     primary_model: null,
@@ -181,15 +217,26 @@ export function resolveStaffModels(
       vision_model: null,
     },
   };
+  const chiefPrimary = typeof chiefConfig?.primary_model === "string" && chiefConfig.primary_model.trim()
+    ? chiefConfig.primary_model.trim()
+    : 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;
+    const chiefSlotVal = chiefConfig ? (chiefConfig 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 if (chiefSlotVal && chiefSlotVal.trim()) {
+      out[slot] = chiefSlotVal;
+      out.source[slot] = "chief_primary";
+    } else if (chiefPrimary) {
+      // Sub-fallback: chief has a primary_model but no per-slot override.
+      out[slot] = chiefPrimary;
+      out.source[slot] = "chief_primary";
     } else {
       out[slot] = null;
       out.source[slot] = "chief_fallback";
@@ -223,8 +270,11 @@ export function buildStaffPersonaBlock(
     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 sourceLabel = (s: "staff" | "chief_default" | "chief_primary" | "chief_fallback" | null) =>
+      s === "staff" ? "per-staff override"
+      : s === "chief_default" ? "chief STAFF MODEL"
+      : s === "chief_primary" ? "chief's own model"
+      : "inherits chief (gateway default)";
     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)})`);

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,113 +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);
-          // 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
-            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 (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
-            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;
         }
@@ -734,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,
@@ -6573,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 {
@@ -6586,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}`
@@ -6604,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 || "";
@@ -6639,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>[] = [];