ofiere-openclaw-plugin 4.52.0 → 4.54.0

package/dist/src/tools.js

@@ -233,7 +233,7 @@ function registerTaskOps(api, supabase, userId, resolveAgent, timezone) {
             `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` +
@@ -279,8 +279,12 @@ function registerTaskOps(api, supabase, userId, resolveAgent, timezone) {
                 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",
@@ -666,15 +670,17 @@ async function handleCreateTask(supabase, userId, resolveAgent, params, fallback
         // 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 || 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, TZ_OFFSET_HOURS)
             : null;
@@ -807,8 +813,18 @@ async function handleUpdateTask(supabase, userId, params) {
             if (params[f] !== undefined)
                 updates[f] = params[f];
         }
-        if (params.status === "DONE")
+        // 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
         // clears any existing subagent assignment; subagent_id alone validates
@@ -2771,11 +2787,68 @@ async function generatePMReportDirect(supabase, userId, scopeType, scopeId, agen
     }
     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, userId) {
+    if (!userId)
+        return PLUGIN_FALLBACK_TZ;
+    try {
+        const { data } = await supabase
+            .from("profiles")
+            .select("timezone")
+            .eq("id", userId)
+            .maybeSingle();
+        const tz = data?.timezone?.trim();
+        return tz && isValidIanaZoneInline(tz) ? tz : PLUGIN_FALLBACK_TZ;
+    }
+    catch {
+        return PLUGIN_FALLBACK_TZ;
+    }
+}
+function formatInUserTzInline(date, timezone) {
+    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) {
+    if (!tz)
+        return false;
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tz }).format(new Date());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function dispatchReportDirect(supabase, userId, agentId, report, channelTypes) {
     // Query agent's active channel bindings
     let query = supabase.from("channel_bindings").select("channel_type, channel_account_id, agent_id, channel_config, thread_id")
@@ -6389,6 +6462,436 @@ function registerTalentContextHook(api, supabase, userId, fallbackAgentId) {
     }
 }
 // ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 17: OFIERE_OFFICE_OPS — Agent Office Canvas (widget dashboard)
+// ═══════════════════════════════════════════════════════════════════════════════
+async function emitOfficeWebhook(api, type, payload) {
+    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) {
+    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) {
+    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) {
+    return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function registerOfficeOps(api, supabase, userId, resolveAgent) {
+    api.registerTool((toolCtx) => ({
+        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, params) {
+            const action = params.action;
+            const ctxAgentHint = toolCtx?.agentAccountId || toolCtx?.agentId || "";
+            async function resolveCallingAgent(explicitId) {
+                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);
+                    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);
+                    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 = {};
+                    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);
+                    if (!agentId)
+                        return err("Could not resolve agent_id");
+                    const inputSections = params.sections;
+                    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)
+                        .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) => ({
+                            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) => s.widgets.map((w) => ({
+                        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;
+                    const agentId = await resolveCallingAgent(params.agent_id);
+                    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)
+                        .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 = office.layout || { version: 1, sections: [] };
+                    const sections = Array.isArray(layout.sections) ? [...layout.sections] : [];
+                    const warnings = [];
+                    const newSeedDataRows = [];
+                    let applied = 0;
+                    let skipped = 0;
+                    for (let i = 0; i < operations.length; i++) {
+                        const op = operations[i];
+                        const path = op?.path || "";
+                        const opType = 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);
+                    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)
+                        .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,
+                        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
 // ═══════════════════════════════════════════════════════════════════════════════
 // This is the single entry point called by index.ts.
@@ -6415,6 +6918,7 @@ supabase, config) {
     registerBrainOps(api, supabase, userId, resolveAgent); // 14
     registerTalentOps(api, supabase, userId); // 15
     registerFrameworkOps(api, supabase, userId, resolveAgent); // 16
+    registerOfficeOps(api, supabase, userId, resolveAgent); // 17
     // ── Register dynamic brain context hook ──
     registerBrainContextHook(api, supabase, userId, fallbackAgentId);
     // ── Register talent context hook ──
@@ -6424,7 +6928,7 @@ supabase, config) {
     // ── Register agent_end hook for server-side brain extraction ──
     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})`);
@@ -6590,6 +7094,52 @@ function registerBrainExtractionHook(api, supabase, userId, fallbackAgentId) {
                                 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 ?? {});
+                                    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
                             // dashboard's hidden conversation_messages so the dashboard can
@@ -6673,6 +7223,50 @@ function registerBrainExtractionHook(api, supabase, userId, fallbackAgentId) {
                     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 ?? {});
+                        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.
                 // Brain L1/L2/L3/L4 extraction skips trivial chit-chat to reduce