ofiere-openclaw-plugin 4.52.0 → 4.54.0

package/src/tools.ts

@@ -271,7 +271,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, subagent_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` +
+      `- "create": Create a task in DRAFT mode. Required: title. Optional: agent_id, subagent_id, description, status, priority, space_id, folder_id, start_date, due_date, dispatch_immediately, tags, instructions, execution_plan, goals, constraints, system_prompt, recurrence_type, recurrence_interval, scheduled_time. ⚠️ EXECUTION SEMANTICS: omit start_date → task sits in agent's task list as draft (does NOT run). Set start_date to schedule. Pass dispatch_immediately:true to run now. ⚠️ 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 + subagent_id\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` +
@@ -317,8 +317,12 @@ function registerTaskOps(
         progress: { type: "number", description: "Progress percentage 0-100 (update only)" },
         space_id: { type: "string", description: "PM Space ID" },
         folder_id: { type: "string", description: "PM Folder ID" },
-        start_date: { type: "string", description: "Start date (ISO 8601). Required for scheduled/recurring tasks." },
+        start_date: { type: "string", description: "Start date (ISO 8601). Required for scheduled/recurring tasks. Omit to create as draft." },
         due_date: { type: "string", description: "Due date (ISO 8601)" },
+        dispatch_immediately: {
+          type: "boolean",
+          description: "When true and start_date is not provided, sets start_date to NOW so the task dispatches on the next cron tick. Default: false (task is created as draft and waits for an explicit start_date).",
+        },
         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",
@@ -749,15 +753,17 @@ async function handleCreateTask(
     // which left the DB row with the unconverted value and the response with
     // the converted one — confusing and unsafe for the scheduler.
     //
-    // Cycle 12 fix: when delegating to a staff (subagent_id present) without
-    // an explicit start_date, default to now + 5s so the scheduler_event auto-
-    // create branch below kicks in. Without this, the task sat PENDING forever
-    // because processDirectTasks' date-string filter also skips it (separate
-    // bug, fixed in task-dispatcher v21). The 5s buffer ensures the safety
-    // net at line ~805 doesn't trip and shift the run to +60s.
+    // Cycle 13 (BUG 3+4): create is a DRAFT operation, NOT a dispatch trigger.
+    // No start_date → rawStartDate stays null → no scheduler_event auto-insert
+    // → task sits in agent's task list as draft. To execute, caller must pass
+    // an explicit start_date OR set dispatch_immediately:true (which we then
+    // resolve to "now" ISO here). Cycle 12's silent +5s default for staff
+    // delegation is REMOVED — it turned create into an unsafe execution
+    // trigger and bypassed the chief's approval flow.
     const explicitStartDate = (params.start_date as string) || null;
+    const dispatchNow = params.dispatch_immediately === true;
     const rawStartDate = explicitStartDate
-      ?? (params.subagent_id ? new Date(Date.now() + 5_000).toISOString() : null);
+      ?? (dispatchNow ? new Date().toISOString() : null);
     const normalized = rawStartDate
       ? normalizeStartDate(rawStartDate, params.scheduled_time as string | undefined, TZ_OFFSET_HOURS)
       : null;
@@ -896,7 +902,16 @@ async function handleUpdateTask(
     for (const f of fields) {
       if (params[f] !== undefined) updates[f] = params[f];
     }
-    if (params.status === "DONE") updates.completed_at = new Date().toISOString();
+    // Cycle 13 (BUG 2): keep status and completed_at consistent. Setting status
+    // to DONE stamps completed_at + progress=100. Setting status to anything
+    // other than DONE clears completed_at so the row never carries the
+    // "PENDING + completed_at" contradiction the dashboard reported.
+    if (params.status === "DONE") {
+      updates.completed_at = new Date().toISOString();
+      if (params.progress === undefined) updates.progress = 100;
+    } else if (typeof params.status === "string") {
+      updates.completed_at = null;
+    }
 
     // ── Subagent + chief invariant ───────────────────────────────────────
     // Mirrors dashboard PATCH: chief change without explicit subagent_id
@@ -2941,13 +2956,72 @@ async function generatePMReportDirect(
   lines.push("");
   lines.push(`💡 Reply "details on #N" for full task result`);
 
+  // Cycle 13 (BUG 1): render the "Generated" stamp in the user's IANA TZ
+  // (from profiles.timezone) instead of UTC. The plugin can't import
+  // dashboard helpers, so this uses Intl.DateTimeFormat directly.
+  const userTz = await loadUserTimezoneForPlugin(supabase, userId);
   const now = new Date();
   lines.push("");
-  lines.push(`Generated: ${now.toISOString().replace("T", " ").slice(0, 16)} UTC`);
+  lines.push(`Generated: ${formatInUserTzInline(now, userTz)}`);
 
   return { report: lines.join("\n"), scopeLabel, taskCount: all.length };
 }
 
+// ─── Plugin-local TZ helpers (Cycle 13, BUG 1) ──────────────────────────────
+// Mirror dashboard/lib/tz.ts; kept inline because the plugin is a separate
+// npm package loaded directly by the OpenClaw gateway and cannot import from
+// the dashboard.
+
+const PLUGIN_FALLBACK_TZ = "Asia/Jakarta";
+
+async function loadUserTimezoneForPlugin(
+  supabase: SupabaseClient,
+  userId: string,
+): Promise<string> {
+  if (!userId) return PLUGIN_FALLBACK_TZ;
+  try {
+    const { data } = await supabase
+      .from("profiles")
+      .select("timezone")
+      .eq("id", userId)
+      .maybeSingle();
+    const tz = ((data as any)?.timezone as string | undefined)?.trim();
+    return tz && isValidIanaZoneInline(tz) ? tz : PLUGIN_FALLBACK_TZ;
+  } catch {
+    return PLUGIN_FALLBACK_TZ;
+  }
+}
+
+function formatInUserTzInline(date: Date, timezone: string): string {
+  if (Number.isNaN(date.getTime())) return "";
+  const tz = isValidIanaZoneInline(timezone) ? timezone : PLUGIN_FALLBACK_TZ;
+  try {
+    const fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZoneName: "short",
+    });
+    return fmt.format(date).replace(", ", " ");
+  } catch {
+    return date.toISOString();
+  }
+}
+
+function isValidIanaZoneInline(tz: string | undefined | null): boolean {
+  if (!tz) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz }).format(new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function dispatchReportDirect(
   supabase: SupabaseClient,
   userId: string,
@@ -6525,6 +6599,453 @@ function registerTalentContextHook(
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 17: OFIERE_OFFICE_OPS — Agent Office Canvas (widget dashboard)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function emitOfficeWebhook(
+  api: any,
+  type: "office_update" | "office_data_update",
+  payload: Record<string, unknown>,
+): Promise<void> {
+  const webhookUrl = process.env.OFIERE_DASHBOARD_WEBHOOK_URL || "";
+  const webhookSecret = process.env.OPENCLAW_WEBHOOK_SECRET || "";
+  if (!webhookUrl || !webhookSecret) return;
+  try {
+    await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${webhookSecret}`,
+      },
+      body: JSON.stringify({ type, payload }),
+    });
+  } catch (wErr) {
+    api.logger.debug?.(`[ofiere-office] webhook post failed: ${wErr instanceof Error ? wErr.message : String(wErr)}`);
+  }
+}
+
+function validateSection(s: any): string | null {
+  if (!s || typeof s !== "object") return "section is not an object";
+  if (typeof s.title !== "string" || !s.title) return "section.title required";
+  if (typeof s.order !== "number") return "section.order must be a number";
+  if (!Array.isArray(s.widgets)) return "section.widgets must be an array";
+  for (const w of s.widgets) {
+    const wErr = validateWidget(w);
+    if (wErr) return `section "${s.title}": ${wErr}`;
+  }
+  return null;
+}
+
+function validateWidget(w: any): string | null {
+  if (!w || typeof w !== "object") return "widget is not an object";
+  if (typeof w.type !== "string" || !w.type) return "widget.type required";
+  if (typeof w.config !== "object" || w.config === null) return "widget.config must be an object";
+  const ly = w.layout;
+  if (!ly || typeof ly !== "object") return "widget.layout required";
+  if (typeof ly.x !== "number" || typeof ly.y !== "number" || typeof ly.w !== "number" || typeof ly.h !== "number") {
+    return "widget.layout must have numeric x, y, w, h";
+  }
+  return null;
+}
+
+function shortId(prefix: string): string {
+  return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function registerOfficeOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
+  api.registerTool((toolCtx: any) => ({
+    name: "OFIERE_OFFICE_OPS",
+    label: "Ofiere Office Operations",
+    description:
+      `Build and update your department Office — a widget-based dashboard canvas bound to a PM Space.\n\n` +
+      `Actions:\n` +
+      `- "get_office": Load the current layout + widget data for a given (space_id, agent_id). Optional: space_id, agent_id.\n` +
+      `- "build_office": One-time initial build. Required: space_id, sections. Only callable while the office row is in 'initializing' state.\n` +
+      `- "update_widgets": Modify the layout (add/remove/replace/patch widgets or sections). Required: office_id, operations. Locked items are skipped (returns warnings).\n` +
+      `- "update_widget_data": Push fresh data for a single widget. Required: office_id, widget_id, data. Always succeeds regardless of lock state — locks protect layout, not data.\n\n` +
+      `Layout shape:\n` +
+      `  { version: 1, sections: [ { id, title, description?, order, locked?, collapsed?, columns, widgets: [ { id, type, config, layout: {x,y,w,h}, locked?, data_source? } ] } ] }\n\n` +
+      `Widget catalog (the dashboard knows which types exist): kpi_card, bar_chart, line_chart, donut_chart, progress_bar, sparkline, heatmap, data_table, activity_feed, report_card, status_list, checklist, text_block, embed, quick_action, file_browser, staff_roster.\n\n` +
+      `Operation shape (RFC-6902 flavored): { op: 'add'|'remove'|'replace'|'patch', path: '/sections/0/widgets/-' or '/sections/0/widgets/0', value?, widget?, config? }`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          description: "get_office, build_office, update_widgets, update_widget_data",
+        },
+        space_id: { type: "string", description: "PM space UUID" },
+        agent_id: { type: "string", description: "Agent identifier (defaults to calling agent)" },
+        office_id: { type: "string", description: "Office row UUID" },
+        widget_id: { type: "string", description: "Widget short id" },
+        sections: { type: "array", description: "Initial layout sections (build_office only)" },
+        operations: { type: "array", description: "Patch operations (update_widgets only)" },
+        data: { type: "object", description: "Widget data payload (update_widget_data only)" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      const ctxAgentHint = toolCtx?.agentAccountId || toolCtx?.agentId || "";
+
+      async function resolveCallingAgent(explicitId?: string): Promise<string | null> {
+        if (explicitId && explicitId.trim()) return resolveAgent(explicitId);
+        if (ctxAgentHint) return resolveAgent(ctxAgentHint);
+        return resolveAgent();
+      }
+
+      switch (action) {
+        case "get_office": {
+          const agentId = await resolveCallingAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          let q = supabase
+            .from("agent_office_layouts")
+            .select("id, space_id, agent_id, status, is_finalized, layout, last_agent_update_at, error_message, updated_at")
+            .eq("user_id", userId)
+            .eq("agent_id", agentId);
+          if (params.space_id) q = q.eq("space_id", params.space_id as string);
+
+          const { data: rows, error } = await q.limit(1);
+          if (error) return err(error.message);
+          if (!rows || rows.length === 0) return err("No office found for this agent");
+
+          const office = rows[0];
+          const { data: widgetData } = await supabase
+            .from("agent_office_data")
+            .select("widget_id, data, updated_at")
+            .eq("user_id", userId)
+            .eq("office_id", office.id);
+
+          const dataMap: Record<string, any> = {};
+          for (const row of widgetData || []) {
+            dataMap[row.widget_id] = row.data;
+          }
+
+          return ok({ office, widget_data: dataMap });
+        }
+
+        case "build_office": {
+          if (!params.space_id) return err("Missing required: space_id");
+          if (!Array.isArray(params.sections)) return err("Missing required: sections (array)");
+
+          const agentId = await resolveCallingAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const inputSections = params.sections as any[];
+          for (let i = 0; i < inputSections.length; i++) {
+            const sErr = validateSection(inputSections[i]);
+            if (sErr) return err(`Validation failed at section[${i}]: ${sErr}`);
+          }
+
+          const { data: existing, error: loadErr } = await supabase
+            .from("agent_office_layouts")
+            .select("id, status")
+            .eq("user_id", userId)
+            .eq("space_id", params.space_id as string)
+            .eq("agent_id", agentId)
+            .maybeSingle();
+
+          if (loadErr) return err(`Office lookup failed: ${loadErr.message}`);
+          if (!existing) return err("Office row not found — dashboard must call /api/office/initialize first");
+          if (existing.status !== "initializing") {
+            return err(`Office already built (status=${existing.status}). Use update_widgets to modify.`);
+          }
+
+          const normalized = inputSections.map((s, idx) => {
+            const widgets = (s.widgets || []).map((w: any) => ({
+              id: typeof w.id === "string" && w.id ? w.id : shortId("wgt"),
+              type: w.type,
+              config: w.config || {},
+              layout: {
+                x: w.layout.x,
+                y: w.layout.y,
+                w: w.layout.w,
+                h: w.layout.h,
+                minW: w.layout.minW,
+                minH: w.layout.minH,
+                maxW: w.layout.maxW,
+                maxH: w.layout.maxH,
+              },
+              locked: w.locked === true,
+              data_source: w.data_source || { type: "agent", refresh_interval: 3600, last_refreshed_at: null },
+            }));
+            return {
+              id: typeof s.id === "string" && s.id ? s.id : shortId("sec"),
+              title: s.title,
+              description: s.description,
+              order: typeof s.order === "number" ? s.order : idx,
+              locked: s.locked === true,
+              collapsed: s.collapsed === true,
+              columns: typeof s.columns === "number" ? s.columns : 3,
+              widgets,
+            };
+          });
+
+          const layout = { version: 1, sections: normalized };
+
+          const { error: updateErr } = await supabase
+            .from("agent_office_layouts")
+            .update({
+              layout,
+              status: "active",
+              last_agent_update_at: new Date().toISOString(),
+              updated_at: new Date().toISOString(),
+            })
+            .eq("id", existing.id)
+            .eq("user_id", userId);
+
+          if (updateErr) return err(`Office save failed: ${updateErr.message}`);
+
+          const dataRows = normalized.flatMap((s: any) =>
+            s.widgets.map((w: any) => ({
+              user_id: userId,
+              office_id: existing.id,
+              widget_id: w.id,
+              data: {},
+            })),
+          );
+
+          if (dataRows.length > 0) {
+            const { error: dataErr } = await supabase
+              .from("agent_office_data")
+              .upsert(dataRows, { onConflict: "office_id,widget_id" });
+            if (dataErr) {
+              api.logger.warn?.(`[ofiere-office] widget_data seed failed: ${dataErr.message}`);
+            }
+          }
+
+          await emitOfficeWebhook(api, "office_update", {
+            user_id: userId,
+            office_id: existing.id,
+            agent_id: agentId,
+          });
+
+          return ok({
+            message: `Office built with ${normalized.length} sections and ${dataRows.length} widgets`,
+            office_id: existing.id,
+            section_count: normalized.length,
+            widget_count: dataRows.length,
+          });
+        }
+
+        case "update_widgets": {
+          if (!params.office_id) return err("Missing required: office_id");
+          if (!Array.isArray(params.operations)) return err("Missing required: operations (array)");
+          const operations = params.operations as any[];
+
+          const agentId = await resolveCallingAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const { data: office, error: loadErr } = await supabase
+            .from("agent_office_layouts")
+            .select("id, layout, is_finalized, agent_id")
+            .eq("id", params.office_id as string)
+            .eq("user_id", userId)
+            .eq("agent_id", agentId)
+            .maybeSingle();
+
+          if (loadErr) return err(loadErr.message);
+          if (!office) return err("Office not found or not owned by this agent");
+
+          const layout: any = office.layout || { version: 1, sections: [] };
+          const sections: any[] = Array.isArray(layout.sections) ? [...layout.sections] : [];
+          const warnings: string[] = [];
+          const newSeedDataRows: { widget_id: string }[] = [];
+          let applied = 0;
+          let skipped = 0;
+
+          for (let i = 0; i < operations.length; i++) {
+            const op = operations[i];
+            const path: string = op?.path || "";
+            const opType: string = op?.op || "";
+
+            const m = path.match(/^\/sections\/(\d+)(?:\/widgets\/(-|\d+))?(?:\/config)?$/);
+            if (!m) {
+              warnings.push(`op[${i}]: unsupported path "${path}"`);
+              skipped++;
+              continue;
+            }
+
+            const sIdx = parseInt(m[1], 10);
+            const wTok = m[2];
+            const isConfig = path.endsWith("/config");
+
+            if (Number.isNaN(sIdx) || sIdx < 0 || sIdx >= sections.length) {
+              warnings.push(`op[${i}]: section index ${sIdx} out of range`);
+              skipped++;
+              continue;
+            }
+            const section = sections[sIdx];
+            if (section.locked) {
+              warnings.push(`op[${i}]: section "${section.title}" is locked`);
+              skipped++;
+              continue;
+            }
+
+            if (wTok === undefined) {
+              if (opType === "remove") {
+                sections.splice(sIdx, 1);
+                applied++;
+                continue;
+              }
+              if (opType === "replace" && op.value) {
+                const sErr = validateSection(op.value);
+                if (sErr) { warnings.push(`op[${i}]: ${sErr}`); skipped++; continue; }
+                sections[sIdx] = { ...op.value, id: section.id };
+                applied++;
+                continue;
+              }
+              warnings.push(`op[${i}]: section-level op "${opType}" not supported (use replace/remove)`);
+              skipped++;
+              continue;
+            }
+
+            if (wTok === "-") {
+              if (opType !== "add") {
+                warnings.push(`op[${i}]: path "/widgets/-" requires op=add`);
+                skipped++;
+                continue;
+              }
+              const w = op.widget || op.value;
+              const wErr = validateWidget(w);
+              if (wErr) { warnings.push(`op[${i}]: ${wErr}`); skipped++; continue; }
+              const newW = {
+                id: typeof w.id === "string" && w.id ? w.id : shortId("wgt"),
+                type: w.type,
+                config: w.config || {},
+                layout: { ...w.layout },
+                locked: w.locked === true,
+                data_source: w.data_source || { type: "agent", refresh_interval: 3600, last_refreshed_at: null },
+              };
+              section.widgets = [...(section.widgets || []), newW];
+              newSeedDataRows.push({ widget_id: newW.id });
+              applied++;
+              continue;
+            }
+
+            const wIdx = parseInt(wTok, 10);
+            if (Number.isNaN(wIdx) || wIdx < 0 || wIdx >= (section.widgets || []).length) {
+              warnings.push(`op[${i}]: widget index ${wIdx} out of range`);
+              skipped++;
+              continue;
+            }
+            const widget = section.widgets[wIdx];
+            if (widget.locked) {
+              warnings.push(`op[${i}]: widget "${widget.id}" is locked`);
+              skipped++;
+              continue;
+            }
+
+            if (opType === "remove") {
+              section.widgets.splice(wIdx, 1);
+              applied++;
+            } else if (opType === "replace" && op.value) {
+              const wErr = validateWidget(op.value);
+              if (wErr) { warnings.push(`op[${i}]: ${wErr}`); skipped++; continue; }
+              section.widgets[wIdx] = { ...op.value, id: widget.id };
+              applied++;
+            } else if ((opType === "patch" || (opType === "replace" && isConfig)) && op.config) {
+              section.widgets[wIdx] = { ...widget, config: { ...widget.config, ...op.config } };
+              applied++;
+            } else {
+              warnings.push(`op[${i}]: widget-level op "${opType}" not handled`);
+              skipped++;
+            }
+          }
+
+          const newLayout = { ...layout, sections };
+
+          const { error: saveErr } = await supabase
+            .from("agent_office_layouts")
+            .update({
+              layout: newLayout,
+              last_agent_update_at: new Date().toISOString(),
+              updated_at: new Date().toISOString(),
+            })
+            .eq("id", office.id)
+            .eq("user_id", userId);
+
+          if (saveErr) return err(`Office save failed: ${saveErr.message}`);
+
+          if (newSeedDataRows.length > 0) {
+            const seedRows = newSeedDataRows.map((r) => ({
+              user_id: userId,
+              office_id: office.id,
+              widget_id: r.widget_id,
+              data: {},
+            }));
+            await supabase
+              .from("agent_office_data")
+              .upsert(seedRows, { onConflict: "office_id,widget_id" });
+          }
+
+          await emitOfficeWebhook(api, "office_update", {
+            user_id: userId,
+            office_id: office.id,
+            agent_id: agentId,
+          });
+
+          return ok({ applied, skipped, warnings });
+        }
+
+        case "update_widget_data": {
+          if (!params.office_id) return err("Missing required: office_id");
+          if (!params.widget_id) return err("Missing required: widget_id");
+          if (typeof params.data !== "object" || params.data === null) return err("Missing required: data (object)");
+
+          const agentId = await resolveCallingAgent(params.agent_id as string);
+          if (!agentId) return err("Could not resolve agent_id");
+
+          const { data: office, error: loadErr } = await supabase
+            .from("agent_office_layouts")
+            .select("id")
+            .eq("id", params.office_id as string)
+            .eq("user_id", userId)
+            .eq("agent_id", agentId)
+            .maybeSingle();
+
+          if (loadErr) return err(loadErr.message);
+          if (!office) return err("Office not found or not owned by this agent");
+
+          const { error: upsertErr } = await supabase
+            .from("agent_office_data")
+            .upsert(
+              {
+                user_id: userId,
+                office_id: office.id,
+                widget_id: params.widget_id as string,
+                data: params.data,
+                updated_at: new Date().toISOString(),
+              },
+              { onConflict: "office_id,widget_id" },
+            );
+
+          if (upsertErr) return err(`Widget data save failed: ${upsertErr.message}`);
+
+          await emitOfficeWebhook(api, "office_data_update", {
+            user_id: userId,
+            office_id: office.id,
+            agent_id: agentId,
+            widget_id: params.widget_id,
+          });
+
+          return ok({ message: `Widget ${params.widget_id} data updated` });
+        }
+
+        default:
+          return err(`Unknown action: ${action}. Use get_office, build_office, update_widgets, update_widget_data.`);
+      }
+    },
+  }));
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -6557,7 +7078,8 @@ export function registerTools(
   registerSOPOps(api, supabase, userId, resolveAgent);        // 13
   registerBrainOps(api, supabase, userId, resolveAgent);      // 14
   registerTalentOps(api, supabase, userId);                   // 15
-  registerFrameworkOps(api, supabase, userId, resolveAgent);   // 16
+  registerFrameworkOps(api, supabase, userId, resolveAgent);  // 16
+  registerOfficeOps(api, supabase, userId, resolveAgent);     // 17
 
   // ── Register dynamic brain context hook ──
   registerBrainContextHook(api, supabase, userId, fallbackAgentId);
@@ -6572,7 +7094,7 @@ export function registerTools(
   registerBrainExtractionHook(api, supabase, userId, fallbackAgentId);
 
   // ── Count and log ──
-  const toolCount = 16;
+  const toolCount = 17;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);
@@ -6752,6 +7274,53 @@ function registerBrainExtractionHook(
                 } catch (logErr) {
                   api.logger.debug?.(`[ofiere-staff-report] dispatch_log update failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
                 }
+
+                // Cycle 13 (BUG 2): flip the tasks row so the dashboard reflects
+                // execution outcome. Without this, tasks stay at PENDING/IN_PROGRESS
+                // forever and the proof-of-execution string lives only in
+                // task_dispatch_log.response_preview (invisible to PM views).
+                // Recurring tasks: stash output but leave status untouched so the
+                // next cron tick can re-fire. One-shot: mark DONE, set progress=100,
+                // stamp completed_at, persist proof in custom_fields.last_output.
+                try {
+                  const { data: schedRow } = await supabase
+                    .from("scheduler_events")
+                    .select("recurrence_type")
+                    .eq("task_id", taskId)
+                    .maybeSingle();
+                  const isRecurring = !!(schedRow?.recurrence_type && schedRow.recurrence_type !== "none");
+
+                  const { data: curTask } = await supabase
+                    .from("tasks")
+                    .select("custom_fields, status")
+                    .eq("id", taskId)
+                    .eq("user_id", userId)
+                    .maybeSingle();
+                  const cf = ((curTask?.custom_fields as Record<string, any>) ?? {}) as Record<string, any>;
+                  cf.last_output = excerpt;
+                  cf.last_completed_session = sessionKey ?? null;
+                  cf.last_run_at = new Date().toISOString();
+
+                  if (isRecurring) {
+                    await supabase.from("tasks")
+                      .update({ custom_fields: cf, updated_at: new Date().toISOString() })
+                      .eq("id", taskId)
+                      .eq("user_id", userId);
+                  } else if (curTask?.status !== "FAILED") {
+                    await supabase.from("tasks")
+                      .update({
+                        status: "DONE",
+                        completed_at: new Date().toISOString(),
+                        progress: 100,
+                        custom_fields: cf,
+                        updated_at: new Date().toISOString(),
+                      })
+                      .eq("id", taskId)
+                      .eq("user_id", userId);
+                  }
+                } catch (tErr) {
+                  api.logger.debug?.(`[ofiere-staff-report] tasks update failed: ${tErr instanceof Error ? tErr.message : String(tErr)}`);
+                }
               }
 
               // BUG 6 fix (BUGSHOOT-2): mirror the assistant turn into the
@@ -6834,6 +7403,51 @@ function registerBrainExtractionHook(
           } catch (logErr) {
             api.logger.debug?.(`[ofiere-brain] dispatch_log update failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
           }
+
+          // Cycle 13 (BUG 2): flip the tasks row for chief-direct (non-staff)
+          // dispatches too — same logic as the staff path above. Recurring
+          // tasks keep their status; one-shots flip to DONE with the proof
+          // string stored in custom_fields.last_output.
+          try {
+            const excerpt = lastAssistant.slice(0, 1500);
+            const { data: schedRow } = await supabase
+              .from("scheduler_events")
+              .select("recurrence_type")
+              .eq("task_id", dispatchTaskIdFromCtx)
+              .maybeSingle();
+            const isRecurring = !!(schedRow?.recurrence_type && schedRow.recurrence_type !== "none");
+
+            const { data: curTask } = await supabase
+              .from("tasks")
+              .select("custom_fields, status")
+              .eq("id", dispatchTaskIdFromCtx)
+              .eq("user_id", userId)
+              .maybeSingle();
+            const cf = ((curTask?.custom_fields as Record<string, any>) ?? {}) as Record<string, any>;
+            cf.last_output = excerpt;
+            cf.last_completed_session = sessionKey ?? null;
+            cf.last_run_at = new Date().toISOString();
+
+            if (isRecurring) {
+              await supabase.from("tasks")
+                .update({ custom_fields: cf, updated_at: new Date().toISOString() })
+                .eq("id", dispatchTaskIdFromCtx)
+                .eq("user_id", userId);
+            } else if (curTask?.status !== "FAILED") {
+              await supabase.from("tasks")
+                .update({
+                  status: "DONE",
+                  completed_at: new Date().toISOString(),
+                  progress: 100,
+                  custom_fields: cf,
+                  updated_at: new Date().toISOString(),
+                })
+                .eq("id", dispatchTaskIdFromCtx)
+                .eq("user_id", userId);
+            }
+          } catch (tErr) {
+            api.logger.debug?.(`[ofiere-brain] tasks update failed: ${tErr instanceof Error ? tErr.message : String(tErr)}`);
+          }
         }
 
         // Cycle 7b BUGSHOOT-4 — trivial-skip moved here from line ~6593.