@curdx/flow 2.3.11 → 3.0.0

package/skills/implement/references/stop-hook-execution.md

@@ -6,11 +6,13 @@ naturally and the hook layer decides whether Claude continues.
 ## Protocol
 
 ```text
-1. Execute 1 task (inline or via flow-executor, then wait for completion)
-2. End the response naturally
-3. stop-watcher.sh evaluates transcript markers, .state.json, and tasks.md
-4. If unchecked tasks remain, the hook blocks stop and injects continuation
-5. Repeat until ALL_TASKS_COMPLETE or recovery forces a halt
+1. Initialize execute_state, including native sync fields
+2. Rebuild native_task_map if the current session cannot update stored task ids
+3. Execute 1 task (inline or via flow-executor, then wait for completion)
+4. End the response naturally
+5. stop-watcher.sh evaluates transcript markers, .state.json, and tasks.md
+6. If unchecked tasks remain, the hook blocks stop and injects continuation
+7. Repeat until ALL_TASKS_COMPLETE or recovery forces a halt
 ```
 
 ## Completion Invariant
@@ -23,6 +25,14 @@ Stop-hook completion is double-checked:
 If either side disagrees, the hook resumes the first unchecked task instead of
 allowing the session to stop cleanly.
 
+If native task sync is active during a continuation round:
+
+- `.flow/specs/<name>/tasks.md` stays the source of truth
+- checked rows should be mirrored back to the native task list before the next
+  task starts
+- a stale `native_task_map` should trigger the rebuild rule from
+  `references/native-task-sync.md`, not a run failure
+
 ## Prerequisites
 
 - `--quick` should be set; otherwise `AskUserQuestion` can stall the loop
@@ -34,3 +44,7 @@ allowing the session to stop cleanly.
 During a stop-hook continuation, `stop_hook_active=true` is only a hint. The
 hook still checks transcript signals, `.state.json`, and `tasks.md` parity
 before deciding whether to continue or stop.
+
+Native task sync is session-local UX. Continuations may resume into a different
+Claude-native task list, so recovery must prefer rebuilding the UI mirror over
+mutating `.flow` state.

package/skills/implement/references/subagent-execution.md

@@ -5,6 +5,12 @@ task, but the backlog is not parallel-safe enough for waves.
 
 ## Dispatch Contract
 
+Before each dispatch, if native task sync is active:
+
+- reconcile obvious `tasks.md` vs native-task drift
+- mark the outgoing task `in_progress`
+- set the native active form to `Executing <task-id>` when available
+
 Dispatch one `flow-executor` at a time with a uniform prompt:
 
 ```text
@@ -32,12 +38,20 @@ When all tasks are done output: ALL_TASKS_COMPLETE
 
 After the agent completes, read the output marker:
 
-- `TASK_COMPLETE` -> mark progress and dispatch the next task
-- `TASK_FAILED` -> increment failure tracking and enter recovery
+- `TASK_COMPLETE` -> mark progress, mark the native task `completed`, and
+  dispatch the next task
+- `TASK_FAILED` -> increment failure tracking, keep the native task open, and
+  enter recovery
 - `ALL_TASKS_COMPLETE` -> mark execute complete and move to verify
 
+If a stored Claude task id no longer updates, rebuild `native_task_map` from
+the current `tasks.md`, then continue serial dispatch. Do not rewrite
+`.state.json` task cursor or `tasks.md` just because the UI task list changed.
+
 ## Guardrails
 
 - This strategy is serial; a single Agent dispatch is not parallel execution
 - Do not batch multiple independent tasks into one `flow-executor` prompt
 - Do not trust narrative summaries over the end marker
+- Native task sync belongs to the coordinator around the dispatch loop, not to
+  the `flow-executor` subagent itself

package/skills/implement/references/wave-execution.md

@@ -50,6 +50,12 @@ If the planner mis-tagged `[P]` (modifies the same file), split the wave automat
 
 ## Step 3: Dispatch a Single Wave (key: within a single response)
 
+Before dispatching the wave, if native task sync is active:
+
+- reconcile obvious `tasks.md` vs native-task drift
+- mark every task in the upcoming wave `in_progress`
+- set the active form to `Executing Wave <n>: <task ids>` when available
+
 ```
 # List multiple Agent tool calls in one response of the main agent:
 Agent(description="Execute 1.1", prompt=<...flow-executor + task_id=1.1...>)
@@ -106,6 +112,14 @@ for task in completed:
         warn(f"Task {task.id} modified undeclared files: {unexpected}")
 ```
 
+After aggregation, if native task sync is active:
+
+- mark each `completed` task `completed`
+- leave each `failed` task open for retry/recovery
+- if any `TaskUpdate` call reports a stale or missing Claude task id, rebuild
+  `native_task_map` from `tasks.md` and continue with `.flow` as source of
+  truth
+
 ## Step 5: Wave Failure Handling
 
 ```
@@ -137,6 +151,10 @@ failed_attempts >= 3 (cumulative):
 ▶ Wave 3/5 starting (VERIFY)...
 ```
 
+When native task sync is active, the Claude task list is the short-form UI
+surface for the same wave progress. Keep chat feedback compact instead of
+relisting the whole backlog after every wave.
+
 ## Configuration
 
 `.flow/config.json`:

package/skills/status/references/gather-contract.md

@@ -19,6 +19,9 @@ Gather read-only state in this order:
    - `execute_state.total_tasks`
    - `execute_state.failed_attempts`
    - `execute_state.global_iteration`
+   - `execute_state.native_sync_enabled`
+   - `execute_state.native_sync_failure_count`
+   - `execute_state.native_task_map` size
 5. If `tasks.md` exists, count:
    - completed tasks: lines matching `- [x] **`
    - open tasks: lines matching `- [ ] **`

package/skills/status/references/output-contract.md

@@ -15,6 +15,7 @@ Phase: <phase | unknown>
 Strategy: <strategy | auto>
 Tasks: <done>/<total from tasks.md> checked, state cursor <task_index>/<total_tasks>
 Failures: <failed_attempts>, rounds: <global_iteration>
+Native sync: <on|off>, mapped tasks: <count>, sync failures: <native_sync_failure_count>
 Artifacts: [x] research [x] requirements [x] design [x] tasks [ ] verify [ ] review
 Health: OK | NEEDS_ATTENTION
 Recovery: <one concrete next command>