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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@questionbase/deskfree",
-  "version": "0.3.0-alpha.20",
+  "version": "0.3.0-alpha.21",
   "description": "OpenClaw channel plugin for DeskFree — turns DeskFree into a messaging platform for OpenClaw AI agents",
   "type": "module",
   "main": "dist/index.js",

package/skills/deskfree/SKILL.md

@@ -5,11 +5,11 @@ description: >
   Use when: creating tasks, managing work items, updating deliverables,
   communicating with humans through DeskFree, checking workspace state,
   handling task lifecycle (start → work → complete → review),
-  evaluating completed tasks, updating ways of working.
+  evaluating completed tasks, updating ways of working, managing initiatives.
   Do NOT use for: general project management advice without DeskFree tools,
   OpenClaw configuration or gateway setup, non-DeskFree platforms (Jira, Asana, etc.),
   direct file/code operations (use standard tools for those, create DeskFree tasks for tracking).
-version: 6.0.0
+version: 7.0.0
 metadata: { 'openclaw': { 'emoji': '🏠' } }
 ---
 
@@ -20,12 +20,26 @@ metadata: { 'openclaw': { 'emoji': '🏠' } }
 ### State Machine (memorize this)
 
 ```
-create_task → bot → [start_task] → bot (is_working) → [complete_task] → human
-                   ↑                                                                |
-                   |                    human approves/declines                     |
-                   └────────────────────────────────────────────────────────────────┘
-                                                                                    |
-                                                                               [approve] → done → [evaluate] → ways_of_working updated
+                              🎯 Initiative lifecycle
+suggest_tasks ──────────────────────────────────────────────────────────────────┐
+  + initiativeSuggestions →  [human approves initiative] → active               │
+                              [human rejects initiative]  → deleted              │
+                                                                                 │
+suggest_tasks → [human approves] → bot → [start_task] → bot (is_working)       │
+                   ↑                                          │                  │
+                   |               human approves/declines    │                  │
+                   └──────────────────────────────────────────┘                  │
+                                                              │                  │
+                                                         [complete_task]         │
+                                                              ↓                  │
+                                                           human                 │
+                                                              │                  │
+                                                         [approve]               │
+                                                              ↓                  │
+                                                           done ──→ [evaluate] ──┘
+                                                                        ↓
+                                                              globalWoW updated (always)
+                                                              + initiative updated (if task has initiative_id)
 ```
 
 - `complete_task` outcome `done` = work complete for review
@@ -33,11 +47,45 @@ create_task → bot → [start_task] → bot (is_working) → [complete_task]
 - Both outcomes move to `human` — the human triages from there
 - When human approves (`done`), a pending evaluation is created for ways-of-working update
 
+### The Work Loop
+
+```
+1. Check state     → deskfree_state — see tasks, active initiatives, pending evaluations
+2. Suggest tasks   → deskfree_suggest_tasks — propose work + optional initiative suggestions
+3. Claim a task    → deskfree_start_task — read instructions + parent context
+4. Do the work     → deskfree_update_deliverable — build incrementally
+5. Suggest follow-ups → if work reveals more to do, suggest them (link to initiative)
+6. Complete        → deskfree_complete_and_suggest (or deskfree_complete_task) — deliverable required
+7. Evaluate        → if approved tasks have pending WoW evaluation (update globalWoW + initiative)
+```
+
 ### Three Rules That Break Everything If Ignored
 
-1. **Always self-task.** Create a DeskFree task before starting ANY work. Tasks are cheap — invisible work is expensive. No exceptions.
-2. **Always check state first.** Call `deskfree_state` before creating tasks. Prevents duplicates, shows what needs attention.
-3. **Always complete tasks.** Never leave a task in `bot` (is_working=true). End with `deskfree_complete_task` — outcome `done` or `blocked`.
+1. **Always suggest first.** Use `deskfree_suggest_tasks` before starting ANY work. Tasks go through human approval. No exceptions.
+2. **Always check state first.** Call `deskfree_state` before suggesting tasks. Prevents duplicates, shows active initiatives.
+3. **Always complete tasks.** Never leave a task in `bot` (is_working=true). End with `deskfree_complete_and_suggest` or `deskfree_complete_task` — outcome `done` or `blocked`.
+
+### Writing Great Instructions
+
+Write instructions as if briefing a contractor who has never seen the codebase. Include:
+- **What to do** — specific, actionable steps
+- **Why** — referencing parent findings or deliverable when applicable
+- **What "done" looks like** — clear acceptance criteria
+- **Known constraints** — gotchas, dependencies, things to avoid
+
+### Deliverable Requirements
+
+**MUST update deliverable before completing with outcome "done".** Minimum: structured summary of what was found/done, decisions made, and recommendations. An empty or placeholder deliverable will be rejected.
+
+### Suggesting Follow-ups
+
+When completing, always consider: does this work reveal follow-up tasks? If yes, suggest them. Your suggestions are strongest at this moment because you have full context.
+
+Use `deskfree_complete_and_suggest` to complete and suggest in one atomic call. Estimate token cost per suggestion — consider how many files to read, how much reasoning, how much output.
+
+### Building the Chain
+
+You're not just doing tasks — you're building a chain. The instructions you write become someone else's brief. The deliverable you produce becomes someone else's context. Write both with care.
 
 ### Auto-Threading
 
@@ -47,6 +95,71 @@ The task sidebar is your human's window into your work — every message appears
 
 ---
 
+## Initiatives — Long-Lived Areas of Focus
+
+Initiatives answer **"what are we working on and why"** while Ways of Working answers **"how do we work."**
+
+| Concept | What it is |
+|---|---|
+| **Initiative** | A persistent area of focus (e.g. "Auth Hardening", "Performance Sprint") |
+| **Initiative Content** | A versioned markdown doc — current state, approach, next priorities |
+| **Task → Initiative link** | Set `initiativeId` on suggestions to link tasks to an initiative |
+
+### When to Propose a New Initiative
+
+```
+On every suggest_tasks call, ask yourself:
+
+"Does an active initiative exist that this work belongs to?"
+→ Yes: set initiativeId on the relevant suggestions
+→ No, but this is part of a bigger theme: add an initiativeSuggestion
+→ No, and it's a one-off task: no initiative needed
+```
+
+### Initiative Suggestion Flow
+
+```
+1. deskfree_state() → check initiatives[] for existing active ones
+
+2. deskfree_suggest_tasks({
+     suggestions: [
+       { title: "Audit auth endpoints", estimatedTokens: 20000 },
+       { title: "Add rate limiting",    estimatedTokens: 15000 }
+     ],
+     initiativeSuggestions: [
+       {
+         title: "Auth Hardening",
+         content: "# Auth Hardening\n\n## Current State\nNeed to improve auth security.\n\n## Approach\nTBD — start with audit.\n\n## Next Priorities\n1. Audit all auth endpoints\n2. Address findings",
+         taskRefs: [0, 1]   // auto-links tasks at index 0 and 1 when approved
+       }
+     ]
+   })
+
+Human sees:
+  🎯 New Initiative: "Auth Hardening"     [Approve] [Reject]
+  📋 Task: "Audit auth endpoints..."      [Approve] [Reject]
+  📋 Task: "Add rate limiting..."         [Approve] [Reject]
+```
+
+### Linking Tasks to Existing Initiatives
+
+```
+deskfree_state() → sees initiatives: [{ id: "init_abc", title: "Auth Hardening", status: "active" }]
+
+deskfree_suggest_tasks({
+  suggestions: [
+    { title: "Implement CSRF protection",
+      instructions: "...",
+      estimatedTokens: 25000,
+      initiativeId: "init_abc"   // link to existing initiative
+    }
+  ]
+  // no initiativeSuggestions needed — initiative already exists
+})
+```
+
+---
+
 ## Ways of Working — The Evolving Playbook
 
 Ways of Working is a **single versioned markdown document** per bot that evolves as you complete tasks. It's your institutional memory — capturing patterns, preferences, and learnings across all work.
@@ -57,19 +170,74 @@ Ways of Working is a **single versioned markdown document** per bot that evolves
 - Updated after task approval via the evaluation flow (never manually during work)
 - Each update creates a new immutable version — full history preserved
 
-### Evaluation Flow
+### Evaluation Flow — Dual Output
 
-When a human approves a task, it enters `pendingEvaluations` in state.get:
+When a human approves a task, it enters `pendingEvaluations` in state.get. Evaluation now has **two independent outputs**:
 
 ```
-1. deskfree_claim_evaluation  → claim the eval, get task + messages + current ways of working
-2. Read the task history       → understand what was done and how
-3. deskfree_submit_evaluation → provide reasoning + updated content (or no changes)
+1. deskfree_claim_evaluation(taskId)
+   → returns: task + messages + waysOfWorking + initiative (if task has initiative_id)
+
+2. Read the task deliverable and messages thoroughly
+
+3. Ask yourself:
+   "Did I learn something about HOW we work that applies everywhere?"
+   → Yes: update globalWoW
+
+   "Did I learn something about WHERE this initiative stands or
+    HOW to approach this specific area?"
+   → Yes: update initiative content
+
+   Both? → update both
+   Neither? → hasChanges: false for both
+
+4. deskfree_submit_evaluation({
+     taskId,
+     reasoning: "...",
+     globalWoW:  { hasChanges: true,  updatedContent: "..." },
+     initiative: { hasChanges: false }
+   })
 ```
 
-**When to update:** New patterns emerged, a better approach was found, recurring mistakes identified, human gave feedback that reveals process improvements.
+**globalWoW** — patterns that apply to all work everywhere. Examples:
+- A better approach to error handling you discovered
+- A recurring mistake to avoid
+- A tool or service pattern that's universally useful
+
+**initiative content** — what was learned about this specific area of focus. Examples:
+- Current state of the initiative has changed (task completed a major piece)
+- New findings shifted the approach
+- Next priorities should be reordered
 
-**When NOT to update:** One-off tasks with no transferable learnings, standard work that matched existing patterns.
+**When NOT to update either:** One-off tasks with no transferable learnings, standard work that matched existing patterns.
+
+### Example Evaluation
+
+```
+Task "Audit auth endpoints" (linked to "Auth Hardening" initiative) is approved.
+
+claim_evaluation → returns:
+  task (with deliverable showing 3 critical issues found)
+  waysOfWorking: "..."
+  initiative: { id: "init_abc", title: "Auth Hardening", content: "No audit done yet." }
+
+Analysis:
+  - Gateway has built-in rate limiting (just needs config) → applies everywhere → update globalWoW
+  - Audit found 3 critical issues → initiative content needs update → update initiative
+
+submit_evaluation({
+  taskId: "audit-task",
+  reasoning: "Audit found 3 issues. Gateway has rate limiting built in — updated both.",
+  globalWoW: {
+    hasChanges: true,
+    updatedContent: "...## Infrastructure\n- Always check AWS API Gateway config before building custom middleware\n..."
+  },
+  initiative: {
+    hasChanges: true,
+    updatedContent: "# Auth Hardening\n\n## Current State\nAudit complete. Found 3 critical issues:\n1. Session fixation\n2. No rate limiting (gateway supports it — just needs config)\n3. Weak CSRF\n\n## Next Priorities\n1. Configure gateway rate limiting (quick win)\n2. Fix session fixation\n3. Implement CSRF tokens"
+  }
+})
+```
 
 ---
 
@@ -79,9 +247,10 @@ When a human approves a task, it enters `pendingEvaluations` in state.get:
 
 - [ ] Called `deskfree_state` — confirmed it returned data (not empty/error)
 - [ ] Read `waysOfWorking` if present — apply established patterns
+- [ ] Read `initiatives` if present — check for active initiatives this work belongs to
 - [ ] Checked for existing tasks that match intent — no duplicates
-- [ ] Created a task with clear, action-oriented title (max 200 chars)
-- [ ] Called `deskfree_start_task` — confirmed task moved to `bot` (is_working=true)
+- [ ] Suggested a task via `deskfree_suggest_tasks` — with `initiativeId` if linking to existing initiative, or `initiativeSuggestions` if proposing new one
+- [ ] Once approved: called `deskfree_start_task` — confirmed task moved to `bot` (is_working=true)
 
 ### Mid-Work
 
@@ -98,7 +267,7 @@ When a human approves a task, it enters `pendingEvaluations` in state.get:
 
 ### Heartbeat Evaluation Check
 
-- [ ] Any `pendingEvaluations` in state? → claim and evaluate each one
+- [ ] Any `pendingEvaluations` in state? → claim and evaluate each one (submit globalWoW + initiative outputs)
 
 ---
 
@@ -107,21 +276,21 @@ When a human approves a task, it enters `pendingEvaluations` in state.get:
 ### Orchestrator Flow (main session)
 
 ```
-1. deskfree_state              → assess workspace + read ways of working
-2. deskfree_create_task        → create with clear title + instructions
-3. deskfree_start_task         → claim it (returns full context)
-4. deskfree_update_deliverable → build incrementally as you work
-5. deskfree_complete_task      → outcome "done" or "blocked"
+1. deskfree_state                  → assess workspace + read ways of working + check active initiatives
+2. deskfree_suggest_tasks          → suggest tasks (with estimatedTokens, initiativeId, initiativeSuggestions)
+3. deskfree_start_task             → claim approved task (returns full context + parent context)
+4. deskfree_update_deliverable     → build incrementally as you work
+5. deskfree_complete_and_suggest   → complete + suggest follow-ups (or deskfree_complete_task if no follow-ups)
 ```
 
 ### Sub-Agent Flow (recommended for tasks > 5 min)
 
 ```
-Orchestrator: deskfree_create_task → deskfree_start_task → spawn sub-agent with full task context
+Orchestrator: deskfree_suggest_tasks → (human approves) → deskfree_start_task → spawn sub-agent with full task context
 Sub-agent:    deskfree_update_deliverable (incrementally) → deskfree_complete_task → terminate
 ```
 
-Sub-agents have **4 tools:** `deskfree_update_deliverable`, `deskfree_complete_task`, `deskfree_send_message` (also supports task suggestions), `deskfree_submit_evaluation`. They cannot create tasks, read workspace state, or claim evaluations.
+Sub-agents have **4 tools:** `deskfree_update_deliverable`, `deskfree_complete_task`, `deskfree_send_message` (also supports task suggestions), `deskfree_submit_evaluation`. They cannot suggest tasks, read workspace state, or claim evaluations.
 
 ### When to Use Main vs Sub-Agent
 
@@ -151,18 +320,20 @@ Sub-agents have **4 tools:** `deskfree_update_deliverable`, `deskfree_complete_t
 
 ### Heartbeat / Proactive Check
 
-1. `deskfree_state` → get workspace snapshot + check `waysOfWorking` + `pendingEvaluations`
-2. `pendingEvaluations`? → `deskfree_claim_evaluation` → `deskfree_submit_evaluation`
+1. `deskfree_state` → get workspace snapshot + check `waysOfWorking` + `initiatives` + `pendingEvaluations`
+2. `pendingEvaluations`? → `deskfree_claim_evaluation` → `deskfree_submit_evaluation` (with globalWoW + initiative outputs)
 3. `bot` tasks? → `deskfree_start_task` + spawn sub-agents
 4. `bot` (is_working=true) with no active sub-agent? → Complete as blocked or resume
 
 ### Human Gives You Work
 
-1. `deskfree_state` → check existing tasks + read ways of working
-2. `deskfree_create_task` → clear title + instructions
-3. `deskfree_start_task` → claim it
-4. Work → `deskfree_update_deliverable` incrementally
-5. `deskfree_complete_task` → outcome `done` or `blocked`
+1. `deskfree_state` → check existing tasks + read ways of working + check active initiatives
+2. Does this work belong to an active initiative? → set `initiativeId` on suggestions
+   OR is this starting a new area of focus? → add `initiativeSuggestions`
+3. `deskfree_suggest_tasks` → suggest with clear title + instructions
+4. [human approves] → `deskfree_start_task` → claim it
+5. Work → `deskfree_update_deliverable` incrementally
+6. `deskfree_complete_task` → outcome `done` or `blocked`
 
 ---
 
@@ -170,18 +341,19 @@ Sub-agents have **4 tools:** `deskfree_update_deliverable`, `deskfree_complete_t
 
 > **Full parameter details:** See `references/tools.md`
 
-### Orchestrator (8 tools)
+### Orchestrator (10 tools)
 
 | Tool | What it does |
 |---|---|
-| `deskfree_state` | Full workspace snapshot — tasks, recently done, ways of working, pending evaluations |
-| `deskfree_create_task` | Create task (→ `bot`) |
-| `deskfree_start_task` | Claim task → `bot` (is_working=true), returns full context |
+| `deskfree_state` | Full workspace snapshot — tasks, recently done, ways of working, active initiatives, pending evaluations |
+| `deskfree_suggest_tasks` | Suggest tasks for human approval (with estimatedTokens, initiativeId, initiativeSuggestions) |
+| `deskfree_start_task` | Claim task → `bot` (is_working=true), returns full context + parent context |
 | `deskfree_update_deliverable` | Build deliverable markdown incrementally |
 | `deskfree_complete_task` | Mark done or blocked → `human` |
-| `deskfree_send_message` | Message in task thread (also supports task suggestions) |
-| `deskfree_claim_evaluation` | Claim a pending ways-of-working evaluation |
-| `deskfree_submit_evaluation` | Submit evaluation result with reasoning and optional updated content |
+| `deskfree_complete_and_suggest` | Complete current task + suggest follow-ups in one atomic call |
+| `deskfree_send_message` | Message in task thread |
+| `deskfree_claim_evaluation` | Claim a pending evaluation — returns task, messages, globalWoW, and initiative (if applicable) |
+| `deskfree_submit_evaluation` | Submit evaluation with dual output: globalWoW + initiative (each independently updatable) |
 
 ### Worker (4 tools — sub-agents only)
 
@@ -316,11 +488,12 @@ If anything goes wrong mid-task:
 ```
 Main Session:
 1. deskfree_state()                    → check workspace
-2. deskfree_create_task({
+2. deskfree_suggest_tasks([{
      title: "Research competitor HumanLayer",
      instructions: "Analyze their product, pricing, and positioning vs DeskFree"
-   })
-3. deskfree_start_task(taskId)         → get task context
+   }])
+3. [human approves task]
+4. deskfree_start_task(taskId)         → get task context
 4. spawn_subagent(research_prompt)     → background research
 
 Sub-agent:
@@ -336,11 +509,12 @@ Sub-agent:
 
 ```
 1. deskfree_state()                    → check current state
-2. deskfree_create_task({
+2. deskfree_suggest_tasks([{
      title: "Fix broken login endpoint", 
      instructions: "Apply hotfix for 500 error in /auth/login"
-   })
-3. deskfree_start_task(taskId)         → claim the work
+   }])
+3. [human approves task]
+4. deskfree_start_task(taskId)         → claim the work
 4. deskfree_update_deliverable()       → "Investigating issue..."
 5. [fix the code...]
 6. deskfree_update_deliverable()       → "Applied fix, testing..."

package/skills/deskfree/references/tools.md

@@ -1,25 +1,20 @@
 # DeskFree Tools — Full Parameter Reference
 
-## Orchestrator Tools (8)
+## Orchestrator Tools (10)
 
 ### `deskfree_state`
-Get full workspace snapshot — all tasks, recently done tasks, current ways of working, and pending evaluations.
+Get full workspace snapshot — all tasks, recently done tasks, active initiatives, current ways of working, and pending evaluations.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | *(none)* | — | — | — |
 
-**Returns:** Active tasks array, recently completed tasks, `waysOfWorking` (string or null), `pendingEvaluations` (array of `{taskId, taskNumber, title}`).
-
----
-
-### `deskfree_create_task`
-Create a new task (starts as `bot`).
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `title` | string | Yes | Task title (max 200 chars) |
-| `instructions` | string | No | Detailed instructions for the task |
+**Returns:**
+- `tasks` — active tasks array
+- `recentlyDone` — recently completed tasks
+- `waysOfWorking` — global ways of working (string or null)
+- `pendingEvaluations` — array of `{taskId, taskNumber, title, initiativeId?}`
+- `initiatives` — active initiatives with `{id, title, status, content, contentVersion, taskCount, activeTaskCount}`
 
 ---
 
@@ -30,7 +25,7 @@ Claim a `bot` task → moves to `bot` (is_working=true). Returns full context.
 |-----------|------|----------|-------------|
 | `taskId` | string | Yes | Task UUID to claim |
 
-**Returns:** Full task context — instructions, current deliverable, message history. Use this to populate sub-agent spawn prompts.
+**Returns:** Full task context — instructions, current deliverable, message history, and `parentContext` (title, deliverable, instructions of the parent task if this was suggested by another task). Use this to populate sub-agent spawn prompts.
 
 **Errors:** 404 if task not `bot` or doesn't exist. 409 if already claimed.
 
@@ -61,38 +56,84 @@ Finish a task → moves to `human`.
 ---
 
 ### `deskfree_send_message`
-Send a message in the task thread. Can also suggest follow-up tasks for human review.
+Send a message in the task thread (progress update, question, status report).
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `content` | string | No | Message content. Required unless `suggestions` is provided. |
 | `taskId` | string | No | Task UUID (optional — auto-threaded to active task if omitted) |
-| `suggestions` | array | No | List of tasks to suggest for human review (1-10), each with `title` (required) and `instructions` (optional). Provide this instead of `content`. |
+| `suggestions` | array | No | List of tasks to suggest for human review (1-10). Prefer `deskfree_suggest_tasks` for richer suggestions with estimatedTokens and dependencies. |
+
+---
+
+### `deskfree_suggest_tasks`
+Suggest tasks for human approval. Creates tasks with `suggested` status. Can also propose new initiatives.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `suggestions` | array | Yes | Array of task suggestions (1-20) |
+| `suggestions[].title` | string | Yes | Task title — short, action-oriented (max 200 chars) |
+| `suggestions[].instructions` | string | No | Detailed instructions: what to do, why, what done looks like, constraints |
+| `suggestions[].estimatedTokens` | number | No | Estimated token cost for completing this task |
+| `suggestions[].dependsOn` | string[] | No | Task IDs this depends on (blocks claiming until those are done) |
+| `suggestions[].initiativeId` | string | No | Link task to an existing active initiative |
+| `initiativeSuggestions` | array | No | Propose new initiatives (0-5) |
+| `initiativeSuggestions[].title` | string | Yes | Initiative title (max 200 chars) |
+| `initiativeSuggestions[].content` | string | Yes | Initial initiative content (markdown — current state, approach, next priorities) |
+| `initiativeSuggestions[].taskRefs` | number[] | No | Indexes into `suggestions[]` to auto-link when approved |
+| `parentTaskId` | string | No | Parent task ID — set when suggesting follow-ups from within a task |
+
+**Returns:** `{ suggestionIds: string[], initiativeSuggestionIds?: string[] }`
+
+---
+
+### `deskfree_complete_and_suggest`
+Complete the current task AND suggest follow-up tasks in one atomic call.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID to complete |
+| `outcome` | string | Yes | `done` or `blocked` |
+| `suggestions` | array | No | Follow-up task suggestions (0-20) |
+| `suggestions[].title` | string | Yes | Task title (max 200 chars) |
+| `suggestions[].instructions` | string | No | Detailed instructions |
+| `suggestions[].estimatedTokens` | number | No | Estimated token cost |
+| `suggestions[].dependsOnTaskIds` | string[] | No | Task IDs this depends on |
+| `suggestions[].initiativeId` | string | No | Link to existing initiative |
+| `initiativeSuggestions` | array | No | Propose new initiatives (same schema as deskfree_suggest_tasks) |
+
+**Returns:** Updated task object + `suggestionIds` array (if suggestions were created) + `initiativeSuggestionIds` (if initiatives were suggested).
+
+**Note:** Deliverable required for outcome `done`. Task moves to `human` for review.
 
 ---
 
 ### `deskfree_claim_evaluation`
-Claim a pending ways-of-working evaluation. Atomically sets `isWorking=true` where `evaluationPending=true` and `isWorking=false`. Returns null if already claimed.
+Claim a pending evaluation. Atomically sets `isWorking=true` where `evaluationPending=true` and `isWorking=false`. Returns null if already claimed.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `taskId` | string | Yes | Task UUID from `pendingEvaluations` list |
 
-**Returns:** `{ task, waysOfWorking, currentVersion, messages }` — full evaluation context, or `null` if already claimed.
+**Returns:** `{ task, waysOfWorking, currentVersion, messages, initiative? }` — full evaluation context including initiative data (if task is linked to one), or `null` if already claimed.
 
 ---
 
 ### `deskfree_submit_evaluation`
-Submit the result of a ways-of-working evaluation. Always call this after `deskfree_claim_evaluation`.
+Submit the result of an evaluation. Supports dual output: global ways of working + initiative content. Always call this after `deskfree_claim_evaluation`.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `taskId` | string | Yes | Task UUID being evaluated |
-| `reasoning` | string | Yes | Explanation of your analysis — what you learned and why you did or did not update ways of working |
-| `hasChanges` | boolean | Yes | Whether the ways of working should be updated |
-| `updatedContent` | string | No | Full updated ways-of-working markdown (required if `hasChanges=true`) |
+| `reasoning` | string | Yes | Explanation of your analysis — what you learned |
+| `globalWoW` | object | Yes | Global ways of working update |
+| `globalWoW.hasChanges` | boolean | Yes | Whether global WoW should be updated |
+| `globalWoW.updatedContent` | string | No | Full updated global WoW markdown (required if hasChanges=true) |
+| `initiative` | object | No | Initiative content update (only if task has initiative_id) |
+| `initiative.hasChanges` | boolean | Yes | Whether initiative content should be updated |
+| `initiative.updatedContent` | string | No | Full updated initiative content markdown (required if hasChanges=true) |
 
-**Returns:** `{ success, version }` — version number of the new ways-of-working entry (if hasChanges=true).
+**Returns:** `{ success, globalVersion?, initiativeVersion? }`
 
 ---
 
@@ -100,4 +141,4 @@ Submit the result of a ways-of-working evaluation. Always call this after `deskf
 
 Sub-agents receive: `deskfree_update_deliverable`, `deskfree_complete_task`, `deskfree_send_message`, `deskfree_submit_evaluation`
 
-They **cannot** use: `deskfree_state`, `deskfree_create_task`, `deskfree_start_task`, `deskfree_claim_evaluation`
+They **cannot** use: `deskfree_state`, `deskfree_suggest_tasks`, `deskfree_start_task`, `deskfree_claim_evaluation`