@noir-ai/skills 1.9.4-beta.1 → 1.9.4

package/builtin/noir-executing-plans/SKILL.md

@@ -16,16 +16,30 @@ Drive a written implementation plan task by task, in order. Each task: implement
 
 - A plan is written and it's time to code.
 - The user says "implement this", "start coding", "build it", or points at a plan file.
-- The plan has ordered tasks — you're executing them sequentially.
-- **Do NOT use:** for exploratory coding without a plan; use `noir-brainstorming` first. For independent tasks that can fan out concurrently, use `noir-parallel`. For a single subagent per task with review between, use `noir-subagent`.
+- **This skill routes to the right execution mode** — inline (sequential), subagent-driven, combination, or workflow orchestration — based on what the user chooses.
+- **Do NOT use:** for exploratory coding without a plan; use `noir-brainstorming` first.
 
 ## Procedure
 
 1. **Load the plan.** Read the plan file. Confirm the task order. If a task depends on an earlier one, start there.
-2. **One task at a time.** Pick the next pending task. State which task you're executing. Do not bundle multiple tasks into one commit.
-3. **RED → GREEN → COMMIT.** Write the failing test first (see `noir-test-driven-development`), implement the minimal code to pass, verify the test goes green and no regression, then commit with a conventional-commit message. Repeat for the task's subtasks if any.
-4. **Mark the task done.** Update the plan's checkbox `- [x]` and move to the next task. The engine's execute gate records the checkpoint observably.
-5. **When the plan is done:** all tasks ticked, all tests green, the implementation matches the spec → hand off.
+2. **Offer execution mode.** On Claude Code, use `AskUserQuestion` to let the user choose how to execute. On other hosts, ask in plain text. The options (presented as a structured choice):
+
+   | Mode | Best for | What happens |
+   |---|---|---|
+   | **Inline (sequential)** | Ordered tasks with dependencies, small-to-medium scope | Drive tasks one-by-one in this session — implement, test, commit, move to next. You stay in control. |
+   | **Subagent-driven** | Independent tasks, fan-out plans, need per-task review | Hand off to `noir-subagent` — dispatch fresh subagent per task with briefs and review gates. |
+   | **Combination** | Mix of sequential + independent tasks | Start inline for dependency-chain tasks, then fan out independent ones via subagents. |
+   | **Workflow orchestration** | Large plans, "ultracode" active, multi-agent parallelism | Use the host's Workflow tool to orchestrate many agents concurrently with review between stages. Only offered when the host's effort/capability level supports it. |
+
+   **Default:** if the user doesn't choose, use inline (sequential) — it's the safest, most reviewable path.
+
+3. **Execute in the chosen mode.** Follow the mode-specific flow:
+   - **Inline:** pick the next pending task → state it → RED (failing test) → GREEN (minimal impl) → REFACTOR → commit → mark `[x]` → repeat.
+   - **Subagent-driven:** route to `noir-subagent` (it handles briefs, dispatch, review, integration).
+   - **Combination:** execute dependency-chain tasks inline first, then fan out independent ones.
+   - **Workflow:** compose the workflow script (phases, agents, review gates) from the plan, then dispatch.
+4. **Mark progress.** Update the plan's checkboxes `- [x]` as tasks complete. The engine's execute gate records checkpoints observably.
+5. **When the plan is done:** all tasks ticked, all tests green, the implementation matches the spec → hand off to `noir-verifying`.
 
 ## Verification
 

package/builtin/noir-parallel/SKILL.md

@@ -22,8 +22,9 @@ When two or more tasks are independent (no shared state, no ordering), work them
 ## Procedure
 
 1. **Validate independence.** List the tasks. Confirm none reads another's output or touches the same file in a conflicting way.
-2. **Issue all dispatches in the same response.** On Claude Code, issue multiple tool uses concurrently. On other hosts, dispatch the equivalent parallel work.
-3. **Collect results.** Each result lands independently. Aggregate, then continue.
+2. **Dispatch all tasks in ONE response.** On Claude Code, issue multiple `Task` tool calls or `Agent` dispatches in the same message turn — the host runs them concurrently. On other hosts, use whatever parallel dispatch mechanism is available (subagents, parallel tool calls, async workers). The key: don't wait for Task A's full completion before starting Task B — issue them together.
+3. **Collect results.** Each result lands independently. Aggregate, then continue. If any task failed or needs adjustment, route it to `noir-systematic-debugging` before integrating.
+4. **Integrate.** All results clean → combine and proceed.
 
 ## When not to use
 

package/builtin/noir-subagent/SKILL.md

@@ -27,9 +27,9 @@ Dispatch each independent task to a fresh subagent with a brief, then review the
 2. **Validate independence.** If task B needs task A's output, they're not independent — order them or merge them.
 
 ### Per task
-3. **Dispatch the subagent.** Fresh subagent, clean context, reads the brief and the spec. On Claude Code, use the `Task` tool or your host's subagent mechanism. On other hosts, dispatch whatever agent runner is available.
+3. **Dispatch the subagent.** Fresh subagent, clean context, reads the brief and the spec. On Claude Code, use the `Task` tool with a specific subagent type (e.g. `Explore` for search, `Plan` for design) — or use `Agent` with `subagent_type` for custom configurations. On other hosts, dispatch whatever agent/subagent runner is available. **Issue multiple dispatches in ONE response to run them concurrently.**
 4. **Receive the report.** The subagent returns a `.noir/sdd/task-N-report.md` — what was done, test results, any issues.
-5. **Review.** Verify: tests pass, spec satisfied, commits are clean. If not, return to the subagent with the issues.
+5. **Review.** Verify: tests pass, spec satisfied, commits are clean. If not, return to the subagent with the specific issues — don't rewrite their code yourself (that defeats the isolation). If a task needs rework, re-dispatch with the issues as context.
 
 ### Final
 6. **Integrate.** All tasks done, all tests green, all briefs archived. Hand off to `noir-verifying`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noir-ai/skills",
-  "version": "1.9.4-beta.1",
+  "version": "1.9.4",
   "description": "Noir skills — the builtin noir-* skill pack, the integrations pack (ClickUp first), and a copy-and-validate compiler.",
   "license": "MIT",
   "author": "agaaaptr",
@@ -48,7 +48,7 @@
   "dependencies": {
     "yaml": "^2.5.0",
     "zod": "^4.2.0",
-    "@noir-ai/core": "1.9.4-beta.1"
+    "@noir-ai/core": "1.9.4"
   },
   "devDependencies": {
     "@types/node": "^26.1.1"