nubos-pilot 1.2.3 → 1.3.0

package/workflows/plan-phase.md

@@ -241,17 +241,38 @@ for ITER in 1 2; do
   #   <prior_findings>$LAST_FINDINGS</prior_findings>  (path to verdict JSON, R≥2)
   #   <agent_skills>$AGENT_SKILLS_PLANNER</agent_skills>
   # Agent MUST: write/update slice plans inside $milestone_dir.
+  # Off-host (ADR-0021): when np-planner routes to an openai-compat provider
+  # (agent_routing), run it via spawn-offhost (below) INSTEAD of the Agent tool.
   # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   PLANNER_START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
   PLANNER_MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-planner --profile frontier)
-  # → execute the Agent call per ACTION CONTRACT above, then:
-  PLANNER_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
-  node .nubos-pilot/bin/np-tools.cjs metrics record \
-    --agent np-planner --tier opus --resolved-model "$PLANNER_MODEL" \
-    --phase "$PHASE" --plan "${milestone_id}-plan" --task "${milestone_id}-planner-run" \
-    --started "$PLANNER_START" --ended "$PLANNER_END" \
-    --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
-    --retry-count 0 --status ok --runtime "$RUNTIME"
+  PLANNER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-planner --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 [ "$PLANNER_KIND" = "openai-compat" ]; then
+    # np-planner is NOT Rule-9-audited and writes ONLY planning artefacts under
+    # .nubos-pilot/ (inside the repo cwd — NOT live code), so it runs off-host
+    # with the default cwd (repo root): Read/Grep/Glob over the whole repo + Write
+    # confined to cwd. NO --allow-bash and NO worktree (there is no live-code
+    # blast radius to isolate, unlike the executor). It writes slice plans into
+    # $milestone_dir exactly as the native planner does — no emit-and-persist
+    # contract needed. spawn-offhost records the metrics row itself.
+    PLANNER_PROMPT="${TMPDIR:-/tmp}/np-offhost-planner-${milestone_id}-i${ITER}.md"
+    # … render the SAME prompt the ACTION CONTRACT above describes (mode,
+    #   milestone, milestone_dir, goal, requirements, prior_findings,
+    #   agent_skills) PLUS $LANG_DIRECTIVE into "$PLANNER_PROMPT" …
+    node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+      --agent np-planner --task-file "$PLANNER_PROMPT" \
+      --phase "$PHASE" --plan "${milestone_id}-plan" >/dev/null
+  else
+    # → execute the Agent call per ACTION CONTRACT above (native host spawn), then:
+    PLANNER_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
+    node .nubos-pilot/bin/np-tools.cjs metrics record \
+      --agent np-planner --tier opus --resolved-model "$PLANNER_MODEL" \
+      --phase "$PHASE" --plan "${milestone_id}-plan" --task "${milestone_id}-planner-run" \
+      --started "$PLANNER_START" --ended "$PLANNER_END" \
+      --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
+      --retry-count 0 --status ok --runtime "$RUNTIME"
+  fi
 
   # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   # ACTION CONTRACT — Step 2b: Spawn np-plan-checker (immediately after 2a)
@@ -265,17 +286,37 @@ for ITER in 1 2; do
   # Agent MUST: read planner output (slice plans inside $milestone_dir),
   # write YAML verdict to $milestone_dir/.tmp-verdict-$ITER.yaml. Orchestrator
   # converts YAML → JSON at $VERDICT_JSON_PATH (next bash section).
+  # Off-host (ADR-0021): when np-plan-checker routes to an openai-compat provider,
+  # run it via spawn-offhost (below) INSTEAD of the Agent tool.
   # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   CHECKER_START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
   CHECKER_MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-plan-checker --profile frontier)
-  # → execute the Agent call per ACTION CONTRACT above, then:
-  CHECKER_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
-  node .nubos-pilot/bin/np-tools.cjs metrics record \
-    --agent np-plan-checker --tier opus --resolved-model "$CHECKER_MODEL" \
-    --phase "$PHASE" --plan "${milestone_id}-plan" --task "${milestone_id}-planner-run" \
-    --started "$CHECKER_START" --ended "$CHECKER_END" \
-    --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
-    --retry-count 0 --status ok --runtime "$RUNTIME"
+  CHECKER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-plan-checker --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 [ "$CHECKER_KIND" = "openai-compat" ]; then
+    # np-plan-checker is NOT Rule-9-audited and writes ONLY the verdict YAML under
+    # $milestone_dir (inside the repo cwd), so it runs off-host with the default
+    # cwd: Read/Grep/Glob over the repo + Write confined to cwd. NO --allow-bash,
+    # NO worktree. It writes $milestone_dir/.tmp-verdict-$ITER.yaml exactly as the
+    # native checker does (the orchestrator's YAML→JSON step is unchanged).
+    # spawn-offhost records the metrics row itself.
+    CHECKER_PROMPT="${TMPDIR:-/tmp}/np-offhost-plan-checker-${milestone_id}-i${ITER}.md"
+    # … render the SAME prompt the ACTION CONTRACT above describes (milestone,
+    #   milestone_dir, agent_skills) PLUS $LANG_DIRECTIVE, and MUST state the exact
+    #   output path $milestone_dir/.tmp-verdict-$ITER.yaml, into "$CHECKER_PROMPT" …
+    node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+      --agent np-plan-checker --task-file "$CHECKER_PROMPT" \
+      --phase "$PHASE" --plan "${milestone_id}-plan" >/dev/null
+  else
+    # → execute the Agent call per ACTION CONTRACT above (native host spawn), then:
+    CHECKER_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
+    node .nubos-pilot/bin/np-tools.cjs metrics record \
+      --agent np-plan-checker --tier opus --resolved-model "$CHECKER_MODEL" \
+      --phase "$PHASE" --plan "${milestone_id}-plan" --task "${milestone_id}-planner-run" \
+      --started "$CHECKER_START" --ended "$CHECKER_END" \
+      --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
+      --retry-count 0 --status ok --runtime "$RUNTIME"
+  fi
 
   VERDICT_JSON_PATH="$milestone_dir/.tmp-verdict-$ITER.json"
   # (verdict JSON: {status: passed|issues_found, findings: [...] })

package/workflows/research-phase.md

@@ -253,8 +253,36 @@ omit the `model:` parameter at spawn (Phase 8 D-22 inherit-pattern).
 ```bash
 RESEARCHER_START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
 RESEARCHER_MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-researcher --profile balanced)
+RESEARCHER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-researcher --kind 2>/dev/null || echo native)
 ```
 
+**Off-host (ADR-0021):** when `np-researcher` routes to an `openai-compat` provider, run the `$SWARM_K` spawns via `spawn-offhost` instead of the abstract host spawn. Two specifics for this audited agent:
+
+- **Synthetic canonical task-id.** `np-researcher` is Rule-9-audited and `dispatchOffHost` requires a `M<NNN>-S<NNN>-T<NNNN>` id for the search-evidence ledger + audit. Research is milestone-level (no real slice/task), so mint the synthetic id `${MILESTONE_ID}-S000-T0000` (the `S000-T0000` suffix is the documented "milestone-level, no slice/task" convention). The injected native `knowledge-search` tool satisfies Rule 9; the orchestrator stamps one `loop-audit-tool-use` per spawn.
+- **Offline only.** The off-host toolset has **no `WebFetch`/`context7`** — an off-host researcher can only do `$MODE == offline` (knowledge-search) research. If `$MODE == online`, keep `np-researcher` native (or accept offline-only research for that spawn). This is a capability bound, surfaced loudly, not a silent degrade.
+
+Each spawn writes its own `$RESEARCH_DIR/spawn-<i>.md` (inside the repo cwd), so it runs write-enabled (NOT `--read-only`), no `--allow-bash`, no worktree.
+
+```bash
+if [ "$RESEARCHER_KIND" = "openai-compat" ]; then
+  OFFHOST_TASK_ID="${MILESTONE_ID}-S000-T0000"
+  i=0
+  while [ "$i" -lt "${SWARM_K:-3}" ]; do
+    R_PROMPT="${TMPDIR:-/tmp}/np-offhost-researcher-${MILESTONE_ID}-${i}.md"
+    # … render spawn-spec i (files_to_read + goal + requirements + seed_delta[i] +
+    #   $SPAWN_SCHEMA + the EXACT output path $RESEARCH_DIR/spawn-${i}.md) PLUS
+    #   $LANG_DIRECTIVE into "$R_PROMPT" …
+    R_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+      --agent np-researcher --task-file "$R_PROMPT" --task-id "$OFFHOST_TASK_ID" --no-audit)
+    R_LOG=$(echo "$R_OUT" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.stringify((JSON.parse(s).toolLog||[]).map(t=>t.name)))}catch{console.log("[]")}})')
+    node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$OFFHOST_TASK_ID" --agent np-researcher --tool-use-log "$R_LOG"
+    i=$((i+1))
+  done
+fi
+```
+
+When `$RESEARCHER_KIND = native`, use the abstract host spawn below (the Phase 8 runtime adapter binds it):
+
 ```text
 Spawn agent=np-researcher tier=sonnet model=$RESEARCHER_MODEL mode=$MODE phase=$PHASE context=$CONTEXT_PATH output=$RESEARCH_PATH
 ```
@@ -351,6 +379,23 @@ Spawn agent=np-researcher-reconciler tier=sonnet model=$RECONCILER_MODEL phase=$
   schema_prompt=$RECONCILER_SCHEMA
 ```
 
+**Off-host (ADR-0021):** when `np-researcher-reconciler` routes to an `openai-compat` provider, run it via `spawn-offhost` instead of the host spawn. The reconciler is NOT Rule-9-audited and writes only the single `$RESEARCH_PATH` (`M<NNN>-RESEARCH.md`) artefact under `.nubos-pilot/` (inside the repo cwd — never live code), so it runs off-host with the default cwd (Read/Grep/Glob over the spawn outputs + Write confined to cwd), **no `--allow-bash`, no worktree**. It writes `$RESEARCH_PATH` exactly as the native reconciler; no emit-and-persist contract is needed. spawn-offhost self-records.
+
+```bash
+RECONCILER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-researcher-reconciler --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 [ "$RECONCILER_KIND" = "openai-compat" ]; then
+  RECONCILER_PROMPT="${TMPDIR:-/tmp}/np-offhost-reconciler-${MILESTONE_ID}.md"
+  # … render the SAME reconciler input (spawn_paths + merge_path + merged_json +
+  #   context_path + $RECONCILER_SCHEMA + the EXACT final_path=$RESEARCH_PATH) PLUS
+  #   $LANG_DIRECTIVE into "$RECONCILER_PROMPT" …
+  node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+    --agent np-researcher-reconciler --task-file "$RECONCILER_PROMPT" \
+    --phase "$PHASE" --plan "$PLAN_ID" --task "$TASK_ID" >/dev/null
+fi
+# else → native host spawn per the block above.
+```
+
 The reconciler classifies each consensus decision's reasoning-trace as `identical | overlapping | orthogonal | unknown` (groupthink detection), picks each contested decision with documented reason, and writes `$RESEARCH_PATH` with `agreement_score` and `contested_count` in frontmatter.
 
 ```bash

package/workflows/scan-codebase.md

@@ -106,9 +106,27 @@ is runtime-agnostic — pick whichever dispatch mechanism your host supports.
 
 ```bash
 PROSE_FILE=$(mktemp -t np-prose-XXXXXX.json)
-# Host dispatches agent with buildDocumenterPrompt(facts) and writes JSON
-# to $PROSE_FILE. Validate JSON before proceeding.
-python -c 'import json,sys; json.load(open(sys.argv[1]))' "$PROSE_FILE"
+# Off-host (ADR-0021): when np-codebase-documenter routes to an openai-compat
+# provider (agent_routing), run it via spawn-offhost INSTEAD of the native host
+# dispatch below.
+DOCUMENTER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-codebase-documenter --kind 2>/dev/null || echo native)
+if [ "$DOCUMENTER_KIND" = "openai-compat" ]; then
+  # np-codebase-documenter is NOT Rule-9-audited and writes ONLY
+  # .nubos-pilot/codebase/ artefacts (inside the repo cwd — NOT live code), so it
+  # runs off-host with the default cwd (repo root): Read/Grep/Glob over the repo +
+  # Write confined to cwd. NO --allow-bash and NO worktree (no live-code blast
+  # radius to isolate). The agent writes its module doc JSON itself, inside cwd.
+  DOC_PROMPT="${TMPDIR:-/tmp}/np-offhost-documenter-${MODULE_ID}.md"
+  # … render the SAME buildDocumenterPrompt(facts) prompt the native dispatch
+  #   below describes PLUS $LANG_DIRECTIVE into "$DOC_PROMPT" …
+  node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+    --agent np-codebase-documenter --task-file "$DOC_PROMPT" \
+    --phase scan >/dev/null
+else
+  # Host dispatches agent with buildDocumenterPrompt(facts) and writes JSON
+  # to $PROSE_FILE. Validate JSON before proceeding.
+  python -c 'import json,sys; json.load(open(sys.argv[1]))' "$PROSE_FILE"
+fi
 ```
 
 Batch pacing: the user opted into batches during Step 1. Between batches,

package/workflows/validate-phase.md

@@ -129,6 +129,8 @@ The auditor reads `REQUIREMENTS.md`, filters to the milestone's declared require
 ```bash
 START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
 MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-nyquist-auditor --profile frontier)
+AUDITOR_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-nyquist-auditor --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")}})')
 
 # Build the read list from the init payload:
 SLICE_PLANS=$(find "$MILESTONE_DIR/slices" -maxdepth 2 -name 'S*-PLAN.md' 2>/dev/null)
@@ -136,19 +138,34 @@ SLICE_SUMMARIES=$(find "$MILESTONE_DIR/slices" -maxdepth 2 -name 'S*-SUMMARY.md'
 TASK_PLANS=$(find "$MILESTONE_DIR/slices" -path '*/tasks/*/T*-PLAN.md' 2>/dev/null)
 TASK_SUMMARIES=$(find "$MILESTONE_DIR/slices" -path '*/tasks/*/T*-SUMMARY.md' 2>/dev/null)
 
-# Spawn agent=np-nyquist-auditor model=$MODEL
-#   input: slice_plans, slice_summaries, task_plans, task_summaries, validation_path,
-#          template_path, requirements_path, milestone_dir, milestone, milestone_id
-#   output: $VALIDATION_PATH with per-requirement Nyquist scoring
-#           (COVERED / UNDER_SAMPLED / UNCOVERED), using templates/VALIDATION.md as skeleton.
-
-END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
-node .nubos-pilot/bin/np-tools.cjs metrics record \
-  --agent np-nyquist-auditor --tier haiku --resolved-model "$MODEL" \
-  --phase "$PHASE" --plan "$PLAN_ID" --task "$TASK_ID" \
-  --started "$START" --ended "$END" \
-  --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
-  --retry-count 0 --status ok --runtime "$RUNTIME"
+if [ "$AUDITOR_KIND" = "openai-compat" ]; then
+  # Off-host (ADR-0021): np-nyquist-auditor is NOT Rule-9-audited and writes ONLY
+  # $VALIDATION_PATH (M<NNN>-VALIDATION.md) under .nubos-pilot/ (inside the repo
+  # cwd — NOT live code), so it runs off-host with the default cwd: Read/Grep/Glob
+  # over the repo + Write confined to cwd. NO --allow-bash, NO worktree. It writes
+  # the file from templates/VALIDATION.md exactly as the native auditor does (the
+  # orchestrator's output-lint check is unchanged). spawn-offhost self-records.
+  AUDITOR_PROMPT="${TMPDIR:-/tmp}/np-offhost-nyquist-${MILESTONE_ID}.md"
+  # … render the SAME auditor prompt (read list above + $VALIDATION_SCHEMA +
+  #   template_path + requirements_path + the EXACT output path $VALIDATION_PATH)
+  #   PLUS $LANG_DIRECTIVE into "$AUDITOR_PROMPT" …
+  node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+    --agent np-nyquist-auditor --task-file "$AUDITOR_PROMPT" \
+    --phase "$PHASE" --plan "$PLAN_ID" --task "$TASK_ID" >/dev/null
+else
+  # Spawn agent=np-nyquist-auditor model=$MODEL (native host spawn)
+  #   input: slice_plans, slice_summaries, task_plans, task_summaries, validation_path,
+  #          template_path, requirements_path, milestone_dir, milestone, milestone_id
+  #   output: $VALIDATION_PATH with per-requirement Nyquist scoring
+  #           (COVERED / UNDER_SAMPLED / UNCOVERED), using templates/VALIDATION.md as skeleton.
+  END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
+  node .nubos-pilot/bin/np-tools.cjs metrics record \
+    --agent np-nyquist-auditor --tier haiku --resolved-model "$MODEL" \
+    --phase "$PHASE" --plan "$PLAN_ID" --task "$TASK_ID" \
+    --started "$START" --ended "$END" \
+    --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
+    --retry-count 0 --status ok --runtime "$RUNTIME"
+fi
 ```
 
 ## Validation Gate

package/workflows/verify-work.md

@@ -81,6 +81,23 @@ Spawn `agents/np-verifier.md` (tier: sonnet, READ-ONLY tools) with:
 
 The agent emits a structured verdict per SC: Pass | Fail | Needs-User-Confirm | Defer (never invents a SC, never edits source).
 
+**Off-host (ADR-0021):** when `np-verifier` routes to an `openai-compat` provider, run it via `spawn-offhost --read-only` instead of the host spawn. The verifier never edits source and **emits** its per-SC verdict as the final message — exactly the contract the native path already consumes — so it needs no worktree, no Bash, no Write. Pass `--output-schema verification` for the dispatch-level lint hook, then feed the returned `.content` (the emitted verdict) into the SAME Pass-1 `emit-draft` / Pass-2 `record-sc` persistence below; `VERIFICATION.md` is produced exactly as for the native agent.
+
+```bash
+VERIFIER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-verifier --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 [ "$VERIFIER_KIND" = "openai-compat" ]; then
+  VERIFIER_PROMPT="${TMPDIR:-/tmp}/np-offhost-verifier-${MILESTONE_ID}.md"
+  # … render the SAME spawn prompt (files_to_read + success_criteria +
+  #   $VERIFICATION_SCHEMA) PLUS $LANG_DIRECTIVE into "$VERIFIER_PROMPT" …
+  VERIFIER_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+    --agent np-verifier --task-file "$VERIFIER_PROMPT" --read-only \
+    --output-schema verification --phase "$PHASE")
+  # The emitted verdict is `.content` of $VERIFIER_OUT — it drives emit-draft / record-sc below.
+fi
+# else → native host spawn per the block above.
+```
+
 Persist the deterministic draft:
 
 ```bash