nubos-pilot 0.6.0 → 0.6.2

package/templates/claude/payload/hooks/np-statusline.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const BAR_WIDTH = 10;
+const AUTOCOMPACT_BUFFER = 0.835;
+const DEFAULT_WINDOW = 200_000;
+const EXTENDED_WINDOW = 1_000_000;
+
+function readStdinJson() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve({});
+    let buf = '';
+    process.stdin.setEncoding('utf-8');
+    const timer = setTimeout(() => {
+      try { process.stdin.removeAllListeners(); } catch {}
+      resolve(safeParse(buf));
+    }, 500);
+    process.stdin.on('data', (chunk) => { buf += chunk; });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(safeParse(buf)); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(safeParse(buf)); });
+  });
+}
+
+function safeParse(s) {
+  try { return s ? JSON.parse(s) : {}; } catch { return {}; }
+}
+
+function modelWindow(payload) {
+  const id = String((payload && payload.model && payload.model.id) || '');
+  const name = String((payload && payload.model && payload.model.display_name) || '');
+  const s = (id + ' ' + name).toLowerCase();
+  if (s.includes('[1m]') || /\b1m\b/.test(s) || s.includes('1-m') || s.includes('1000k')) {
+    return EXTENDED_WINDOW;
+  }
+  return DEFAULT_WINDOW;
+}
+
+function lastUsage(transcriptPath) {
+  if (!transcriptPath) return null;
+  let raw;
+  try { raw = fs.readFileSync(transcriptPath, 'utf-8'); } catch { return null; }
+  const lines = raw.split('\n');
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    const usage = obj && obj.message && obj.message.usage;
+    if (!usage || typeof usage !== 'object') continue;
+    const input = Number(usage.input_tokens || 0);
+    const cacheCreation = Number(usage.cache_creation_input_tokens || 0);
+    const cacheRead = Number(usage.cache_read_input_tokens || 0);
+    const output = Number(usage.output_tokens || 0);
+    const total = input + cacheCreation + cacheRead + output;
+    if (!Number.isFinite(total) || total <= 0) continue;
+    return { input, cacheCreation, cacheRead, output, total };
+  }
+  return null;
+}
+
+function renderBar(used, limit) {
+  const fraction = Math.max(0, Math.min(1, used / limit));
+  const ofUsable = Math.max(0, Math.min(1, fraction / AUTOCOMPACT_BUFFER));
+  const pct = Math.round(ofUsable * 100);
+  const filled = Math.round(ofUsable * BAR_WIDTH);
+  const bar = '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
+  let color = '\x1b[32m';
+  let suffix = '';
+  if (pct >= 80) { color = '\x1b[31m'; suffix = ' 💀'; }
+  else if (pct >= 65) { color = '\x1b[38;5;208m'; }
+  else if (pct >= 50) { color = '\x1b[33m'; }
+  return color + bar + '\x1b[0m ' + pct + '%' + suffix;
+}
+
+function terminalWidth() {
+  const envCols = Number(process.env.COLUMNS);
+  if (Number.isFinite(envCols) && envCols > 0) return envCols;
+  if (process.stdout && process.stdout.columns) return process.stdout.columns;
+  try {
+    const { execSync } = require('node:child_process');
+    const out = execSync('tput cols', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const n = Number(out);
+    if (Number.isFinite(n) && n > 0) return n;
+  } catch {}
+  return 120;
+}
+
+function visibleLen(s) {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, '');
+  let w = 0;
+  for (const ch of stripped) {
+    const cp = ch.codePointAt(0);
+    if (cp > 0xFFFF) w += 2;
+    else w += 1;
+  }
+  return w;
+}
+
+function centerLine(line) {
+  const width = terminalWidth();
+  const pad = Math.max(0, Math.floor((width - visibleLen(line)) / 2));
+  return ' '.repeat(pad) + line;
+}
+
+function writeBridge(payload, usage, limit) {
+  const sid = payload && payload.session_id;
+  if (!sid) return;
+  const bridgePath = path.join(os.tmpdir(), 'claude-ctx-' + String(sid).replace(/[^a-zA-Z0-9._-]/g, '_') + '.json');
+  const data = {
+    session_id: sid,
+    used: usage.total,
+    limit: limit,
+    usable_remaining_pct: Math.max(0, Math.round(((AUTOCOMPACT_BUFFER * limit) - usage.total) / (AUTOCOMPACT_BUFFER * limit) * 100)),
+    updated_at: new Date().toISOString(),
+  };
+  try { fs.writeFileSync(bridgePath, JSON.stringify(data)); } catch {}
+}
+
+(async () => {
+  let payload = {};
+  try { payload = await readStdinJson(); } catch { payload = {}; }
+  const limit = modelWindow(payload);
+  const usage = lastUsage(payload && payload.transcript_path);
+  const prefix = '\x1b[38;5;33mnubos-pilot\x1b[0m';
+  if (!usage) {
+    process.stdout.write(centerLine(prefix));
+    return;
+  }
+  writeBridge(payload, usage, limit);
+  const bar = renderBar(usage.total, limit);
+  const modelName = (payload && payload.model && payload.model.display_name) || '';
+  const tail = modelName ? '  \x1b[2m' + modelName + '\x1b[0m' : '';
+  process.stdout.write(centerLine(prefix + '  ctx ' + bar + tail));
+})().catch(() => {
+  process.stdout.write('\x1b[38;5;33mnubos-pilot\x1b[0m');
+});

package/workflows/add-todo.md

@@ -47,10 +47,10 @@ through `lib/layout.cjs.slugify` (strips to `[a-z0-9-]` only;
 filename-injection mitigation) and validates the description length
 (<= 500 chars) before any filesystem write occurs.
 
-**Text-mode routing.** If `text_mode == true`, skip every `np-tools.cjs askuser`
-call below and render questions as plain-text numbered lists in the main
-chat. Auto-enabled in Claude Code (CLAUDECODE=1); opt-in via
-`.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ## Create Pending Dir
 

package/workflows/discuss-phase.md

@@ -34,22 +34,20 @@ Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`,
 `milestone_context_path`, `has_context`, `has_milestone_dir`, `goal`,
 `requirements`, `agent_skills`, `mode`, `text_mode`, `text_mode_source`.
 
-**Text-mode routing (SSOT = INIT payload).** If `text_mode` is `true`, do
-**not** shell out to `np-tools.cjs askuser` for any prompt in this workflow.
-Present every question inline as a plain-text numbered list and wait for the
-user's reply in the main chat. This is the correct path whenever:
-
-- `text_mode_source == "runtime"` → Claude Code Bash has no TTY and cannot
-  forward interactive menu selections; the askuser marker-block protocol
-  never completes.
-- `text_mode_source == "config"` → the user explicitly opted into text mode
-  via `.nubos-pilot/config.json` → `workflow.text_mode`.
-
-When text mode is active, skip every `node .nubos-pilot/bin/np-tools.cjs
-askuser …` block below and substitute the plain-text equivalent. Collect the
-answers from the user's reply, then proceed to the next step as normal. The
-rest of the workflow (validation, canonical-ref accumulation, template
-render, commit) is unchanged.
+**Askuser routing (SSOT = INIT payload).** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a **spec**, not a literal command. Pick the path once at Initialize:
+
+- **Claude Code runtime** (you are running inside Claude Code — the `AskUserQuestion` tool is available to you): **do not** shell out to `np-tools.cjs askuser`. Parse the JSON spec inside each askuser block and call the native `AskUserQuestion` tool directly with one question entry:
+  - `type: "select"` → `{ question, header, multiSelect: false, options: [{label, description}...] }`
+  - `type: "multiselect"` → `{ question, header, multiSelect: true, options: [{label, description}...] }`
+  - `type: "confirm"` → single question with `options: [{label: "Yes"}, {label: "No"}]`, `multiSelect: false`
+  - `type: "input"` → ask as a plain free-form question in the chat; the user replies inline
+  Use a short `header` (≤12 chars) that labels the category, e.g. `"Discuss"`, `"Scope"`, `"Overwrite?"`. This is the default path and gives the user a real selection menu.
+
+- **`text_mode == true`** (INIT payload): skip every askuser block and render every question inline as a plain-text numbered list; the user replies with the number. This path is opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+
+- **Other runtime with TTY** (Codex, Gemini, …): run the shell `node .nubos-pilot/bin/np-tools.cjs askuser --json '…'` block verbatim.
+
+`text_mode_source` in the INIT payload (`config` / `default`) is informational only — it does not change the routing above.
 
 If the user passed `--assumptions`, route to
 `workflows/discuss-phase-assumptions.md` and exit this workflow.
@@ -142,33 +140,19 @@ Capture the idea in a "Deferred Ideas" section. Don't lose it, don't act on it.
 ## Answer Validation
 
 <answer_validation>
-**Routing decision (made once at Initialize):** If INIT payload
-`text_mode == true`, skip every `np-tools.cjs askuser` call in this workflow
-and use plain-text numbered lists in the main chat instead. The
-`text_mode_source` field (`runtime` / `config` / `default`) tells you why
-text mode is active — it is informational only and does not change behavior.
-
-**When text_mode is false and askuser is used — per-prompt validation:**
-1. If `askuser` exits with structured error `askuser-no-tty` (exit code 1,
-   stderr JSON with `"code":"askuser-no-tty"`), that means the runtime
-   detection missed something; **skip retry** and treat the remainder of the
-   workflow as text-mode (plain-text numbered lists).
-2. If the response is empty or whitespace-only (exit 0 but no value), retry
-   the question once with the same parameters.
-3. If still empty, present the options as a plain-text numbered list and ask
-   the user to type their choice number.
+**Routing was decided at Initialize** (see "Askuser routing" section above). This section documents per-prompt validation only.
+
+**Claude Code path (`AskUserQuestion` tool):** the tool guarantees a non-empty selection; no validation needed.
+
+**Shell askuser path (other runtimes with TTY):**
+1. If `askuser` exits with structured error `askuser-no-tty` (exit code 1, stderr JSON with `"code":"askuser-no-tty"`), that means the runtime detection missed something; **skip retry** and treat the remainder of the workflow as text-mode (plain-text numbered lists).
+2. If the response is empty or whitespace-only (exit 0 but no value), retry the question once with the same parameters.
+3. If still empty, present the options as a plain-text numbered list and ask the user to type their choice number.
 Never proceed with an empty answer.
 
-**Enable text mode:**
-- Auto-detected: any Claude Code session (`CLAUDECODE=1` /
-  `CLAUDE_CODE_ENTRYPOINT` set) — default behavior, no user action needed.
-- Opt-in per project: set `workflow.text_mode: true` in
-  `.nubos-pilot/config.json`.
-- Opt-out per project: set `workflow.text_mode: false` in
-  `.nubos-pilot/config.json` (overrides runtime detection).
+**Text-mode (numbered-list path):** user reply must parse as a valid index (1-N) for select/multiselect, `y/n` for confirm, or any non-empty string for input. Re-ask on invalid input.
 
-Text mode applies to ALL workflows that emit `text_mode` in their INIT
-payload, not just discuss-phase.
+**Enable text mode** (force the numbered-list path regardless of runtime): set `workflow.text_mode: true` in `.nubos-pilot/config.json`. Useful for remote-control setups or runtimes where neither `AskUserQuestion` nor TTY stdin are reliable.
 </answer_validation>
 
 ## Process
@@ -386,18 +370,66 @@ If the template lacks a key, `render()` throws
 `NubosPilotError('template-missing-key', …)` — the workflow must not swallow
 that error. Fix the template or the accumulator, don't mask the failure.
 
+### Step 6b: Extract + persist Success Criteria (np-sc-extractor)
+
+CONTEXT.md now captures the decisions. Success Criteria in `roadmap.yaml` are still empty for this milestone — downstream `/np:verify-work` reads them from there, so we must persist them now. Spawn the SC-extractor (haiku) to derive observable SCs from goal + requirements + CONTEXT.md + any pre-existing `M<NNN>-ROADMAP.md` / `M<NNN>-META.json` sidecars, and call `update-phase-meta` to write them.
+
+```bash
+SC_START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
+SC_MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-sc-extractor --profile balanced)
+
+REQS_PATH=".nubos-pilot/REQUIREMENTS.md"
+[[ -f "$REQS_PATH" ]] || REQS_PATH=".planning/REQUIREMENTS.md"
+
+EXISTING_SC_JSON=$(node -e '
+  const r = require("./lib/roadmap.cjs");
+  const p = r.getPhase(process.argv[1]);
+  process.stdout.write(JSON.stringify(p.success_criteria || []));
+' "$PHASE")
+
+# Spawn agent=np-sc-extractor tier=haiku model=$SC_MODEL milestone=$PHASE
+#   input: milestone=$PHASE, milestone_id=$MILESTONE_ID, milestone_dir=$MILESTONE_DIR,
+#          context_path=$CONTEXT_PATH, requirements_path=$REQS_PATH,
+#          existing_success_criteria=$EXISTING_SC_JSON
+#   output: calls `np-tools.cjs update-phase-meta $PHASE --stdin` with
+#           {"success_criteria": [{id:"SC-N", text:"..."}, ...]} and prints summary.
+
+SC_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
+node .nubos-pilot/bin/np-tools.cjs metrics record \
+  --agent np-sc-extractor --tier haiku --resolved-model "$SC_MODEL" \
+  --phase "$PHASE" --plan "${MILESTONE_ID}-sc" --task "${MILESTONE_ID}-sc-extract" \
+  --started "$SC_START" --ended "$SC_END" \
+  --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
+  --retry-count 0 --status ok --runtime "$RUNTIME"
+```
+
+After the spawn, sanity-check that `success_criteria` is non-empty:
+
+```bash
+SC_COUNT=$(node -e '
+  const r = require("./lib/roadmap.cjs");
+  const p = r.getPhase(process.argv[1]);
+  process.stdout.write(String((p.success_criteria || []).length));
+' "$PHASE")
+if [[ "$SC_COUNT" -lt 1 ]]; then
+  echo "ERROR: np-sc-extractor produced no success_criteria for $MILESTONE_ID — refusing to continue." >&2
+  exit 1
+fi
+```
+
+A failure here is loud by design: `/np:verify-work` and `/np:validate-phase` depend on a populated `success_criteria[]`. If the extractor cannot derive any, fix the goal/requirements/CONTEXT.md inputs before retrying.
+
 ### Step 7: Commit respecting config.commit_docs
 
 ```bash
 COMMIT_DOCS=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.commit_docs 2>/dev/null || echo "true")
 if [[ "$COMMIT_DOCS" == "true" ]]; then
-  git add "$CONTEXT_PATH"
-  git commit -m "docs($MILESTONE_ID): capture milestone context"
+  git add "$CONTEXT_PATH" .nubos-pilot/roadmap.yaml .nubos-pilot/ROADMAP.md
+  git commit -m "docs($MILESTONE_ID): capture milestone context + success criteria"
 fi
 ```
 
-If `workflow.commit_docs` is false, leave the file uncommitted — the user is
-opting into manual commit gating.
+If `workflow.commit_docs` is false, leave both CONTEXT.md and the roadmap edits uncommitted — the user is opting into manual commit gating.
 
 ### Step 8: Confirm and next steps
 

package/workflows/discuss-project.md

@@ -61,6 +61,11 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 narrative status updates, and the prose written into PROJECT.md sections.
 Supersedes CLAUDE.md managed block.
 
+**Askuser routing.** The "Use `np-tools.cjs askuser` for every prompt" rule below is SC-5 gateway enforcement — the JSON spec must pass through np-tools for logging/validation. Pick the presentation path:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip shell askuser calls and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute `node .nubos-pilot/bin/np-tools.cjs askuser --json '…'` directly.
+
 Parse: `mode`, `sub_mode` (`bootstrap` or `refresh`), `project_md_exists`,
 `scan_context`, `questions[]`, `required_fields[]`.
 

package/workflows/execute-phase.md

@@ -32,11 +32,10 @@ directive in CLAUDE.md managed block.
 
 Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `waves[]` (each with `wave` (= slice number), `slice_id`, `slice_full_id`, `slice_dir`, `tasks[]`), `total_tasks`, `slice_count`, `executor_tier`, `text_mode`, `text_mode_source`, `agent_skills`.
 
-**Text-mode routing.** If `text_mode == true`, skip every `np-tools.cjs askuser`
-call below (including the orphan-checkpoint and empty-milestone prompts)
-and render the options as a plain-text numbered list in the main chat.
-Auto-enabled in Claude Code (CLAUDECODE=1); opt-in via
-`.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below (including the orphan-checkpoint and empty-milestone prompts) is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 `PLAN_ID` is iterated per slice as `${milestone_id}-${slice_id}` (e.g. `M001-S001`). `TASK_ID` is iterated from each slice's `tasks[]` (e.g. `M001-S001-T0001`).
 

package/workflows/new-milestone.md

@@ -62,11 +62,10 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 user-facing output, and any prose written into milestone artefacts (YAML
 keys, IDs, and identifiers stay canonical English). Supersedes CLAUDE.md.
 
-**Text-mode routing.** If INIT payload `text_mode == true`, skip every
-`np-tools.cjs askuser` call below and render each question as a plain-text
-prompt in the main chat; collect the answer inline. Auto-enabled in Claude
-Code (CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` →
-`workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 Payload: three questions — `milestone_name`, `milestone_goal`, `create_req_prefix` (confirm).
 

package/workflows/new-project.md

@@ -126,11 +126,10 @@ user-facing output, and any narrative prose written into PROJECT.md /
 REQUIREMENTS.md (field names and YAML keys stay canonical English).
 Supersedes CLAUDE.md.
 
-**Text-mode routing.** If INIT payload `text_mode == true`, skip every
-`np-tools.cjs askuser` call below and render each question as a plain-text
-prompt in the main chat; collect the user's answer inline and move on.
-Auto-enabled in Claude Code (CLAUDECODE=1); opt-in via
-`.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ```bash
 ANS_PROJECT_NAME=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{"type":"input","prompt":"Project name?"}')

package/workflows/note.md

@@ -52,16 +52,16 @@ into `$TEXT`. Empty text after stripping is an error — there is no
 `list` or `promote` subcommand here (deferred to a future
 capture-management plan).
 
-**Text-mode routing.** Resolve once at the start:
+**Askuser routing.** Resolve once at the start:
 
 ```bash
 TEXT_MODE=$(node .nubos-pilot/bin/np-tools.cjs text-mode 2>/dev/null || echo false)
 ```
 
-If `$TEXT_MODE == "true"`, skip every `np-tools.cjs askuser` call below and
-render questions as plain-text numbered lists in the main chat. Auto-enabled
-in Claude Code (CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` →
-`workflow.text_mode`.
+Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`$TEXT_MODE == "true"`**: skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ## Compute Paths
 

package/workflows/plan-phase.md

@@ -88,10 +88,10 @@ prompts as a system-level rule. This supersedes any directive in CLAUDE.md.
 
 Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `milestone_context_path`, `milestone_roadmap_path`, `milestone_meta_path`, `name`, `goal`, `requirements`, `success_criteria`, `has_context`, `has_roadmap`, `has_meta`, `existing_slices[]`, `planner_tier`, `checker_tier`, `text_mode`, `text_mode_source`, `agent_skills`.
 
-**Text-mode routing.** If `text_mode == true`, skip every `np-tools.cjs askuser`
-call below and present questions as plain-text numbered lists in the main
-chat. Auto-enabled in Claude Code (CLAUDECODE=1); opt-in per-project via
-`.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 `PLAN_ID` and `TASK_ID` default to `${milestone_id}-plan` / `${milestone_id}-planner-run` for the metrics records.
 
@@ -118,6 +118,29 @@ case "$CHOICE" in
 esac
 ```
 
+### Gate 1b — Empty success_criteria
+
+If `success_criteria.length == 0`:
+
+```bash
+CHOICE=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{
+  "type": "select",
+  "header": "No SCs in roadmap.yaml",
+  "question": "Milestone has no success_criteria in roadmap.yaml. Downstream /np:verify-work will produce an empty VERIFICATION.md. How to proceed?",
+  "options": [
+    {"label": "Run /np:discuss-phase first", "description": "Recommended — np-sc-extractor derives SCs from CONTEXT.md + goal + requirements and writes them to roadmap.yaml."},
+    {"label": "Continue anyway",             "description": "Plan the milestone without SCs; you must back-fill them before /np:verify-work."},
+    {"label": "Abort",                       "description": "Exit without changes."}
+  ]
+}')
+case "$CHOICE" in
+  "Run /np:discuss-phase"*) echo "Run: /np:discuss-phase $PHASE"; exit 0 ;;
+  "Abort")                  exit 0 ;;
+esac
+```
+
+The planner will still emit a plan without SCs, but you are consciously opting into a known-broken verify-work path. The safer default is always to re-run `/np:discuss-phase` — Step 6b there spawns `np-sc-extractor` which populates `roadmap.yaml` directly.
+
 ### Gate 2 — Missing slice RESEARCH.md
 
 Research is per-slice  (`slices/S<NNN>/S<NNN>-RESEARCH.md`). The planner can plan without research, but if the roadmap config requires it, ask. The `--research` flag auto-dispatches `/np:research-phase` before re-entering.

package/workflows/propose-milestones.md

@@ -70,7 +70,10 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
 `$LANG_DIRECTIVE` is authoritative. Obey it for askuser prompt texts, AI-facing reasoning shown to the user, and any narrative prose. YAML keys, milestone IDs, and status strings stay canonical English.
 
-**Text-mode routing.** If INIT payload `text_mode == true`, skip every `np-tools.cjs askuser` call below and render each question as a plain-text prompt in the main chat; collect the answer inline. Auto-enabled in Claude Code (CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 Parse INIT for: `milestones[]` (each with `id`, `name`, `goal`, `status`, `classification`, `slice_count`, `context`, `touchable`, `modification_requires_confirm`), `project_md`, `requirements_md`, `project_has_tbd`, `current_state_milestone`, `next_milestone_number`, `guidance`.
 

package/workflows/research-phase.md

@@ -107,10 +107,10 @@ project language. This supersedes CLAUDE.md.
 `RUNTIME` is resolved once here and reused by the metrics-record call at the
 researcher spawn site (Step 4) per D-06 workflow-writer pattern.
 
-**Text-mode routing.** If `text_mode == true` in the payload below, skip every
-`np-tools.cjs askuser` call in this workflow and render questions as
-plain-text numbered lists in the main chat. Auto-enabled in Claude Code
-(CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 The payload shape:
 

package/workflows/resume-work.md

@@ -24,10 +24,10 @@ askuser prompts. When spawning the np-executor to continue a checkpoint,
 pass `$LANG_DIRECTIVE` into the spawn prompt so resumed task summaries
 follow the project language. Supersedes CLAUDE.md.
 
-**Text-mode routing.** If INIT payload `text_mode == true`, skip every
-`np-tools.cjs askuser` call below and render prompts as plain-text numbered
-lists in the main chat. Auto-enabled in Claude Code (CLAUDECODE=1); opt-in
-via `.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ## Execution
 

package/workflows/session-report.md

@@ -62,10 +62,10 @@ canonical English. Supersedes CLAUDE.md.
 TEXT_MODE=$(node .nubos-pilot/bin/np-tools.cjs text-mode 2>/dev/null || echo false)
 ```
 
-If `$TEXT_MODE == "true"`, skip every `np-tools.cjs askuser` call below and
-render questions as plain-text numbered lists in the main chat. Auto-enabled
-in Claude Code (CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` →
-`workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`$TEXT_MODE == "true"`** (from the check above, or INIT payload `text_mode == true`): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 The filename format is `YYYY-MM-DDTHHMM-session-report.md` (D-17 —
 4-char HHMM, no seconds, local time) so reports sort

package/workflows/validate-phase.md

@@ -33,10 +33,10 @@ field names stay English. Supersedes CLAUDE.md.
 
 Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`, `slice_uat`, `text_mode`, `text_mode_source`.
 
-**Text-mode routing.** If `text_mode == true`, skip every `np-tools.cjs askuser`
-call in this workflow and render options as plain-text numbered lists in
-the main chat. Auto-enabled in Claude Code (CLAUDECODE=1); opt-in via
-`.nubos-pilot/config.json` → `workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ```bash
 MILESTONE_ID=$(echo "$INIT" | jq -r '.milestone_id')

package/workflows/verify-work.md

@@ -31,11 +31,10 @@ CLAUDE.md.
 
 Parse: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`, `success_criteria`, `draft_results`, `verification_path`, `slice_uat`, `verifier_tier`, `text_mode`, `text_mode_source`, `agent_skills`.
 
-**Text-mode routing.** If `text_mode == true`, skip every `np-tools.cjs askuser`
-call below (including the Pass-2 `needs_user_confirm` gate) and render the
-options as a plain-text numbered list in the main chat. Auto-enabled in
-Claude Code (CLAUDECODE=1); opt-in via `.nubos-pilot/config.json` →
-`workflow.text_mode`.
+**Askuser routing.** Every `node .nubos-pilot/bin/np-tools.cjs askuser …` block below (including the Pass-2 `needs_user_confirm` gate) is a spec, not a literal command. Pick the path once at Initialize:
+- **Claude Code** (native `AskUserQuestion` tool is available): parse the JSON spec and call `AskUserQuestion` directly. `select` → `multiSelect: false`; `multiselect` → `multiSelect: true`; `confirm` → `options: [{label: "Yes"}, {label: "No"}]`; `input` → ask free-form in chat. Use a short `header` (≤12 chars).
+- **`text_mode == true`** (INIT payload): skip every askuser block and render questions as plain-text numbered lists. Opt-in via `.nubos-pilot/config.json` → `workflow.text_mode`.
+- **Other runtime with TTY** (Codex, Gemini, …): execute the shell `askuser` block verbatim.
 
 ## Pass 1 — verifier agent