nubos-pilot 1.3.3 → 1.3.5

package/workflows/execute-phase.md

@@ -219,6 +219,10 @@ SPAWN_HEADLESS_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.hea
 SPAWN_HEADLESS_AGENTS=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.headless.agents 2>/dev/null || echo '["np-critic","np-researcher"]')
 SPAWN_HEADLESS_FALLBACK=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.headless.fallback_on_error 2>/dev/null || echo true)
 CONF_INJECT_CRITERIA=$(node .nubos-pilot/bin/np-tools.cjs config-get conformance.inject_criteria 2>/dev/null || echo true)
+# Round-1 prep agents (default on; backfilled on install/update). When a toggle
+# is false the matching ACTION CONTRACT (Step 2b / Step 2c) is skipped wholesale.
+ARCHITECT_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get agents.architect 2>/dev/null || echo true)
+TEST_WRITER_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get agents.test_writer 2>/dev/null || echo true)
 # Milestone success_criteria as the executor's acceptance target (rendered once from the INIT payload).
 # Intent-level only (ADR-0019): these describe what "done right" means, NOT how to build it.
 SUCCESS_CRITERIA_BLOCK=$(echo "$INIT" | node -e 'process.stdin.on("data",d=>{try{const c=JSON.parse(d).success_criteria||[];console.log(c.map(x=>"- "+(x.id?x.id+": ":"")+(x.text||x)).join("\n"))}catch(e){console.log("")}})')
@@ -414,6 +418,131 @@ for WAVE_INDEX in 0 1 2 ...; do
         CONSENSUS_PATTERN=""
       fi
 
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # ACTION CONTRACT — Step 2b: Per-Task Architect (Round 1, config-gated)
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # WHEN: $ROUND -eq 1 AND $ARCHITECT_ENABLED = true. Skip wholesale otherwise
+      #   (agents.architect=false → no architect this run; R≥2 build-fixer rounds
+      #   never run it).
+      # SKIP-GUARD: loop-post-architect-missing-spawn-audit (needs 1 architect audit).
+      #
+      # Execute EXACTLY these three groups, in order:
+      #
+      # (1) ONE Agent tool-call (real, not bash):
+      #       Agent(subagent_type="np-task-architect", prompt=<…>)
+      #     Prompt fields:
+      #       <files_to_read>: task plan, slice plan, CONTEXT.md, RULES.md,
+      #         M<NNN>-ARCHITECTURE.md (if present), .nubos-pilot/codebase/INDEX.md
+      #       <consensus_pattern>: $CONSENSUS_PATTERN (researcher output; may be empty)
+      #       <lang_directive>: $LANG_DIRECTIVE
+      #     Curated skills (quality bar) — instruct the agent to Read each that
+      #     applies from .claude/skills/<skill>/SKILL.md: np-system-design,
+      #     np-service-boundary, np-api-design, np-composition-patterns,
+      #     np-error-handling, np-adr (only for a costly-to-reverse choice).
+      #     The agent is READ-ONLY: it emits its Task-Architecture spec as its FINAL
+      #     MESSAGE (markdown per its Output Contract). Write that message verbatim
+      #     to "$ARCH_CONSTRAINTS_PATH".
+      #
+      # (2) ONE Bash audit-stamp (same round) — architect is NOT Rule-9 audited,
+      #     so an empty tool-use log is correct:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" \
+      #         --agent np-task-architect --tool-use-log '[]'
+      #
+      # (3) ONE Bash advance:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" \
+      #         --phase post-architect
+      #
+      # $ARCH_CONSTRAINTS is injected as <architecture_constraints> into the
+      # test-writer (Step 2c) AND executor (Step 3) prompts.
+      #
+      # Rationale: ADR-0023 — a per-task structural pass before tests/code so the
+      # test-writer and executor build against a decided shape, honouring RULES.md
+      # Conventions. Ephemeral ($TMPDIR, never committed) → plan-lint untouched.
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      ARCH_CONSTRAINTS=""
+      ARCH_CONSTRAINTS_PATH="${TMPDIR:-/tmp}/np-arch-${TASK_ID}.md"
+      if [ "$ROUND" -eq 1 ] && [ "$ARCHITECT_ENABLED" = "true" ]; then
+        # Off-host (ADR-0021): np-task-architect is read-only (Read/Grep/Glob), not
+        # Rule-9 audited, writes no files — run via spawn-offhost with default cwd
+        # when it routes to an openai-compat provider; its spec returns as the
+        # spawn's final message (content).
+        ARCHITECT_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-task-architect --json 2>/dev/null \
+          | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).kind||"native")}catch{console.log("native")}})')
+        if [ "$ARCHITECT_KIND" = "openai-compat" ]; then
+          A_PROMPT="${TMPDIR:-/tmp}/np-offhost-task-architect-${TASK_ID}.md"
+          # … render the files_to_read block + consensus + skills + $LANG_DIRECTIVE into "$A_PROMPT" …
+          A_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+            --agent np-task-architect --task-file "$A_PROMPT" --task-id "$TASK_ID" \
+            --read-only --no-audit ${SLICE_CWD:+--cwd "$SLICE_CWD"})
+          echo "$A_OUT" | ARCH_PATH="$ARCH_CONSTRAINTS_PATH" node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{let c="";try{c=JSON.parse(s).content||""}catch{}require("fs").writeFileSync(process.env.ARCH_PATH,c)})'
+        else
+          true  # → execute group (1): native Agent spawn; write its final message to "$ARCH_CONSTRAINTS_PATH".
+        fi
+        node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" --agent np-task-architect --tool-use-log '[]'
+        node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" --phase post-architect
+        [ -f "$ARCH_CONSTRAINTS_PATH" ] && ARCH_CONSTRAINTS=$(cat "$ARCH_CONSTRAINTS_PATH")
+      fi
+
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # ACTION CONTRACT — Step 2c: Test-Writer / TDD (Round 1, config-gated)
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # WHEN: $ROUND -eq 1 AND $TEST_WRITER_ENABLED = true. Runs AFTER the architect,
+      #   BEFORE the executor. Skip wholesale otherwise.
+      # SKIP-GUARD: loop-post-test-writer-missing-spawn-audit (needs 1 test-writer audit).
+      #
+      # Execute EXACTLY these three groups, in order:
+      #
+      # (1) ONE Agent tool-call (real, not bash):
+      #       Agent(subagent_type="np-test-writer", prompt=<…>)
+      #     Prompt fields:
+      #       <files_to_read>: task plan, slice plan, RULES.md, neighbouring tests
+      #       <architecture_constraints>: $ARCH_CONSTRAINTS (the architect's required
+      #         test surfaces; empty when the architect is disabled)
+      #       <success_criteria>: $SUCCESS_CRITERIA_BLOCK + slice UAT path (intent-level)
+      #       <lang_directive>: $LANG_DIRECTIVE
+      #     Curated skill (quality bar) — instruct the agent to Read
+      #     .claude/skills/np-test-strategy/SKILL.md and satisfy its Verification bar.
+      #     RULES — the agent writes REAL, VALID test files for every required surface;
+      #     it MUST NOT skip/stub/weaken assertions (Rule 10). Tests MAY be red now;
+      #     the executor makes them green. The agent emits a JSON envelope whose
+      #     tests_written paths you collect into $TDD_TESTS.
+      #
+      # (2) ONE Bash audit-stamp (same round) — test-writer is NOT Rule-9 audited:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" \
+      #         --agent np-test-writer --tool-use-log '[]'
+      #
+      # (3) ONE Bash advance — pass the written test paths so they are recorded in
+      #     the checkpoint (nubosloop.tdd_tests) and commit-task folds them into the
+      #     commit even when files_modified did not enumerate them:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" \
+      #         --phase post-test-writer --tests "$TDD_TESTS"
+      #
+      # Rationale: ADR-0023 — TDD inside the loop. The mechanical verify gate
+      # (Step 4) runs only AFTER the executor, so red-until-executor is expected
+      # and not a failure. The np-critic-tests axis (Step 5) re-audits for any
+      # skipped/vacuous assertions that slipped through.
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      TDD_TESTS=""
+      if [ "$ROUND" -eq 1 ] && [ "$TEST_WRITER_ENABLED" = "true" ]; then
+        # Off-host (ADR-0021): np-test-writer writes test files, so off-host needs
+        # worktree isolation exactly like the executor (model-driven Write confined
+        # + ff-merged back). When worktree isolation is off, it runs native.
+        TEST_WRITER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-test-writer --json 2>/dev/null \
+          | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).kind||"native")}catch{console.log("native")}})')
+        if [ "$TEST_WRITER_KIND" = "openai-compat" ] && [ "$WORKTREE_ISOLATION" = "true" ] && [ -n "$SLICE_CWD" ] && [ "$SLICE_CWD" != "." ]; then
+          TW_PROMPT="${TMPDIR:-/tmp}/np-offhost-test-writer-${TASK_ID}.md"
+          # … render files_to_read + architecture_constraints + success_criteria + skill + $LANG_DIRECTIVE into "$TW_PROMPT" …
+          TW_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+            --agent np-test-writer --task-file "$TW_PROMPT" --task-id "$TASK_ID" \
+            --cwd "$SLICE_CWD" --allow-bash --no-audit)
+          TDD_TESTS=$(echo "$TW_OUT" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(JSON.parse(s).content||"{}");console.log((j.tests_written||[]).join(", "))}catch{console.log("")}})')
+        else
+          true  # → execute group (1): native Agent spawn; collect tests_written from the envelope into $TDD_TESTS.
+        fi
+        node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" --agent np-test-writer --tool-use-log '[]'
+        node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" --phase post-test-writer --tests "$TDD_TESTS"
+      fi
+
       # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
       # ACTION CONTRACT — Step 3: Executor (R1) / Build-Fixer (R≥2)
       # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -424,6 +553,13 @@ for WAVE_INDEX in 0 1 2 ...; do
       #     Prompt fields:
       #       <files_to_read>: task plan, slice plan, prior slice SUMMARYs, CONTEXT.md
       #       <consensus_pattern>: $CONSENSUS_PATTERN (with [VERIFIED]/[PROVISIONAL]/[CACHED])
+      #       <architecture_constraints>: $ARCH_CONSTRAINTS — the per-task architect's
+      #         decided structure + constraints (empty when agents.architect is off).
+      #         The executor builds against this shape; it is intent-level, not a code spec.
+      #       <tdd_tests>: $TDD_TESTS — test files np-test-writer wrote (R1, empty when off).
+      #         The executor MUST make them green WITHOUT deleting, skipping, or weakening
+      #         any assertion. They are in scope alongside files_modified (recorded in the
+      #         checkpoint at post-test-writer) and commit-task commits them with the diff.
       #       <success_criteria>: when $CONF_INJECT_CRITERIA = true, include the milestone
       #         acceptance target — $SUCCESS_CRITERIA_BLOCK plus the slice UAT path
       #         (.nubos-pilot/milestones/M<NNN>/slices/S<NNN>/S<NNN>-UAT.md). Frame it as
@@ -437,7 +573,8 @@ for WAVE_INDEX in 0 1 2 ...; do
       #         ultra) instruct the agent to APPLY the np-executor "Climb the ladder"
       #         discipline before writing (prevention-first). When $ECONOMY_MODE = off,
       #         instruct it to SKIP the ladder (no economy pressure this run).
-      #     RULES — Agent MUST: edit ONLY paths in files_modified (D-04 scope guard) —
+      #     RULES — Agent MUST: edit ONLY paths in files_modified plus the <tdd_tests>
+      #     paths (D-04 scope guard; the TDD tests are the sole sanctioned addition) —
       #     success_criteria are the acceptance target, NEVER a licence to touch other files,
       #     run `node np-tools.cjs knowledge-search "<q>" --task $TASK_ID` via Bash
       #     ≥1× (Rule 9 — the --task flag writes the audit evidence ledger),

package/workflows/plan-phase.md

@@ -1,7 +1,7 @@
 ---
 command: np:plan-phase
 description: Plans a milestone (M<NNN>) — breaks it into slices (waves) and tasks. Spawns np-planner (opus) + np-plan-checker (opus), 2-iteration verification, then scaffolds every task file.
-argument-hint: <milestone-number> [--research] [--repromote]
+argument-hint: <milestone-number> [--research] [--architect] [--repromote]
 ---
 
 # np:plan-phase
@@ -41,17 +41,19 @@ Output layout:
 ```bash
 PHASE=""
 RESEARCH_FLAG=0
+ARCHITECT_FLAG=0
 REPROMOTE_FLAG=0
 for arg in "$@"; do
   case "$arg" in
     --research)  RESEARCH_FLAG=1 ;;
+    --architect) ARCHITECT_FLAG=1 ;;
     --repromote) REPROMOTE_FLAG=1 ;;
     --*)         echo "Unknown flag: $arg" >&2; exit 2 ;;
     *)           [[ -z "$PHASE" ]] && PHASE="$arg" ;;
   esac
 done
 if [[ -z "$PHASE" ]]; then
-  echo "Usage: /np:plan-phase <milestone-number> [--research] [--repromote]" >&2
+  echo "Usage: /np:plan-phase <milestone-number> [--research] [--architect] [--repromote]" >&2
   exit 2
 fi
 ```
@@ -154,6 +156,19 @@ fi
 
 **Exit code 42 contract:** orchestrator sees exit 42 → runs `/np:research-phase $PHASE` → re-enters `/np:plan-phase $PHASE` without the `--research` flag.
 
+### Gate 2b — Optional architecture pass (`--architect`)
+
+The `--architect` flag auto-dispatches `/np:architect-phase` before planning, so a structural ADR pass (`M<NNN>-ARCHITECTURE.md`) is decided up front and the planner consumes it like an extension of CONTEXT.md. Dispatched AFTER research (the established flow is research → architect → plan): when both flags are set, the research re-entry strips `--research`, leaving `--architect` to dispatch on the next pass.
+
+```bash
+if [[ "$ARCHITECT_FLAG" == "1" ]]; then
+  echo "architect-auto: dispatching /np:architect-phase $PHASE before planning" >&2
+  exit 43
+fi
+```
+
+**Exit code 43 contract:** orchestrator sees exit 43 → runs `/np:architect-phase $PHASE` → re-enters `/np:plan-phase $PHASE` without the `--architect` flag. The milestone `np-architect` stays intent-level (ADR-0019): its decisions inform the plan; they do not bake schema/filenames/code-style into `PLAN.md`.
+
 **Researcher-Schwarm semantics (ADR-0011).** The dispatched `/np:research-phase` runs in Schwarm mode by default (`swarm.research.k=3`). The cache-bypass at Pre-flight short-circuits the swarm whenever the milestone goal + requirements match a stored learning at similarity ≥ `swarm.research.threshold` and `occurrence ≥ swarm.research.minOccurrence`. The merged consensus carries a `<consensus_meta>` block (`k`, `agreement_score`, `flagged_decisions`) which `np-plan-checker` reads to weight downstream verdicts. No additional flags needed at this site — the swarm runs automatically when `--research` is set.
 
 ### Gate 3 — Milestone already planned