@questionbase/deskfree 0.3.0-alpha.20 → 0.3.0-alpha.21

package/README.md

@@ -15,7 +15,7 @@ Agents can pick up tasks, post progress updates, mark work as done or blocked, m
 │   deskfree_state             Inbound messages from humans        │
 │   deskfree_start_task        Outbound replies from agent         │
 │   deskfree_complete_task     Real-time notifications             │
-│   deskfree_create_task                                           │
+│   deskfree_suggest_tasks                                           │
 │   deskfree_create_activity                                       │
 │   deskfree_update_activity                                       │
 │   deskfree_classify_task                                         │

package/dist/index.d.ts

@@ -442,13 +442,6 @@ interface TaskWithContext extends Task {
     deliverable: string;
     messages: TaskMessage[];
 }
-/**
- * Response from the tasks.create bot endpoint.
- *
- * The backend mutation (`trpc.bot.tasks.create`) returns the Task object
- * directly (not wrapped in `{ task: ... }`).
- */
-type CreateTaskResponse = Task;
 interface CompleteTaskInput {
     taskId: string;
     outcome: 'done' | 'blocked';
@@ -463,6 +456,15 @@ interface WorkspaceStateTask {
     createdAt: string;
     updatedAt: string;
 }
+interface Initiative {
+    id: string;
+    title: string;
+    status: 'suggested' | 'active' | 'paused';
+    content: string;
+    contentVersion: number;
+    taskCount: number;
+    activeTaskCount: number;
+}
 interface WorkspaceState {
     tasks: WorkspaceStateTask[];
     recentlyDone: WorkspaceStateTask[];
@@ -471,7 +473,9 @@ interface WorkspaceState {
         taskId: string;
         taskNumber: number;
         title: string;
+        initiativeId?: string | null;
     }>;
+    initiatives: Initiative[];
 }
 interface EvaluationTaskMessage {
     messageId: string;
@@ -487,6 +491,11 @@ interface ClaimEvaluationResponse {
     waysOfWorking: string | null;
     currentVersion: number;
     messages: EvaluationTaskMessage[];
+    initiative?: {
+        id: string;
+        title: string;
+        content: string;
+    } | null;
 }
 
 /** Enhanced error class for DeskFree API errors with user-friendly messages */
@@ -558,19 +567,6 @@ declare class DeskFreeClient {
     }): Promise<MessagesResponse>;
     /** Obtain a one-time WebSocket authentication ticket for real-time notifications. */
     getWsTicket(): Promise<WsTicketResponse>;
-    /** Create a new task, optionally with a recurring schedule. */
-    createTask(input: {
-        title: string;
-        instructions?: string;
-        isRecurring?: boolean;
-        recurringSchedule?: {
-            frequency: 'daily' | 'weekly' | 'biweekly' | 'monthly';
-            dayOfWeek?: number;
-            dayOfMonth?: number;
-            time: string;
-            timezone?: string;
-        };
-    }): Promise<CreateTaskResponse>;
     /** Claim a task so the bot can begin working on it. Returns enriched context. */
     claimTask(input: {
         taskId: string;
@@ -638,6 +634,25 @@ declare class DeskFreeClient {
         messageId: string;
         content: string;
     }>;
+    /** Suggest tasks via the dedicated bot/tasks.suggest endpoint. */
+    suggestTasksDedicated(input: {
+        suggestions: Array<{
+            title: string;
+            instructions?: string;
+            estimatedTokens?: number;
+            dependsOn?: string[];
+            initiativeId?: string;
+        }>;
+        parentTaskId?: string;
+        initiativeSuggestions?: Array<{
+            title: string;
+            content: string;
+            taskRefs?: number[];
+        }>;
+    }): Promise<{
+        suggestionIds: string[];
+        initiativeSuggestionIds?: string[];
+    }>;
     /**
      * Claim a pending evaluation for a task. Atomically sets isWorking=true where
      * evaluationPending=true and isWorking=false. Returns null if already claimed.
@@ -647,17 +662,24 @@ declare class DeskFreeClient {
     }): Promise<ClaimEvaluationResponse | null>;
     /**
      * Submit the result of a ways-of-working evaluation.
-     * If hasChanges is true and updatedContent is provided, inserts a new version.
+     * Dual output: globalWoW (applies everywhere) and initiative (applies to the task's initiative).
      * Clears evaluationPending and isWorking on the task.
      */
     submitEvaluation(input: {
         taskId: string;
-        updatedContent?: string;
         reasoning: string;
-        hasChanges: boolean;
+        globalWoW: {
+            hasChanges: boolean;
+            updatedContent?: string;
+        };
+        initiative: {
+            hasChanges: boolean;
+            updatedContent?: string;
+        };
     }): Promise<{
         success: boolean;
-        version?: number;
+        globalVersion?: number;
+        initiativeVersion?: number;
     }>;
     /**
      * Lightweight health check that verifies connectivity and authentication.
@@ -725,4 +747,4 @@ declare const plugin: {
     register(api: OpenClawPluginApi): void;
 };
 
-export { type AnyAgentTool, type ChannelAccountSnapshot, type ChannelCapabilities, type ChannelConfigAdapter, type ChannelGatewayAdapter, type ChannelGatewayContext, type ChannelLogoutContext, type ChannelLogoutResult, type ChannelMessagingAdapter, type ChannelMessagingTargetResolver, type ChannelMeta, type ChannelOnboardingAdapter, type ChannelOnboardingResult, type ChannelOnboardingStatus, type ChannelOutboundAdapter, type ChannelOutboundContext, type ChannelPlugin, type ChannelProbeResult, type ChannelSecurityAdapter, type ChannelSecurityDmPolicy, type ChannelSetupAdapter, type ChannelStatusAdapter, type ChannelStatusIssue, type ChatMessage, type ChatMessageAttachment, type ClaimEvaluationResponse, type CompleteTaskInput, type CreateTaskResponse, type DeskFreeChannelConfig, DeskFreeClient, DeskFreeError, type EvaluationTaskMessage, type FinalizedMsgContext, type MessagesResponse, OfflineQueue, type OpenClawConfig, type OpenClawPluginApi, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OutboundDeliveryResult, type PluginHookAgentContext, type PluginHookBeforeAgentStartEvent, type PluginHookBeforeAgentStartResult, type PluginHookHandlerMap, type PluginHookName, type PluginLogger, type PluginRuntime, type ReplyDispatcher, type ResolvedDeskFreeAccount, type Task, type TaskMessage, type TaskWithContext, type WizardPrompter, type WorkspaceState, type WorkspaceStateTask, type WsNotification, type WsTicketResponse, plugin as default, reportError };
+export { type AnyAgentTool, type ChannelAccountSnapshot, type ChannelCapabilities, type ChannelConfigAdapter, type ChannelGatewayAdapter, type ChannelGatewayContext, type ChannelLogoutContext, type ChannelLogoutResult, type ChannelMessagingAdapter, type ChannelMessagingTargetResolver, type ChannelMeta, type ChannelOnboardingAdapter, type ChannelOnboardingResult, type ChannelOnboardingStatus, type ChannelOutboundAdapter, type ChannelOutboundContext, type ChannelPlugin, type ChannelProbeResult, type ChannelSecurityAdapter, type ChannelSecurityDmPolicy, type ChannelSetupAdapter, type ChannelStatusAdapter, type ChannelStatusIssue, type ChatMessage, type ChatMessageAttachment, type ClaimEvaluationResponse, type CompleteTaskInput, type DeskFreeChannelConfig, DeskFreeClient, DeskFreeError, type EvaluationTaskMessage, type FinalizedMsgContext, type Initiative, type MessagesResponse, OfflineQueue, type OpenClawConfig, type OpenClawPluginApi, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OutboundDeliveryResult, type PluginHookAgentContext, type PluginHookBeforeAgentStartEvent, type PluginHookBeforeAgentStartResult, type PluginHookHandlerMap, type PluginHookName, type PluginLogger, type PluginRuntime, type ReplyDispatcher, type ResolvedDeskFreeAccount, type Task, type TaskMessage, type TaskWithContext, type WizardPrompter, type WorkspaceState, type WorkspaceStateTask, type WsNotification, type WsTicketResponse, plugin as default, reportError };

package/dist/index.js

@@ -3889,11 +3889,6 @@ var DeskFreeClient = class {
     return this.request("POST", "messages.wsTicket", {});
   }
   // ── Tasks ─────────────────────────────────────────────────
-  /** Create a new task, optionally with a recurring schedule. */
-  async createTask(input) {
-    this.requireNonEmpty(input.title, "title");
-    return this.request("POST", "tasks.create", input);
-  }
   /** Claim a task so the bot can begin working on it. Returns enriched context. */
   async claimTask(input) {
     this.requireNonEmpty(input.taskId, "taskId");
@@ -3943,6 +3938,18 @@ var DeskFreeClient = class {
       taskId: input.taskId
     });
   }
+  /** Suggest tasks via the dedicated bot/tasks.suggest endpoint. */
+  async suggestTasksDedicated(input) {
+    if (!input.suggestions || input.suggestions.length === 0) {
+      throw new DeskFreeError(
+        "client",
+        "suggestions",
+        "suggestions array is required and cannot be empty",
+        "Missing required parameter: suggestions."
+      );
+    }
+    return this.request("POST", "tasks.suggest", input);
+  }
   /**
    * Claim a pending evaluation for a task. Atomically sets isWorking=true where
    * evaluationPending=true and isWorking=false. Returns null if already claimed.
@@ -3953,7 +3960,7 @@ var DeskFreeClient = class {
   }
   /**
    * Submit the result of a ways-of-working evaluation.
-   * If hasChanges is true and updatedContent is provided, inserts a new version.
+   * Dual output: globalWoW (applies everywhere) and initiative (applies to the task's initiative).
    * Clears evaluationPending and isWorking on the task.
    */
   async submitEvaluation(input) {
@@ -7755,19 +7762,9 @@ var Type = type_exports2;
 var ORCHESTRATOR_TOOLS = {
   STATE: {
     name: "deskfree_state",
-    description: "Get full workspace state \u2014 all tasks, recently done tasks. Use to assess what needs attention.",
+    description: "Get full workspace state \u2014 all tasks, recently done tasks, active initiatives. Use to assess what needs attention.",
     parameters: Type.Object({})
   },
-  CREATE_TASK: {
-    name: "deskfree_create_task",
-    description: "Create a new task (starts as bot).",
-    parameters: Type.Object({
-      title: Type.String({ description: "Task title (max 200 chars)" }),
-      instructions: Type.Optional(
-        Type.String({ description: "Detailed instructions for the task" })
-      )
-    })
-  },
   START_TASK: {
     name: "deskfree_start_task",
     description: "Claim a bot task (isWorking=false) and start working. Returns full context (instructions, deliverable, message history).",
@@ -7833,28 +7830,115 @@ var ORCHESTRATOR_TOOLS = {
       )
     })
   },
+  SUGGEST_TASKS: {
+    name: "deskfree_suggest_tasks",
+    description: 'Suggest tasks for human approval. Tasks are created with "suggested" status \u2014 the human approves or rejects each one. Use this to propose work before starting. Include detailed instructions as if briefing a contractor.',
+    parameters: Type.Object({
+      suggestions: Type.Array(
+        Type.Object({
+          title: Type.String({
+            description: "Task title \u2014 short, action-oriented (max 200 chars)"
+          }),
+          instructions: Type.Optional(
+            Type.String({
+              description: "Detailed instructions: what to do, why, what done looks like, known constraints"
+            })
+          ),
+          estimatedTokens: Type.Optional(
+            Type.Number({
+              description: "Estimated token cost \u2014 consider files to read, reasoning, output"
+            })
+          ),
+          dependsOn: Type.Optional(
+            Type.Array(Type.String(), {
+              description: "Task IDs this suggestion depends on (blocks claiming until those are done)"
+            })
+          ),
+          initiativeId: Type.Optional(
+            Type.String({
+              description: "Link to existing initiative ID \u2014 set when this task belongs to an active initiative"
+            })
+          )
+        }),
+        {
+          description: "Array of task suggestions (1-20)",
+          minItems: 1,
+          maxItems: 20
+        }
+      ),
+      parentTaskId: Type.Optional(
+        Type.String({
+          description: "Parent task ID \u2014 set when suggesting follow-ups from within a task"
+        })
+      ),
+      initiativeSuggestions: Type.Optional(
+        Type.Array(
+          Type.Object({
+            title: Type.String({
+              description: "Initiative title (max 200 chars)"
+            }),
+            content: Type.String({
+              description: "Initiative content markdown \u2014 current state, approach, and next priorities"
+            }),
+            taskRefs: Type.Optional(
+              Type.Array(Type.Number(), {
+                description: "Indexes into suggestions[] to auto-link when this initiative is approved"
+              })
+            )
+          }),
+          {
+            description: 'Propose new initiatives (optional). Created with "suggested" status \u2014 human approves or rejects independently.',
+            minItems: 1,
+            maxItems: 10
+          }
+        )
+      )
+    })
+  },
   CLAIM_EVALUATION: {
     name: "deskfree_claim_evaluation",
-    description: "Claim a pending ways-of-working evaluation for a task. Returns the task, its message history, and current ways_of_working content so you can decide whether updates are needed. Returns null if already claimed by another process.",
+    description: "Claim a pending ways-of-working evaluation for a task. Returns the task, its message history, current global ways_of_working, and initiative data (if the task belongs to an initiative). Returns null if already claimed by another process.",
     parameters: Type.Object({
       taskId: Type.String({ description: "Task UUID to claim evaluation for" })
     })
   },
   SUBMIT_EVALUATION: {
     name: "deskfree_submit_evaluation",
-    description: "Submit the result of a ways-of-working evaluation. Provide reasoning explaining your analysis. If the task revealed new patterns or learnings worth capturing, set hasChanges=true and provide updatedContent with the full updated markdown. Otherwise set hasChanges=false.",
+    description: "Submit the result of a ways-of-working evaluation. Provide reasoning explaining your analysis. Evaluation has two independent outputs: globalWoW (applies everywhere) and initiative (applies to the specific initiative this task belongs to). Set hasChanges=true and provide updatedContent for each output you want to update.",
     parameters: Type.Object({
       taskId: Type.String({ description: "Task UUID being evaluated" }),
       reasoning: Type.String({
-        description: "Explanation of your evaluation \u2014 what you analyzed and why you did or did not update the ways of working"
-      }),
-      hasChanges: Type.Boolean({
-        description: "Whether the ways of working should be updated"
+        description: "Explanation of your evaluation \u2014 what you analyzed and why you did or did not update the ways of working and/or initiative content"
       }),
-      updatedContent: Type.Optional(
-        Type.String({
-          description: "Full updated ways-of-working markdown (required if hasChanges=true)"
-        })
+      globalWoW: Type.Object(
+        {
+          hasChanges: Type.Boolean({
+            description: "Whether the global ways of working should be updated"
+          }),
+          updatedContent: Type.Optional(
+            Type.String({
+              description: "Full updated global ways-of-working markdown (required if hasChanges=true)"
+            })
+          )
+        },
+        {
+          description: "Global ways-of-working update \u2014 patterns that apply across all work"
+        }
+      ),
+      initiative: Type.Object(
+        {
+          hasChanges: Type.Boolean({
+            description: "Whether the initiative content should be updated (ignored if task has no initiative)"
+          }),
+          updatedContent: Type.Optional(
+            Type.String({
+              description: "Full updated initiative content markdown (required if hasChanges=true)"
+            })
+          )
+        },
+        {
+          description: "Initiative content update \u2014 what was learned about this specific area of focus. Ignored if the task has no initiative_id."
+        }
       )
     })
   }
@@ -8420,14 +8504,22 @@ var deskFreePlugin = {
 };
 
 // src/context.ts
-var DESKFREE_AGENT_DIRECTIVE = `## DeskFree
-Always read the deskfree skill (SKILL.md) at startup. Follow its workflow for task tracking and messaging.
-1. ALL work requires a task \u2014 use \`deskfree_create_task\` then \`deskfree_start_task\`.
-2. Ways of Working is your evolving playbook \u2014 it's injected automatically via state.get. When tasks are approved by humans, you'll evaluate them and update the ways of working.
-3. Build deliverables incrementally \u2014 use \`deskfree_update_deliverable\` from the start.
-4. Always complete tasks \u2014 use \`deskfree_complete_task\` with outcome "done" or "blocked".
-5. Auto-threading works \u2014 messages sent while a task is active are threaded automatically.
-6. Sub-agents get 4 tools: update_deliverable, complete_task, send_message (also supports suggestions), submit_evaluation.`;
+var DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 The Work Loop
+Always read the deskfree skill (SKILL.md) at startup. Follow the suggest-first work loop:
+1. **Check state** \u2192 \`deskfree_state\` \u2014 see what needs attention, read ways of working.
+2. **Suggest tasks** \u2192 \`deskfree_suggest_tasks\` \u2014 ALL work requires human-approved tasks first.
+3. **Claim a task** \u2192 \`deskfree_start_task\` \u2014 read instructions + parent context carefully.
+4. **Do the work** \u2192 \`deskfree_update_deliverable\` incrementally from the start.
+5. **Suggest follow-ups** \u2192 if work reveals more to do, suggest them (strongest when you have full context).
+6. **Complete** \u2192 \`deskfree_complete_task\` \u2014 deliverable required for "done".
+7. **Evaluate** \u2192 check \`pendingEvaluations\` and update ways of working.
+
+Key principles:
+- You're building a chain. Your instructions become someone else's brief. Your deliverable becomes someone else's context.
+- Write instructions as if briefing a contractor who has never seen the codebase.
+- MUST update deliverable before completing with outcome "done".
+- Estimate token cost per suggestion \u2014 consider files to read, reasoning, output.
+- Sub-agents get 4 tools: update_deliverable, complete_task, send_message, submit_evaluation.`;
 function getDeskFreeContext() {
   return `${DESKFREE_AGENT_DIRECTIVE}
 
@@ -8634,37 +8726,6 @@ function createOrchestratorTools(api) {
         }
       }
     },
-    {
-      ...ORCHESTRATOR_TOOLS.CREATE_TASK,
-      async execute(_id, params) {
-        try {
-          const title = validateStringParam(params, "title", true);
-          const instructions = validateStringParam(
-            params,
-            "instructions",
-            false
-          );
-          const task = await client.createTask({
-            title,
-            instructions
-          });
-          await client.sendMessage({
-            content: `\u{1F4CB} Created task: "${task.title}"`
-          }).catch(() => {
-          });
-          return formatTaskResponse(
-            task,
-            `Created task "${task.title}" with ID ${task.taskId}`,
-            [
-              "Claim and start this task with deskfree_start_task",
-              "Or check workspace state with deskfree_state"
-            ]
-          );
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    },
     {
       ...ORCHESTRATOR_TOOLS.START_TASK,
       async execute(_id, params) {
@@ -8806,6 +8867,95 @@ function createOrchestratorTools(api) {
         }
       }
     },
+    {
+      ...ORCHESTRATOR_TOOLS.SUGGEST_TASKS,
+      async execute(_id, params) {
+        try {
+          const rawSuggestions = params?.suggestions;
+          if (!Array.isArray(rawSuggestions) || rawSuggestions.length === 0) {
+            throw new Error(
+              'Parameter "suggestions" must be a non-empty array'
+            );
+          }
+          const suggestions = rawSuggestions.map((s, i) => {
+            if (typeof s !== "object" || s === null) {
+              throw new Error(`suggestions[${i}] must be an object`);
+            }
+            const item = s;
+            const title = item["title"];
+            if (typeof title !== "string" || title.trim() === "") {
+              throw new Error(
+                `suggestions[${i}].title must be a non-empty string`
+              );
+            }
+            return {
+              title: title.trim(),
+              instructions: typeof item["instructions"] === "string" ? item["instructions"] : void 0,
+              estimatedTokens: typeof item["estimatedTokens"] === "number" ? item["estimatedTokens"] : void 0,
+              dependsOn: Array.isArray(item["dependsOn"]) ? item["dependsOn"] : void 0,
+              initiativeId: typeof item["initiativeId"] === "string" ? item["initiativeId"] : void 0
+            };
+          });
+          const parentTaskId = validateStringParam(
+            params,
+            "parentTaskId",
+            false
+          );
+          const rawInitiativeSuggestions = params?.initiativeSuggestions;
+          let initiativeSuggestions;
+          if (Array.isArray(rawInitiativeSuggestions) && rawInitiativeSuggestions.length > 0) {
+            initiativeSuggestions = rawInitiativeSuggestions.map(
+              (s, i) => {
+                if (typeof s !== "object" || s === null) {
+                  throw new Error(`initiativeSuggestions[${i}] must be an object`);
+                }
+                const item = s;
+                const title = item["title"];
+                if (typeof title !== "string" || title.trim() === "") {
+                  throw new Error(
+                    `initiativeSuggestions[${i}].title must be a non-empty string`
+                  );
+                }
+                const content = item["content"];
+                if (typeof content !== "string") {
+                  throw new Error(
+                    `initiativeSuggestions[${i}].content must be a string`
+                  );
+                }
+                return {
+                  title: title.trim(),
+                  content,
+                  taskRefs: Array.isArray(item["taskRefs"]) ? item["taskRefs"] : void 0
+                };
+              }
+            );
+          }
+          const result = await client.suggestTasksDedicated({
+            suggestions,
+            parentTaskId,
+            initiativeSuggestions
+          });
+          const initiativeCount = initiativeSuggestions?.length ?? 0;
+          const summaryParts = [
+            `Suggested ${suggestions.length} task${suggestions.length === 1 ? "" : "s"} for human approval`,
+            ...initiativeCount > 0 ? [
+              `and ${initiativeCount} initiative${initiativeCount === 1 ? "" : "s"}`
+            ] : []
+          ];
+          return formatConfirmation(
+            summaryParts.join(" "),
+            [
+              'Tasks created with "suggested" status \u2014 human will approve or reject each',
+              ...initiativeCount > 0 ? ["Initiative suggestions created \u2014 human will approve or reject independently"] : [],
+              "Use deskfree_state to check for approved tasks"
+            ],
+            result
+          );
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
     {
       ...ORCHESTRATOR_TOOLS.CLAIM_EVALUATION,
       async execute(_id, params) {
@@ -8826,14 +8976,15 @@ function createOrchestratorTools(api) {
                   {
                     summary: `Claimed evaluation for task "${result.task.title}"`,
                     nextActions: [
-                      "Review the task messages and current ways of working",
-                      "Decide if patterns/learnings should update ways of working",
+                      "Review the task messages, current global ways of working, and initiative content (if present)",
+                      "Decide what to update: globalWoW (universal patterns), initiative (area-specific learnings), both, or neither",
                       "Call deskfree_submit_evaluation with your analysis"
                     ],
                     task: result.task,
                     waysOfWorking: result.waysOfWorking,
                     currentVersion: result.currentVersion,
-                    messages: result.messages
+                    messages: result.messages,
+                    ...result.initiative ? { initiative: result.initiative } : {}
                   },
                   null,
                   2
@@ -8852,26 +9003,53 @@ function createOrchestratorTools(api) {
         try {
           const taskId = validateStringParam(params, "taskId", true);
           const reasoning = validateStringParam(params, "reasoning", true);
-          const hasChanges = params?.hasChanges;
-          if (typeof hasChanges !== "boolean") {
-            throw new Error('Parameter "hasChanges" must be a boolean');
+          const rawGlobalWoW = params?.globalWoW;
+          if (typeof rawGlobalWoW !== "object" || rawGlobalWoW === null) {
+            throw new Error('Parameter "globalWoW" must be an object');
           }
-          const updatedContent = validateStringParam(
-            params,
-            "updatedContent",
-            false
-          );
+          const globalWoWObj = rawGlobalWoW;
+          if (typeof globalWoWObj["hasChanges"] !== "boolean") {
+            throw new Error('Parameter "globalWoW.hasChanges" must be a boolean');
+          }
+          const globalWoW = {
+            hasChanges: globalWoWObj["hasChanges"],
+            updatedContent: typeof globalWoWObj["updatedContent"] === "string" ? globalWoWObj["updatedContent"] : void 0
+          };
+          const rawInitiative = params?.initiative;
+          if (typeof rawInitiative !== "object" || rawInitiative === null) {
+            throw new Error('Parameter "initiative" must be an object');
+          }
+          const initiativeObj = rawInitiative;
+          if (typeof initiativeObj["hasChanges"] !== "boolean") {
+            throw new Error('Parameter "initiative.hasChanges" must be a boolean');
+          }
+          const initiative = {
+            hasChanges: initiativeObj["hasChanges"],
+            updatedContent: typeof initiativeObj["updatedContent"] === "string" ? initiativeObj["updatedContent"] : void 0
+          };
           const result = await client.submitEvaluation({
             taskId,
             reasoning,
-            hasChanges,
-            updatedContent
+            globalWoW,
+            initiative
           });
-          const messageContent = hasChanges ? `\u{1F4DD} Updated ways of working (v${result.version}): ${reasoning}` : `\u{1F4DD} No updates to ways of working: ${reasoning}`;
+          const parts = [];
+          if (globalWoW.hasChanges) {
+            parts.push(`global WoW \u2192 v${result.globalVersion}`);
+          }
+          if (initiative.hasChanges && result.initiativeVersion !== void 0) {
+            parts.push(`initiative \u2192 v${result.initiativeVersion}`);
+          }
+          const messageContent = parts.length > 0 ? `\u{1F4DD} Updated ${parts.join(", ")}: ${reasoning}` : `\u{1F4DD} No updates to ways of working: ${reasoning}`;
           await client.sendMessage({ content: messageContent, taskId }).catch(() => {
           });
+          const summaryParts = [];
+          if (globalWoW.hasChanges) summaryParts.push(`global WoW v${result.globalVersion}`);
+          if (initiative.hasChanges && result.initiativeVersion !== void 0) {
+            summaryParts.push(`initiative v${result.initiativeVersion}`);
+          }
           return formatConfirmation(
-            hasChanges ? `Ways of working updated to v${result.version}` : "Evaluation complete \u2014 no changes needed",
+            summaryParts.length > 0 ? `Evaluation complete \u2014 updated ${summaryParts.join(", ")}` : "Evaluation complete \u2014 no changes needed",
             ["Use deskfree_state to check for other pending evaluations"],
             result
           );