nubos-pilot 0.5.2 → 0.5.4

package/bin/np-tools/text-mode.test.cjs

@@ -0,0 +1,132 @@
+'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('./text-mode.cjs');
+
+function _mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-text-mode-cli-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'), { recursive: true });
+  return dir;
+}
+
+function _captureIO() {
+  const out = [];
+  const err = [];
+  return {
+    stdout: { write: (s) => { out.push(String(s)); return true; } },
+    stderr: { write: (s) => { err.push(String(s)); return true; } },
+    stdoutText: () => out.join(''),
+    stderrText: () => err.join(''),
+  };
+}
+
+function _clearClaudeEnv() {
+  const saved = {};
+  for (const k of ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT']) {
+    saved[k] = process.env[k];
+    delete process.env[k];
+  }
+  return () => {
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  };
+}
+
+test('text-mode CLI: default without config and without Claude env prints "false"', () => {
+  const restore = _clearClaudeEnv();
+  try {
+    const dir = _mkSandbox();
+    try {
+      const io = _captureIO();
+      const rc = subcmd.run([], { cwd: dir, stdout: io.stdout, stderr: io.stderr });
+      assert.equal(rc, 0);
+      assert.equal(io.stdoutText().trim(), 'false');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } finally {
+    restore();
+  }
+});
+
+test('text-mode CLI: CLAUDECODE=1 prints "true"', () => {
+  const restore = _clearClaudeEnv();
+  try {
+    process.env.CLAUDECODE = '1';
+    const dir = _mkSandbox();
+    try {
+      const io = _captureIO();
+      const rc = subcmd.run([], { cwd: dir, stdout: io.stdout, stderr: io.stderr });
+      assert.equal(rc, 0);
+      assert.equal(io.stdoutText().trim(), 'true');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } finally {
+    restore();
+  }
+});
+
+test('text-mode CLI: --json emits detail object', () => {
+  const restore = _clearClaudeEnv();
+  try {
+    process.env.CLAUDECODE = '1';
+    const dir = _mkSandbox();
+    try {
+      const io = _captureIO();
+      const rc = subcmd.run(['--json'], { cwd: dir, stdout: io.stdout, stderr: io.stderr });
+      assert.equal(rc, 0);
+      const payload = JSON.parse(io.stdoutText().trim());
+      assert.equal(payload.enabled, true);
+      assert.equal(payload.source, 'runtime');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } finally {
+    restore();
+  }
+});
+
+test('text-mode CLI: config workflow.text_mode=false wins over CLAUDECODE', () => {
+  const restore = _clearClaudeEnv();
+  try {
+    process.env.CLAUDECODE = '1';
+    const dir = _mkSandbox();
+    try {
+      fs.writeFileSync(
+        path.join(dir, '.nubos-pilot', 'config.json'),
+        JSON.stringify({ workflow: { text_mode: false } }),
+      );
+      const io = _captureIO();
+      const rc = subcmd.run(['--json'], { cwd: dir, stdout: io.stdout, stderr: io.stderr });
+      assert.equal(rc, 0);
+      const payload = JSON.parse(io.stdoutText().trim());
+      assert.equal(payload.enabled, false);
+      assert.equal(payload.source, 'config');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } finally {
+    restore();
+  }
+});
+
+test('text-mode CLI: unknown flag exits 1 with structured error', () => {
+  const dir = _mkSandbox();
+  try {
+    const io = _captureIO();
+    const rc = subcmd.run(['--wat'], { cwd: dir, stdout: io.stdout, stderr: io.stderr });
+    assert.equal(rc, 1);
+    const payload = JSON.parse(io.stderrText().trim());
+    assert.equal(payload.code, 'text-mode-unknown-arg');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/bin/np-tools/verify-work.cjs

@@ -19,6 +19,7 @@ const {
   milestoneVerificationPath,
 } = require('../../lib/verify.cjs');
 const { getAgentSkills } = require('../../lib/agents.cjs');
+const textMode = require('../../lib/text-mode.cjs');
 
 const INLINE_THRESHOLD_BYTES = 16 * 1024;
 const _VALID_SC_STATUSES = new Set(['Pass', 'Fail', 'Defer', 'Pending']);
@@ -90,6 +91,8 @@ function _initPayload(mNum, cwd) {
     };
   });
 
+  const tmDetail = textMode.resolveTextModeDetail(cwd);
+
   return {
     _workflow: 'verify-work',
     milestone: mNum,
@@ -101,6 +104,8 @@ function _initPayload(mNum, cwd) {
     verification_path: verificationPath,
     slice_uat: sliceUat,
     verifier_tier: 'sonnet',
+    text_mode: tmDetail.enabled,
+    text_mode_source: tmDetail.source,
     agent_skills: { verifier: _safeSkills('np-verifier', cwd) },
   };
 }

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,10 @@
-const { _readOneLine, _parseAnswer } = require('./_readline.cjs');
+const {
+  _readOneLine,
+  _parseAnswer,
+  _hasReadlineImplForTests,
+  askUserReadline,
+} = require('./_readline.cjs');
+const { NubosPilotError } = require('../core.cjs');
 
 function _emitClaudeMarkerBlock({ type, question, options, def }) {
   const payload = {
@@ -17,6 +23,20 @@ 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) {
+    return askUserReadline({ type, question, options, def });
+  }
+  if (!_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,66 @@ 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 with TTY stdin uses readline UI, no marker block', async () => {
+  const originalIsTTY = process.stdin.isTTY;
+  _setReadlineImplForTests(async () => '2');
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const stderrChunks = [];
+  process.stderr.write = (chunk) => { stderrChunks.push(String(chunk)); return true; };
+  try {
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    const { val, out } = await captureStdout(() =>
+      claude.askUser({ type: 'select', question: 'Q', options: ['A', 'B', 'C'] })
+    );
+    assert.ok(!/<!-- askUser v1 -->/.test(out),
+      'must not emit marker block when stdin is TTY');
+    assert.equal(val.source, 'readline');
+    assert.equal(val.value, 'B');
+    const stderrJoined = stderrChunks.join('');
+    assert.match(stderrJoined, /Q/, 'readline UI should render the question on stderr');
+  } finally {
+    process.stderr.write = originalStderrWrite;
+    _setReadlineImplForTests(null);
+    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/lib/text-mode.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { findProjectRoot, NubosPilotError } = require('./core.cjs');
+
+const DEFAULT_TEXT_MODE = false;
+const CLAUDE_ENV_KEYS = ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT'];
+
+function _coerceBool(raw) {
+  if (raw === true || raw === false) return raw;
+  if (raw == null) return null;
+  const s = String(raw).trim().toLowerCase();
+  if (s === 'true' || s === '1' || s === 'yes' || s === 'on') return true;
+  if (s === 'false' || s === '0' || s === 'no' || s === 'off') return false;
+  return null;
+}
+
+function readConfigTextMode(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('text-mode-config-parse-error', 'config.json invalid JSON', { cause: err && err.message });
+  }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const workflow = parsed.workflow;
+  if (!workflow || typeof workflow !== 'object') return null;
+  if (!Object.prototype.hasOwnProperty.call(workflow, 'text_mode')) return null;
+  const coerced = _coerceBool(workflow.text_mode);
+  return coerced;
+}
+
+function detectRuntimeTextMode(env) {
+  const source = env || process.env;
+  for (const key of CLAUDE_ENV_KEYS) {
+    const v = source[key];
+    if (v != null && String(v) !== '' && String(v) !== '0' && String(v).toLowerCase() !== 'false') {
+      return true;
+    }
+  }
+  return false;
+}
+
+function resolveTextMode(cwd, env) {
+  const fromConfig = readConfigTextMode(cwd);
+  if (fromConfig !== null) return fromConfig;
+  if (detectRuntimeTextMode(env)) return true;
+  return DEFAULT_TEXT_MODE;
+}
+
+function resolveTextModeDetail(cwd, env) {
+  const fromConfig = readConfigTextMode(cwd);
+  if (fromConfig !== null) {
+    return { enabled: fromConfig, source: 'config' };
+  }
+  if (detectRuntimeTextMode(env)) {
+    return { enabled: true, source: 'runtime' };
+  }
+  return { enabled: DEFAULT_TEXT_MODE, source: 'default' };
+}
+
+module.exports = {
+  DEFAULT_TEXT_MODE,
+  CLAUDE_ENV_KEYS,
+  readConfigTextMode,
+  detectRuntimeTextMode,
+  resolveTextMode,
+  resolveTextModeDetail,
+};

package/lib/text-mode.test.cjs

@@ -0,0 +1,139 @@
+'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 tm = require('./text-mode.cjs');
+
+function _mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-textmode-'));
+  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('text-mode: default without config or runtime env is false', () => {
+  const dir = _mkSandbox();
+  try {
+    assert.equal(tm.resolveTextMode(dir, {}), false);
+    const detail = tm.resolveTextModeDetail(dir, {});
+    assert.deepEqual(detail, { enabled: false, source: 'default' });
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: CLAUDECODE=1 in env flips default to true', () => {
+  const dir = _mkSandbox();
+  try {
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '1' }), true);
+    const detail = tm.resolveTextModeDetail(dir, { CLAUDECODE: '1' });
+    assert.deepEqual(detail, { enabled: true, source: 'runtime' });
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: CLAUDE_CODE_ENTRYPOINT non-empty flips to true', () => {
+  const dir = _mkSandbox();
+  try {
+    assert.equal(tm.resolveTextMode(dir, { CLAUDE_CODE_ENTRYPOINT: 'cli' }), true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: env value "0" or "false" does not flip', () => {
+  const dir = _mkSandbox();
+  try {
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '0' }), false);
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: 'false' }), false);
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '' }), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: config workflow.text_mode=true wins over absent runtime', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { workflow: { text_mode: true } });
+    assert.equal(tm.resolveTextMode(dir, {}), true);
+    assert.deepEqual(tm.resolveTextModeDetail(dir, {}), { enabled: true, source: 'config' });
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: config workflow.text_mode=false overrides CLAUDECODE runtime', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { workflow: { text_mode: false } });
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '1' }), false);
+    assert.deepEqual(
+      tm.resolveTextModeDetail(dir, { CLAUDECODE: '1' }),
+      { enabled: false, source: 'config' },
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: config workflow.text_mode="true" string coerced to boolean', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { workflow: { text_mode: 'true' } });
+    assert.equal(tm.resolveTextMode(dir, {}), true);
+    _writeConfig(dir, { workflow: { text_mode: '0' } });
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '1' }), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: config missing workflow.text_mode falls through to runtime detection', () => {
+  const dir = _mkSandbox();
+  try {
+    _writeConfig(dir, { response_language: 'de' });
+    assert.equal(tm.resolveTextMode(dir, { CLAUDECODE: '1' }), true);
+    assert.equal(tm.resolveTextMode(dir, {}), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: readConfigTextMode returns null outside project root', () => {
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'np-outside-'));
+  try {
+    assert.equal(tm.readConfigTextMode(outside), null);
+    assert.equal(tm.resolveTextMode(outside, {}), false);
+  } finally {
+    fs.rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: readConfigTextMode throws on invalid JSON', () => {
+  const dir = _mkSandbox();
+  try {
+    fs.writeFileSync(path.join(dir, '.nubos-pilot', 'config.json'), '{not json');
+    assert.throws(
+      () => tm.readConfigTextMode(dir),
+      (err) => err && err.code === 'text-mode-config-parse-error',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('text-mode: detectRuntimeTextMode honors multiple env keys', () => {
+  assert.equal(tm.detectRuntimeTextMode({ CLAUDECODE: '1' }), true);
+  assert.equal(tm.detectRuntimeTextMode({ CLAUDE_CODE_ENTRYPOINT: 'cli' }), true);
+  assert.equal(tm.detectRuntimeTextMode({ OTHER: '1' }), false);
+  assert.equal(tm.detectRuntimeTextMode({}), false);
+});

package/np-tools.cjs

@@ -45,6 +45,8 @@ 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'),
+  'text-mode':      require('./bin/np-tools/text-mode.cjs'),
 };
 
 const THRESHOLD = 16 * 1024;

package/package.json

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