nubos-pilot 0.1.0

package/lib/runtime/claude.cjs

@@ -0,0 +1,48 @@
+const { _readOneLine, _parseAnswer } = require('./_readline.cjs');
+
+function _emitClaudeMarkerBlock({ type, question, options, def }) {
+  const payload = {
+    type,
+    question,
+    options: options || null,
+    default: def === undefined ? null : def,
+  };
+  const block = '<!-- askUser v1 -->\n<!-- ' + JSON.stringify(payload) + ' -->\n';
+  process.stdout.write(block);
+  return _readOneLine();
+}
+
+async function askUser(spec) {
+  const type = spec && spec.type;
+  const question = spec && spec.question;
+  const options = spec && spec.options;
+  const def = spec ? spec.default : undefined;
+  const line = await _emitClaudeMarkerBlock({ type, question, options, def });
+  return { value: _parseAnswer(type, line, options, def), source: 'askUserQuestion' };
+}
+
+module.exports = {
+  name: 'claude',
+  detectHints: {
+    env: ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT'],
+    pathBinary: 'claude',
+    diskMarkers: ['.claude/'],
+  },
+  capabilities: {
+    askUserQuestion: true,
+    slashCommands: true,
+    agentsMd: 'CLAUDE.md',
+    textMode: 'off',
+    modelResolution: 'profile',
+  },
+  paths: {
+    payload: '.claude/nubos-pilot/',
+    commands: '.claude/commands/',
+    agents: '.claude/agents/',
+    agentsMd: 'CLAUDE.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Claude Code konsumiert. '
+    + 'Interaktive Prompts laufen über Claudes native Frage-Dialog (marker block auf stdout).',
+  askUser,
+};

package/lib/runtime/claude.test.cjs

@@ -0,0 +1,101 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { _setReadlineImplForTests } = require('./_readline.cjs');
+const claude = require('./claude.cjs');
+
+function captureStdout(fn) {
+  const chunks = [];
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk) => { chunks.push(chunk.toString()); return true; };
+  return Promise.resolve(fn()).then(
+    (val) => { process.stdout.write = orig; return { val, out: chunks.join('') }; },
+    (err) => { process.stdout.write = orig; throw err; },
+  );
+}
+
+test('claude-adapter: exports five-key contract', () => {
+  for (const k of ['name', 'detectHints', 'capabilities', 'paths', 'askUser']) {
+    assert.ok(k in claude, 'missing ' + k);
+  }
+  assert.equal(claude.name, 'claude');
+});
+
+test('claude-adapter: capabilities match D-07 spec', () => {
+  const c = claude.capabilities;
+  assert.equal(c.askUserQuestion, true);
+  assert.equal(c.slashCommands, true);
+  assert.equal(c.agentsMd, 'CLAUDE.md');
+  assert.equal(c.textMode, 'off');
+  assert.equal(c.modelResolution, 'profile');
+});
+
+test('claude-adapter: askUser emits askUser v1 marker block', async () => {
+  _setReadlineImplForTests(async () => 'chosen');
+  try {
+    const { val, out } = await captureStdout(() =>
+      claude.askUser({ type: 'input', question: 'Q' })
+    );
+    assert.match(out, /<!-- askUser v1 -->/);
+    assert.match(out, /<!-- \{"type":"input"/);
+    assert.equal(val.source, 'askUserQuestion');
+    assert.equal(val.value, 'chosen');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('claude-adapter: select with injected index returns option', async () => {
+  _setReadlineImplForTests(async () => '2');
+  try {
+    const { val } = await captureStdout(() =>
+      claude.askUser({ type: 'select', question: 'P', options: ['A', 'B', 'C'] })
+    );
+    assert.equal(val.value, 'B');
+    assert.equal(val.source, 'askUserQuestion');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('claude-adapter: confirm y/n parsing', async () => {
+  _setReadlineImplForTests(async () => 'y');
+  try {
+    const { val } = await captureStdout(() =>
+      claude.askUser({ type: 'confirm', question: 'OK' })
+    );
+    assert.equal(val.value, true);
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('claude-adapter: marker JSON payload has exact key order', async () => {
+  _setReadlineImplForTests(async () => 'x');
+  try {
+    const { out } = await captureStdout(() =>
+      claude.askUser({ type: 'input', question: 'Q', options: ['a'], default: 'd' })
+    );
+    assert.match(out, /"type":"input","question":"Q","options":\["a"\],"default":"d"/);
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('claude-adapter: does not import node:readline directly', () => {
+  const src = require('fs').readFileSync(require.resolve('./claude.cjs'), 'utf-8');
+  assert.ok(
+    !/require\(['"]node:readline['"]\)/.test(src),
+    'claude.cjs must delegate to _readline.cjs, not require node:readline',
+  );
+});
+
+test('claude-adapter: exports runtimeNotice compatible with agents-md SC-5 check', () => {
+  const notice = claude.runtimeNotice;
+  assert.equal(typeof notice, 'string');
+  assert.ok(notice.length > 0);
+  assert.match(notice, /readline|prompt/i, 'runtimeNotice must match /readline|prompt/i');
+});
+
+test('claude-adapter: runtimeNotice does not contain the forbidden joined Claude-tool literal (SC-5 guard)', () => {
+  assert.ok(!/Ask-User-Question/.test(claude.runtimeNotice));
+});

package/lib/runtime/codex.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'codex',
+  detectHints: {
+    env: ['CODEX_HOME', 'CODEX_VERSION'],
+    pathBinary: 'codex',
+    diskMarkers: ['.codex/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'AGENTS.md',
+    textMode: 'auto',
+    modelResolution: 'profile',
+  },
+  paths: {
+    payload: null,
+    config: null,
+    agentsMd: 'AGENTS.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei wird von Codex/Gemini/OpenCode konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr), nicht über das Claude-spezifische AskUser-Tool.',
+  askUser,
+};

package/lib/runtime/codex.test.cjs

@@ -0,0 +1,114 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const { _setReadlineImplForTests } = require('./_readline.cjs');
+const codex = require('./codex.cjs');
+
+function captureStderr(fn) {
+  const chunks = [];
+  const orig = process.stderr.write.bind(process.stderr);
+  process.stderr.write = (chunk) => { chunks.push(chunk.toString()); return true; };
+  return Promise.resolve(fn()).then(
+    (val) => { process.stderr.write = orig; return { val, out: chunks.join('') }; },
+    (err) => { process.stderr.write = orig; throw err; },
+  );
+}
+
+test('codex-adapter: exports five-key contract', () => {
+  for (const k of ['name', 'detectHints', 'capabilities', 'paths', 'askUser']) {
+    assert.ok(k in codex, 'missing ' + k);
+  }
+  assert.equal(codex.name, 'codex');
+});
+
+test('codex-adapter: capabilities match D-07 spec', () => {
+  const c = codex.capabilities;
+  assert.equal(c.askUserQuestion, false);
+  assert.equal(c.slashCommands, false);
+  assert.equal(c.agentsMd, 'AGENTS.md');
+  assert.equal(c.textMode, 'auto');
+  assert.equal(c.modelResolution, 'profile');
+});
+
+test('codex-adapter: paths are null for payload/config (codex has no per-project tree)', () => {
+  assert.equal(codex.paths.payload, null);
+  assert.equal(codex.paths.config, null);
+  assert.equal(codex.paths.agentsMd, 'AGENTS.md');
+});
+
+test('codex-adapter: readline select returns option', async () => {
+  _setReadlineImplForTests(async () => '1');
+  try {
+    const { val } = await captureStderr(() =>
+      codex.askUser({ type: 'select', question: 'P', options: ['A', 'B'] }),
+    );
+    assert.equal(val.value, 'A');
+    assert.equal(val.source, 'readline');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('codex-adapter: readline input returns line', async () => {
+  _setReadlineImplForTests(async () => 'hi');
+  try {
+    const { val } = await captureStderr(() =>
+      codex.askUser({ type: 'input', question: 'Q' }),
+    );
+    assert.equal(val.value, 'hi');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('codex-adapter: readline confirm yes/no', async () => {
+  _setReadlineImplForTests(async () => 'yes');
+  try {
+    const { val } = await captureStderr(() =>
+      codex.askUser({ type: 'confirm', question: 'OK' }),
+    );
+    assert.equal(val.value, true);
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('codex-adapter: REGRESSION GUARD — does not import codex-toml or install-layer modules (D-20)', () => {
+  const src = fs.readFileSync(require.resolve('./codex.cjs'), 'utf-8');
+  assert.ok(
+    !/codex-toml/.test(src),
+    'D-20 violation: codex.cjs must not import lib/install/codex-toml.cjs — [features]-repair stays in install layer',
+  );
+  assert.ok(
+    !/require\(['"]\.\.\/install\//.test(src),
+    'codex.cjs must not reach into lib/install/',
+  );
+  assert.ok(
+    !/repairCodexFeatures/.test(src),
+    'codex.cjs must not reference repairCodexFeatures',
+  );
+});
+
+test('codex-adapter: does not import node:readline directly', () => {
+  const src = fs.readFileSync(require.resolve('./codex.cjs'), 'utf-8');
+  assert.ok(
+    !/require\(['"]node:readline['"]\)/.test(src),
+    'codex.cjs must delegate to _readline.cjs',
+  );
+});
+
+test('codex-adapter: exports runtimeNotice compatible with agents-md SC-5 check', () => {
+  const notice = codex.runtimeNotice;
+  assert.equal(typeof notice, 'string');
+  assert.ok(notice.length > 0);
+  assert.match(notice, /readline|prompt/i, 'runtimeNotice must match /readline|prompt/i');
+});
+
+test('codex-adapter: runtimeNotice starts with the runtime-hint marker (default fallback)', () => {
+  assert.ok(codex.runtimeNotice.startsWith('> **Runtime-Hinweis:**'));
+  assert.ok(/readline/.test(codex.runtimeNotice));
+});
+
+test('codex-adapter: runtimeNotice does not contain the forbidden joined Claude-tool literal (SC-5 guard)', () => {
+  assert.ok(!/Ask-User-Question/.test(codex.runtimeNotice));
+});

package/lib/runtime/gemini.cjs

@@ -0,0 +1,35 @@
+const { askUserReadline } = require('./_readline.cjs');
+
+async function askUser(spec) {
+  return askUserReadline({
+    type: spec && spec.type,
+    question: spec && spec.question,
+    options: spec && spec.options,
+    def: spec ? spec.default : undefined,
+  });
+}
+
+module.exports = {
+  name: 'gemini',
+  detectHints: {
+    env: ['GEMINI_CLI', 'GEMINI_VERSION'],
+    pathBinary: 'gemini',
+    diskMarkers: ['.gemini/'],
+  },
+  capabilities: {
+    askUserQuestion: false,
+    slashCommands: false,
+    agentsMd: 'GEMINI.md',
+    textMode: 'auto',
+    modelResolution: 'profile',
+  },
+  paths: {
+    payload: null,
+    config: null,
+    agentsMd: 'GEMINI.md',
+  },
+  runtimeNotice:
+    '> **Runtime-Hinweis:** Diese Datei (GEMINI.md) wird von der Gemini CLI konsumiert. '
+    + 'Interaktive Prompts laufen über readline (stderr).',
+  askUser,
+};

package/lib/runtime/gemini.test.cjs

@@ -0,0 +1,109 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const { _setReadlineImplForTests } = require('./_readline.cjs');
+const gemini = require('./gemini.cjs');
+
+function captureStderr(fn) {
+  const chunks = [];
+  const orig = process.stderr.write.bind(process.stderr);
+  process.stderr.write = (chunk) => { chunks.push(chunk.toString()); return true; };
+  return Promise.resolve(fn()).then(
+    (val) => { process.stderr.write = orig; return { val, out: chunks.join('') }; },
+    (err) => { process.stderr.write = orig; throw err; },
+  );
+}
+
+test('gemini-adapter: exports five-key contract', () => {
+  for (const k of ['name', 'detectHints', 'capabilities', 'paths', 'askUser']) {
+    assert.ok(k in gemini, 'missing ' + k);
+  }
+  assert.equal(gemini.name, 'gemini');
+});
+
+test('gemini-adapter: capabilities match D-07 + D-17', () => {
+  const c = gemini.capabilities;
+  assert.equal(c.askUserQuestion, false);
+  assert.equal(c.slashCommands, false);
+  assert.equal(
+    c.agentsMd,
+    'GEMINI.md',
+    'D-17: Gemini reads GEMINI.md as default context file',
+  );
+  assert.equal(c.textMode, 'auto');
+  assert.equal(c.modelResolution, 'profile');
+});
+
+test('gemini-adapter: paths.agentsMd is root-level GEMINI.md', () => {
+  assert.equal(
+    gemini.paths.agentsMd,
+    'GEMINI.md',
+    'D-17: GEMINI.md at project root, not in .gemini/ subdir',
+  );
+  assert.equal(gemini.paths.payload, null);
+  assert.equal(gemini.paths.config, null);
+});
+
+test('gemini-adapter: readline select parses 1-based index', async () => {
+  _setReadlineImplForTests(async () => '2');
+  try {
+    const { val } = await captureStderr(() =>
+      gemini.askUser({ type: 'select', question: 'P', options: ['A', 'B'] }),
+    );
+    assert.equal(val.value, 'B');
+    assert.equal(val.source, 'readline');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('gemini-adapter: readline input', async () => {
+  _setReadlineImplForTests(async () => 'ok');
+  try {
+    const { val } = await captureStderr(() =>
+      gemini.askUser({ type: 'input', question: 'Q' }),
+    );
+    assert.equal(val.value, 'ok');
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('gemini-adapter: readline confirm', async () => {
+  _setReadlineImplForTests(async () => 'y');
+  try {
+    const { val } = await captureStderr(() =>
+      gemini.askUser({ type: 'confirm', question: 'OK' }),
+    );
+    assert.equal(val.value, true);
+  } finally {
+    _setReadlineImplForTests(null);
+  }
+});
+
+test('gemini-adapter: single responsibility — no install-layer imports, no direct readline', () => {
+  const src = fs.readFileSync(require.resolve('./gemini.cjs'), 'utf-8');
+  assert.ok(
+    !/require\(['"]\.\.\/install\//.test(src),
+    'gemini.cjs must not reach into lib/install/',
+  );
+  assert.ok(
+    !/require\(['"]node:readline['"]\)/.test(src),
+    'gemini.cjs must delegate to _readline.cjs',
+  );
+});
+
+test('gemini-adapter: exports runtimeNotice compatible with agents-md SC-5 check', () => {
+  const notice = gemini.runtimeNotice;
+  assert.equal(typeof notice, 'string');
+  assert.ok(notice.length > 0);
+  assert.match(notice, /readline|prompt/i, 'runtimeNotice must match /readline|prompt/i');
+});
+
+test('gemini-adapter: runtimeNotice references GEMINI.md', () => {
+  assert.ok(gemini.runtimeNotice.includes('GEMINI.md'));
+});
+
+test('gemini-adapter: runtimeNotice does not contain the forbidden joined Claude-tool literal (SC-5 guard)', () => {
+  assert.ok(!/Ask-User-Question/.test(gemini.runtimeNotice));
+});

package/lib/runtime/index.cjs

@@ -0,0 +1,49 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { NubosPilotError } = require('../core.cjs');
+const { getRuntime: _askuserGetRuntime } = require('../askuser.cjs');
+
+const KNOWN_RUNTIMES = ['claude', 'opencode', 'codex', 'gemini'];
+
+function listRuntimes() {
+  return KNOWN_RUNTIMES.slice();
+}
+
+function getAdapter(name) {
+  if (!KNOWN_RUNTIMES.includes(name)) {
+    throw new NubosPilotError(
+      'runtime-unknown',
+      'Unknown runtime: ' + name,
+      { name, known: KNOWN_RUNTIMES.slice() },
+    );
+  }
+  return require('./' + name + '.cjs');
+}
+
+function detect(opts) {
+  const cwd = (opts && opts.cwd) || process.cwd();
+
+  const configPath = path.join(cwd, '.nubos-pilot', 'config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      if (cfg && cfg.runtime && KNOWN_RUNTIMES.includes(cfg.runtime)) {
+        return { runtime: cfg.runtime, source: cfg.runtime_source || 'config' };
+      }
+    } catch {  }
+  }
+
+  const live = _askuserGetRuntime();
+  if (KNOWN_RUNTIMES.includes(live)) {
+    return { runtime: live, source: 'env' };
+  }
+
+  return { runtime: 'codex', source: 'default' };
+}
+
+function getCurrent() {
+  const { runtime } = detect();
+  return getAdapter(runtime);
+}
+
+module.exports = { listRuntimes, getAdapter, getCurrent, detect };

package/lib/runtime/index.test.cjs

@@ -0,0 +1,181 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const rt = require('./index.cjs');
+
+const RUNTIME_ENV_KEYS = [
+  'NUBOS_RUNTIME',
+  'CLAUDECODE',
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CODEX_HOME',
+  'CODEX_VERSION',
+  'GEMINI_CLI',
+  'GEMINI_VERSION',
+  'OPENCODE',
+  'OPENCODE_VERSION',
+  'NUBOS_PILOT_REDETECT_RUNTIME',
+];
+
+function snapshotEnv() {
+  const snap = {};
+  for (const k of RUNTIME_ENV_KEYS) snap[k] = process.env[k];
+  return snap;
+}
+function restoreEnv(snap) {
+  for (const k of RUNTIME_ENV_KEYS) {
+    if (snap[k] === undefined) delete process.env[k];
+    else process.env[k] = snap[k];
+  }
+}
+function clearAllRuntimeEnv() {
+  for (const k of RUNTIME_ENV_KEYS) delete process.env[k];
+}
+function forceRedetect() {
+  process.env.NUBOS_PILOT_REDETECT_RUNTIME = '1';
+}
+
+function mkTmp(scope) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'np-runtime-' + scope + '-'));
+}
+
+function writeConfig(cwd, json) {
+  const dir = path.join(cwd, '.nubos-pilot');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(json), 'utf-8');
+}
+
+test('RTI-1: listRuntimes returns four known runtimes in canonical order', () => {
+  assert.deepEqual(rt.listRuntimes(), ['claude', 'opencode', 'codex', 'gemini']);
+});
+
+test('RTI-2: listRuntimes returns defensive copy — mutation does not leak', () => {
+  const a = rt.listRuntimes();
+  a.push('pwned');
+  const b = rt.listRuntimes();
+  assert.deepEqual(b, ['claude', 'opencode', 'codex', 'gemini']);
+});
+
+test('RTI-3: getAdapter("nonexistent") throws NubosPilotError with code runtime-unknown', () => {
+  assert.throws(
+    () => rt.getAdapter('nonexistent'),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'runtime-unknown',
+  );
+});
+
+test('RTI-4: getAdapter unknown-runtime error details.known lists KNOWN_RUNTIMES', () => {
+  try {
+    rt.getAdapter('mystery');
+    assert.fail('should throw');
+  } catch (err) {
+    assert.equal(err.code, 'runtime-unknown');
+    assert.deepEqual(err.details.known, ['claude', 'opencode', 'codex', 'gemini']);
+    assert.equal(err.details.name, 'mystery');
+  }
+});
+
+test('RTI-5: detect honors .nubos-pilot/config.json runtime + runtime_source', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('cfg-honored');
+  try {
+    clearAllRuntimeEnv();
+    forceRedetect();
+    writeConfig(tmp, { runtime: 'codex', runtime_source: 'asked' });
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'codex');
+    assert.equal(d.source, 'asked');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-6: detect config without runtime_source defaults source to "config"', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('cfg-no-src');
+  try {
+    clearAllRuntimeEnv();
+    forceRedetect();
+    writeConfig(tmp, { runtime: 'gemini' });
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'gemini');
+    assert.equal(d.source, 'config');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-7: detect falls through when config.runtime is unknown', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('cfg-unknown');
+  try {
+    clearAllRuntimeEnv();
+    forceRedetect();
+    writeConfig(tmp, { runtime: 'mystery' });
+
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'codex');
+    assert.equal(d.source, 'default');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-8: detect with no config + CLAUDECODE=1 returns {runtime:claude, source:env}', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('env-claude');
+  try {
+    clearAllRuntimeEnv();
+    process.env.CLAUDECODE = '1';
+    forceRedetect();
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'claude');
+    assert.equal(d.source, 'env');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-9: detect with no config + no env returns {runtime:codex, source:default}', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('default');
+  try {
+    clearAllRuntimeEnv();
+    forceRedetect();
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'codex');
+    assert.equal(d.source, 'default');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-10: detect tolerates malformed config.json (silent fall-through to env/default)', () => {
+  const snap = snapshotEnv();
+  const tmp = mkTmp('bad-json');
+  try {
+    clearAllRuntimeEnv();
+    forceRedetect();
+    const dir = path.join(tmp, '.nubos-pilot');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'config.json'), '{ not json', 'utf-8');
+    const d = rt.detect({ cwd: tmp });
+    assert.equal(d.runtime, 'codex');
+    assert.equal(d.source, 'default');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    restoreEnv(snap);
+  }
+});
+
+test('RTI-11: module exports exactly listRuntimes, getAdapter, getCurrent, detect', () => {
+  const keys = Object.keys(rt).sort();
+  assert.deepEqual(keys, ['detect', 'getAdapter', 'getCurrent', 'listRuntimes']);
+});
+