nubos-pilot 0.5.2 → 0.5.3

package/bin/install.js

@@ -16,6 +16,7 @@ const runtimeDetectMod = require('../lib/install/runtime-detect.cjs');
 const backupMod = require('../lib/install/backup.cjs');
 const registryMod = require('../lib/install/runtimes-registry.cjs');
 const runtimeAssetsMod = require('../lib/install/runtime-assets.cjs');
+const languageMod = require('../lib/language.cjs');
 
 const cyan = '\x1b[36m', green = '\x1b[32m', yellow = '\x1b[33m',
       red = '\x1b[31m', blue = '\x1b[38;5;33m',
@@ -64,22 +65,11 @@ function _autoAskUser(spec) {
   });
 }
 
-const LANG_DIRECTIVES = {
-  de: 'Sprache: **Deutsch.** Jede nubos-pilot Slash-Command-Ausgabe, jede Frage an den User und jedes Statusupdate in allen `/np:*` Workflows ist auf Deutsch zu schreiben — inklusive Fehlermeldungen und Klärungsfragen. Nur Code, Bash-Kommandos, Tool-Outputs und Commit-Messages bleiben wie sie sind.',
-  en: 'Language: **English.** All `/np:*` slash-command output, askuser prompts and status updates respond in English.',
-};
-
-function _langDirective(responseLanguage) {
-  const lang = String(responseLanguage || 'en').toLowerCase();
-  if (LANG_DIRECTIVES[lang]) return LANG_DIRECTIVES[lang];
-  return 'Language: respond in the ISO-639 language `' + lang + '` for all `/np:*` slash-command output, askuser prompts and status updates.';
-}
-
 function _managedBlockInner(responseLanguage) {
   return (
     'This project uses [nubos-pilot](https://github.com/nubos/nubos-pilot)'
     + ' for planning and execution.\n\n'
-    + _langDirective(responseLanguage)
+    + languageMod.buildDirective(responseLanguage)
     + '\n\nRun `npx nubos-pilot doctor` to check install integrity.'
   );
 }

package/bin/np-tools/_commands.cjs

@@ -43,6 +43,7 @@ const COMMANDS = [
   { name: 'askuser',         category: 'Utility', description: 'Capability-layer prompt wrapper (reads spec JSON, returns chosen label)' },
   { name: 'commit',          category: 'Utility', description: 'Atomic git commit wrapper with gitignore-guard' },
   { name: 'config-get',      category: 'Utility', description: 'Read value from .nubos-pilot/config.json by dotted key path' },
+  { name: 'lang-directive',  category: 'Utility', description: 'Print workflow language directive from config.response_language (SSOT)' },
   { name: 'generate-slug',   category: 'Utility', description: 'Slugify text via lib/layout.cjs.slugify' },
   { name: 'stats',           category: 'Utility', description: 'Aggregated project stats (roadmap + STATE + git + metrics JSON shape)' },
 

package/bin/np-tools/lang-directive.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+const languageMod = require('../../lib/language.cjs');
+const { NubosPilotError } = require('../../lib/core.cjs');
+
+function _usage() {
+  return 'Usage:\n  np-tools.cjs lang-directive [--json] [--lang <code>]';
+}
+
+function _emitError(err, stderr) {
+  const code = err && err.name === 'NubosPilotError' ? err.code : 'lang-directive-internal-error';
+  const message = (err && err.message) || String(err);
+  const details = (err && err.details) || null;
+  stderr.write(JSON.stringify({ code, message, details }) + '\n');
+}
+
+function run(argv, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const stderr = context.stderr || process.stderr;
+  const args = Array.isArray(argv) ? argv.slice() : [];
+
+  let wantJson = false;
+  let override = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') { wantJson = true; continue; }
+    if (a === '--lang') { override = args[++i] || null; continue; }
+    if (a.startsWith('--lang=')) { override = a.slice('--lang='.length); continue; }
+    if (a === '-h' || a === '--help') {
+      stdout.write(_usage() + '\n');
+      return 0;
+    }
+    stderr.write(JSON.stringify({
+      code: 'lang-directive-unknown-arg',
+      message: 'Unknown argument: ' + a,
+      details: { arg: a },
+    }) + '\n');
+    return 1;
+  }
+
+  try {
+    const language = override != null
+      ? languageMod.normalizeLanguage(override)
+      : languageMod.resolveLanguage(cwd);
+    const directive = languageMod.buildDirective(language);
+    if (wantJson) {
+      stdout.write(JSON.stringify({ language, directive }) + '\n');
+    } else {
+      stdout.write(directive + '\n');
+    }
+    return 0;
+  } catch (err) {
+    _emitError(err, stderr);
+    return 1;
+  }
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  process.exit(run(process.argv.slice(2)));
+}

package/bin/np-tools/lang-directive.test.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const subcmd = require('./lang-directive.cjs');
+
+function _capture() {
+  let out = '';
+  let err = '';
+  const stdout = { write: (s) => { out += s; return true; } };
+  const stderr = { write: (s) => { err += s; return true; } };
+  return { stdout, stderr, getOut: () => out, getErr: () => err };
+}
+
+function _mkProject(language) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-lang-cli-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'), { recursive: true });
+  const cfg = language ? { response_language: language } : {};
+  fs.writeFileSync(path.join(dir, '.nubos-pilot', 'config.json'), JSON.stringify(cfg));
+  return dir;
+}
+
+test('lang-directive: default prints plain directive text', () => {
+  const dir = _mkProject('de');
+  try {
+    const cap = _capture();
+    const rc = subcmd.run([], { cwd: dir, stdout: cap.stdout, stderr: cap.stderr });
+    assert.equal(rc, 0);
+    assert.match(cap.getOut(), /Sprache: \*\*Deutsch\.\*\*/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('lang-directive: --json emits language+directive payload', () => {
+  const dir = _mkProject('de');
+  try {
+    const cap = _capture();
+    const rc = subcmd.run(['--json'], { cwd: dir, stdout: cap.stdout, stderr: cap.stderr });
+    assert.equal(rc, 0);
+    const parsed = JSON.parse(cap.getOut());
+    assert.equal(parsed.language, 'de');
+    assert.match(parsed.directive, /Sprache: \*\*Deutsch\.\*\*/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('lang-directive: --lang overrides config', () => {
+  const dir = _mkProject('de');
+  try {
+    const cap = _capture();
+    const rc = subcmd.run(['--lang', 'en'], { cwd: dir, stdout: cap.stdout, stderr: cap.stderr });
+    assert.equal(rc, 0);
+    assert.match(cap.getOut(), /Language: \*\*English\.\*\*/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('lang-directive: defaults to en when no config entry', () => {
+  const dir = _mkProject(null);
+  try {
+    const cap = _capture();
+    const rc = subcmd.run([], { cwd: dir, stdout: cap.stdout, stderr: cap.stderr });
+    assert.equal(rc, 0);
+    assert.match(cap.getOut(), /Language: \*\*English\.\*\*/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('lang-directive: unknown arg returns error code', () => {
+  const dir = _mkProject(null);
+  try {
+    const cap = _capture();
+    const rc = subcmd.run(['--nope'], { cwd: dir, stdout: cap.stdout, stderr: cap.stderr });
+    assert.equal(rc, 1);
+    const parsed = JSON.parse(cap.getErr().trim());
+    assert.equal(parsed.code, 'lang-directive-unknown-arg');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/lib/language.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { findProjectRoot, NubosPilotError } = require('./core.cjs');
+
+const LANG_DIRECTIVES = {
+  de: 'Sprache: **Deutsch.** Jede nubos-pilot Slash-Command-Ausgabe, jede Frage an den User und jedes Statusupdate in allen `/np:*` Workflows ist auf Deutsch zu schreiben — inklusive Fehlermeldungen und Klärungsfragen. Nur Code, Bash-Kommandos, Tool-Outputs und Commit-Messages bleiben wie sie sind.',
+  en: 'Language: **English.** All `/np:*` slash-command output, askuser prompts and status updates respond in English.',
+};
+
+const DEFAULT_LANGUAGE = 'en';
+
+function normalizeLanguage(raw) {
+  const s = String(raw || '').trim().toLowerCase();
+  return s || DEFAULT_LANGUAGE;
+}
+
+function buildDirective(language) {
+  const lang = normalizeLanguage(language);
+  if (LANG_DIRECTIVES[lang]) return LANG_DIRECTIVES[lang];
+  return 'Language: respond in the ISO-639 language `' + lang + '` for all `/np:*` slash-command output, askuser prompts and status updates.';
+}
+
+function readConfigLanguage(cwd) {
+  let root;
+  try {
+    root = findProjectRoot(cwd || process.cwd());
+  } catch (err) {
+    if (err && err.code === 'not-in-project') return null;
+    throw err;
+  }
+  const p = path.join(root, '.nubos-pilot', 'config.json');
+  if (!fs.existsSync(p)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+  } catch (err) {
+    throw new NubosPilotError('language-config-parse-error', 'config.json invalid JSON', { cause: err && err.message });
+  }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const raw = parsed.response_language;
+  if (raw == null || raw === '') return null;
+  return normalizeLanguage(raw);
+}
+
+function resolveLanguage(cwd) {
+  return readConfigLanguage(cwd) || DEFAULT_LANGUAGE;
+}
+
+function resolveDirective(cwd) {
+  return buildDirective(resolveLanguage(cwd));
+}
+
+module.exports = {
+  LANG_DIRECTIVES,
+  DEFAULT_LANGUAGE,
+  normalizeLanguage,
+  buildDirective,
+  readConfigLanguage,
+  resolveLanguage,
+  resolveDirective,
+};

package/lib/language.test.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const lang = require('./language.cjs');
+
+function _mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-lang-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'), { recursive: true });
+  return dir;
+}
+
+function _writeConfig(dir, obj) {
+  fs.writeFileSync(path.join(dir, '.nubos-pilot', 'config.json'), JSON.stringify(obj, null, 2));
+}
+
+test('language: normalizeLanguage lowercases and trims', () => {
+  assert.equal(lang.normalizeLanguage('DE'), 'de');
+  assert.equal(lang.normalizeLanguage('  En  '), 'en');
+  assert.equal(lang.normalizeLanguage(''), 'en');
+  assert.equal(lang.normalizeLanguage(null), 'en');
+});
+
+test('language: buildDirective returns known de/en strings', () => {
+  const de = lang.buildDirective('de');
+  assert.match(de, /Sprache: \*\*Deutsch\.\*\*/);
+  const en = lang.buildDirective('en');
+  assert.match(en, /Language: \*\*English\.\*\*/);
+});
+
+test('language: buildDirective falls back to ISO-639 template for unknown code', () => {
+  const fr = lang.buildDirective('fr');
+  assert.match(fr, /ISO-639 language `fr`/);
+});
+
+test('language: readConfigLanguage returns null when no config', () => {
+  const dir = _mkSandbox();
+  try {
+    assert.equal(lang.readConfigLanguage(dir), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('language: readConfigLanguage returns normalized value from config', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { response_language: 'DE' });
+    assert.equal(lang.readConfigLanguage(dir), 'de');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('language: readConfigLanguage returns null when response_language absent', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { runtime: 'claude' });
+    assert.equal(lang.readConfigLanguage(dir), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('language: resolveLanguage defaults to en when no project root', () => {
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'np-outside-'));
+  try {
+    assert.equal(lang.resolveLanguage(outside), 'en');
+  } finally {
+    fs.rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test('language: resolveDirective uses config language', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { response_language: 'de' });
+    assert.match(lang.resolveDirective(dir), /Sprache: \*\*Deutsch\.\*\*/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('language: readConfigLanguage throws on invalid JSON', () => {
+  const dir = _mkSandbox();
+  try {
+    fs.writeFileSync(path.join(dir, '.nubos-pilot', 'config.json'), '{not json');
+    assert.throws(
+      () => lang.readConfigLanguage(dir),
+      (err) => err && err.code === 'language-config-parse-error',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/lib/runtime/_readline.cjs

@@ -7,6 +7,10 @@ function _setReadlineImplForTests(impl) {
   _readlineImpl = impl || null;
 }
 
+function _hasReadlineImplForTests() {
+  return _readlineImpl != null;
+}
+
 function _readOneLine() {
   if (_readlineImpl) return Promise.resolve(_readlineImpl());
   return new Promise((resolve, reject) => {
@@ -156,4 +160,4 @@ async function askUserReadline({ type, question, options, def }) {
   return { value: _parseAnswer(type, line, options, def), source: 'readline' };
 }
 
-module.exports = { askUserReadline, _readOneLine, _parseAnswer, _setReadlineImplForTests };
+module.exports = { askUserReadline, _readOneLine, _parseAnswer, _setReadlineImplForTests, _hasReadlineImplForTests };

package/lib/runtime/_readline.test.cjs

@@ -115,9 +115,10 @@ test('RL-9: _parseAnswer unknown type throws askuser-invalid-type', () => {
   );
 });
 
-test('RL-10: module exports exactly askUserReadline, _readOneLine, _parseAnswer, _setReadlineImplForTests', () => {
+test('RL-10: module exports readline helpers + claude-runtime TTY probe', () => {
   const keys = Object.keys(rl).sort();
   assert.deepEqual(keys, [
+    '_hasReadlineImplForTests',
     '_parseAnswer',
     '_readOneLine',
     '_setReadlineImplForTests',

package/lib/runtime/claude.cjs

@@ -1,4 +1,5 @@
-const { _readOneLine, _parseAnswer } = require('./_readline.cjs');
+const { _readOneLine, _parseAnswer, _hasReadlineImplForTests } = require('./_readline.cjs');
+const { NubosPilotError } = require('../core.cjs');
 
 function _emitClaudeMarkerBlock({ type, question, options, def }) {
   const payload = {
@@ -17,6 +18,17 @@ async function askUser(spec) {
   const question = spec && spec.question;
   const options = spec && spec.options;
   const def = spec ? spec.default : undefined;
+  const hasTTY = !!process.stdin.isTTY;
+  if (!hasTTY && !_hasReadlineImplForTests()) {
+    if (def !== undefined && def !== null) {
+      return { value: def, source: 'default' };
+    }
+    throw new NubosPilotError(
+      'askuser-no-tty',
+      'askUser cannot prompt without TTY (Claude Code Bash has no interactive stdin). Fall back to plain-text numbered list.',
+      { question, type },
+    );
+  }
   const line = await _emitClaudeMarkerBlock({ type, question, options, def });
   return { value: _parseAnswer(type, line, options, def), source: 'askUserQuestion' };
 }

package/lib/runtime/claude.test.cjs

@@ -99,3 +99,38 @@ test('claude-adapter: exports runtimeNotice compatible with agents-md SC-5 check
 test('claude-adapter: runtimeNotice does not contain the forbidden joined Claude-tool literal (SC-5 guard)', () => {
   assert.ok(!/Ask-User-Question/.test(claude.runtimeNotice));
 });
+
+test('claude-adapter: askUser without TTY and without default throws askuser-no-tty', async () => {
+  const originalIsTTY = process.stdin.isTTY;
+  try {
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    _setReadlineImplForTests(null);
+    await assert.rejects(
+      () => claude.askUser({ type: 'select', question: 'P', options: ['A', 'B'] }),
+      (err) => err && err.code === 'askuser-no-tty',
+    );
+  } finally {
+    if (originalIsTTY === undefined) {
+      delete process.stdin.isTTY;
+    } else {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  }
+});
+
+test('claude-adapter: askUser without TTY but with default returns default', async () => {
+  const originalIsTTY = process.stdin.isTTY;
+  try {
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    _setReadlineImplForTests(null);
+    const res = await claude.askUser({ type: 'confirm', question: 'OK?', default: true });
+    assert.equal(res.value, true);
+    assert.equal(res.source, 'default');
+  } finally {
+    if (originalIsTTY === undefined) {
+      delete process.stdin.isTTY;
+    } else {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  }
+});

package/np-tools.cjs

@@ -45,6 +45,7 @@ const topLevelCommands = {
   'metrics':        require('./bin/np-tools/metrics.cjs'),
   'resolve-model':  require('./bin/np-tools/resolve-model.cjs'),
   'stats':          require('./bin/np-tools/stats.cjs'),
+  'lang-directive': require('./bin/np-tools/lang-directive.cjs'),
 };
 
 const THRESHOLD = 16 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubos-pilot",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "AI-driven planning and execution tool for code projects",
   "homepage": "https://github.com/Nubos-AI/nubos-pilot",
   "repository": {

package/workflows/discuss-phase.md

@@ -19,10 +19,17 @@ workflow delivers PLAN-01 and nothing beyond it.
 ## Initialize
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init discuss-phase "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative for this workflow. Obey it for ALL
+subsequent output, askuser prompt texts, status updates, and the CONTEXT.md
+rendering. This supersedes any directive in CLAUDE.md managed block if they
+conflict — the config is the single source of truth.
+
 Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`,
 `milestone_context_path`, `has_context`, `has_milestone_dir`, `goal`,
 `requirements`, `agent_skills`, `mode`.
@@ -118,11 +125,16 @@ Capture the idea in a "Deferred Ideas" section. Don't lose it, don't act on it.
 ## Answer Validation
 
 <answer_validation>
-**IMPORTANT: Answer validation** — After every interactive prompt, check if the
-response is empty or whitespace-only. If so:
-1. Retry the question once with the same parameters
-2. If still empty, present the options as a plain-text numbered list and ask
-   the user to type their choice number
+**IMPORTANT: Answer validation** — After every interactive prompt, check the
+exit code and the response:
+1. If `askuser` exits with structured error `askuser-no-tty` (exit code 1,
+   stderr JSON with `"code":"askuser-no-tty"`), **skip retry** and fall back
+   immediately to the plain-text numbered list described below — the runtime
+   cannot prompt interactively in this session.
+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.
 
 **Text mode (`workflow.text_mode: true` in config or `--text` flag):**

package/workflows/discuss-project.md

@@ -51,10 +51,16 @@ Never:
 ## Single-Call Init
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init discuss-project ${BOOTSTRAP:+--bootstrap})
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for all askuser prompt texts,
+narrative status updates, and the prose written into PROJECT.md sections.
+Supersedes CLAUDE.md managed block.
+
 Parse: `mode`, `sub_mode` (`bootstrap` or `refresh`), `project_md_exists`,
 `scan_context`, `questions[]`, `required_fields[]`.
 

package/workflows/execute-phase.md

@@ -16,12 +16,20 @@ Execute every slice of a milestone in wave order: slice S001 first (all its task
 
 ```bash
 PHASE="$1"
-INIT=$(node .nubos-pilot/bin/np-tools.cjs init execute-milestone "$PHASE")
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
+INIT=$(node .nubos-pilot/bin/np-tools.cjs init execute-milestone init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_EXECUTOR=$(node .nubos-pilot/bin/np-tools.cjs agent-skills executor 2>/dev/null)
 RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative for this workflow. Obey it for all user-
+facing output, askuser prompts, and status updates. Pass `$LANG_DIRECTIVE`
+into every np-executor spawn prompt as a system-level rule so task summaries
+and checkpoint notes follow the project language. This supersedes any
+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`, `agent_skills`.
 
 `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

@@ -52,10 +52,16 @@ The subcommand raises `project-not-initialized` anyway, but the shell check give
 ## Single-Call Init
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init new-milestone)
 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,
+user-facing output, and any prose written into milestone artefacts (YAML
+keys, IDs, and identifiers stay canonical English). Supersedes CLAUDE.md.
+
 Payload: three questions — `milestone_name`, `milestone_goal`, `create_req_prefix` (confirm).
 
 ## Interview

package/workflows/new-project.md

@@ -106,10 +106,17 @@ Use the scan to propose:
 The 5 structural questions. All prompts go through the askuser gateway.
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init new-project)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for all askuser prompt texts,
+user-facing output, and any narrative prose written into PROJECT.md /
+REQUIREMENTS.md (field names and YAML keys stay canonical English).
+Supersedes CLAUDE.md.
+
 ```bash
 ANS_PROJECT_NAME=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{"type":"input","prompt":"Project name?"}')
 ANS_CORE_VALUE=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{"type":"input","prompt":"Core value — one sentence that must stay true if everything else fails?"}')

package/workflows/pause-work.md

@@ -15,9 +15,14 @@ progress.
 ## Execution
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 node .nubos-pilot/bin/np-tools.cjs init pause-work
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+Obey `$LANG_DIRECTIVE` for the resume-hint narration and any status lines
+printed around the JSON payload. Supersedes CLAUDE.md.
+
 Output is a small JSON payload `{ ok, stopped_at, resume_file }`. The
 workflow simply displays it.
 

package/workflows/plan-phase.md

@@ -72,6 +72,7 @@ fi
 ### Read milestone state
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init plan-milestone init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_PLANNER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills planner 2>/dev/null)
@@ -79,6 +80,12 @@ AGENT_SKILLS_CHECKER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills plan-chec
 RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for all user-facing output,
+askuser prompts, status updates, and any narrative text the spawned planner
+or plan-checker subagents emit. Pass `$LANG_DIRECTIVE` into their spawn
+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`, `agent_skills`.
 
 `PLAN_ID` and `TASK_ID` default to `${milestone_id}-plan` / `${milestone_id}-planner-run` for the metrics records.

package/workflows/research-phase.md

@@ -92,11 +92,18 @@ payload; larger payloads are written to a tmp file and referenced via
 `@file:<path>`.
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init research-phase "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output and
+askuser prompts, and pass it into the np-researcher spawn prompt so
+RESEARCH.md prose (not URLs, citations, or code snippets) follows the
+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.
 

package/workflows/resume-work.md

@@ -13,10 +13,17 @@ on each accordingly.
 ## Initialize
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init resume-work)
 STATUS=$(echo "$INIT" | node -e "process.stdin.on('data', d => console.log(JSON.parse(d).status))")
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output and
+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.
+
 ## Execution
 
 ### status: resume

package/workflows/scan-codebase.md

@@ -60,10 +60,18 @@ end.
 Scan, group, write manifest + stubs, emit module-facts in one call:
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 PLAN=$(node .nubos-pilot/bin/np-tools.cjs scan-codebase --project-name "$PROJECT_NAME")
 if [[ "$PLAN" == @file:* ]]; then PLAN=$(cat "${PLAN#@file:}"); fi
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output and
+askuser prompts. Pass it into any writer-subagent spawn so module-doc
+prose (overview, responsibilities, notes) follows the project language.
+Module IDs, file paths, symbol names, and language labels stay canonical
+English. Supersedes CLAUDE.md.
+
 `--project-name` is optional; when provided it goes into `INDEX.md`. Other
 flags: `--batch-size N` (default 500), `--max-files N`.
 

package/workflows/session-report.md

@@ -32,6 +32,7 @@ record. Pitfall 9 / `workflow-missing-metrics` is exempt.
 ## Initialize
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 SINCE_OVERRIDE=""
 for arg in "$@"; do
   case "$arg" in
@@ -49,6 +50,12 @@ LOCAL_FILENAME_TS=$(date +"%Y-%m-%dT%H%M")
 REPORT_PATH="${REPORTS_DIR}/${LOCAL_FILENAME_TS}-session-report.md"
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for the report's narrative
+sections (summary, highlights, notable events) and any askuser prompts.
+Task IDs, milestone IDs, commit SHAs, metrics keys, and file paths stay
+canonical English. Supersedes CLAUDE.md.
+
 The filename format is `YYYY-MM-DDTHHMM-session-report.md` (D-17 —
 4-char HHMM, no seconds, local time) so reports sort
 lexicographically by invocation order.

package/workflows/update-docs.md

@@ -51,10 +51,17 @@ If `.doc-index.json` is missing, fall back to a full rescan via
 ## Single-Call Init
 
 ```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 PLAN=$(node .nubos-pilot/bin/np-tools.cjs update-docs)
 if [[ "$PLAN" == @file:* ]]; then PLAN=$(cat "${PLAN#@file:}"); fi
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output and
+askuser prompts. Pass it into any writer-subagent spawn so refreshed
+module-doc prose follows the project language. Module IDs, file paths,
+and symbol names stay canonical English. Supersedes CLAUDE.md.
+
 Parse: `mode`, `diff_summary` (added/removed/changed/unchanged counts),
 `stale_modules[]`, `added_modules[]`, `removed_modules[]`.
 

package/workflows/validate-phase.md

@@ -19,11 +19,18 @@ if [[ -z "$PHASE" ]]; then
   exit 2
 fi
 
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output, askuser
+prompts, and pass it into the np-nyquist-auditor spawn prompt so gap-fill
+narrative follows the project language. Test IDs, file paths, and canonical
+field names stay English. Supersedes CLAUDE.md.
+
 Parse JSON for: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`, `slice_uat`.
 
 ```bash

package/workflows/verify-work.md

@@ -16,11 +16,19 @@ Slice-level acceptance (UAT) is validated separately by `/np:validate-phase <N>`
 
 ```bash
 PHASE="$1"
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_VERIFIER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills verifier 2>/dev/null)
 ```
 
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
+`$LANG_DIRECTIVE` is authoritative. Obey it for user-facing output, askuser
+prompts, and pass it into the np-verifier spawn prompt so VERIFICATION.md
+prose (Pass/Fail findings, root-cause notes) follows the project language.
+Test-case IDs, file paths, and stack traces stay canonical. Supersedes
+CLAUDE.md.
+
 Parse: `milestone`, `milestone_id`, `milestone_dir`, `milestone_name`, `success_criteria`, `draft_results`, `verification_path`, `slice_uat`, `verifier_tier`, `agent_skills`.
 
 ## Pass 1 — verifier agent