nubos-pilot 1.3.0 → 1.3.2

package/lib/elision-proxy.test.cjs

@@ -0,0 +1,243 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const http = require('node:http');
+const child_process = require('node:child_process');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const proxy = require('./elision-proxy.cjs');
+
+function bigLog() {
+  const lines = [];
+  for (let i = 0; i < 300; i++) {
+    lines.push(i % 71 === 0 ? ('ERROR: boom at svc_' + i) : ('[info] step ' + i + ' ok ' + 'x'.repeat(40)));
+  }
+  return lines.join('\n');
+}
+
+function fakeCx(store) {
+  return { enabled: true, minBlockBytes: 100, verifyMaxBytes: 2000, store: store || (() => 'abcdef012345') };
+}
+
+const _servers = [];
+const _dirs = [];
+const _procs = [];
+afterEach(() => {
+  while (_procs.length) { try { _procs.pop().kill(); } catch {} }
+  while (_servers.length) { try { _servers.pop().close(); } catch {} }
+  while (_dirs.length) { try { fs.rmSync(_dirs.pop(), { recursive: true, force: true }); } catch {} }
+});
+function ws(files) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'np-proxy-')));
+  for (const [rel, content] of Object.entries(files || {})) {
+    const abs = path.join(root, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content, 'utf-8');
+  }
+  _dirs.push(root);
+  return root;
+}
+
+test('PXY-1: compresses a large tool_result and stores the original; cache_control + ids survive', () => {
+  const seen = [];
+  const body = {
+    model: 'claude',
+    system: [{ type: 'text', text: 'SYSTEM PROMPT '.repeat(50), cache_control: { type: 'ephemeral' } }],
+    messages: [
+      { role: 'assistant', content: [{ type: 'text', text: 'thinking' }] },
+      { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'tu_1', is_error: false, cache_control: { type: 'ephemeral' }, content: bigLog() },
+      ] },
+    ],
+  };
+  const out = proxy.compressAnthropicBody(body, fakeCx((orig) => { seen.push(orig); return 'abcdef012345'; }));
+  assert.equal(out.stats.blocks_compressed, 1);
+  assert.ok(out.stats.bytes_after < out.stats.bytes_before);
+  const tr = out.body.messages[1].content[0];
+  assert.ok(tr.content.includes('⟦elided:abcdef012345'), 'marker injected into tool_result');
+  assert.deepEqual(tr.cache_control, { type: 'ephemeral' }, 'cache_control preserved');
+  assert.equal(tr.tool_use_id, 'tu_1');
+  assert.equal(tr.is_error, false);
+  assert.equal(seen.length, 1, 'original stored once');
+  assert.ok(seen[0].includes('ERROR: boom at svc_0'), 'raw original captured');
+});
+
+test('PXY-2: system blocks and ordinary text are never touched (cached prefix stays byte-identical)', () => {
+  const sys = 'SYSTEM '.repeat(500);
+  const body = {
+    system: [{ type: 'text', text: sys, cache_control: { type: 'ephemeral' } }],
+    messages: [{ role: 'assistant', content: [{ type: 'text', text: 'A'.repeat(5000) }] }],
+  };
+  const out = proxy.compressAnthropicBody(body, fakeCx());
+  assert.equal(out.stats.blocks_compressed, 0);
+  assert.equal(out.body.system[0].text, sys);
+  assert.equal(out.body.messages[0].content[0].text, 'A'.repeat(5000));
+});
+
+test('PXY-3: small tool_result is left verbatim', () => {
+  const body = { messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 't', content: 'tiny' }] }] };
+  const out = proxy.compressAnthropicBody(body, fakeCx());
+  assert.equal(out.stats.blocks_compressed, 0);
+  assert.equal(out.body.messages[0].content[0].content, 'tiny');
+});
+
+test('PXY-4: deterministic — same body compresses to the same bytes (cache-stable across turns)', () => {
+  const mk = () => ({ messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 't', content: bigLog() }] }] });
+  const a = proxy.compressAnthropicBody(mk(), fakeCx());
+  const b = proxy.compressAnthropicBody(mk(), fakeCx());
+  assert.equal(JSON.stringify(a.body), JSON.stringify(b.body));
+});
+
+test('PXY-5: array-form tool_result content compresses its text blocks', () => {
+  const body = { messages: [{ role: 'user', content: [
+    { type: 'tool_result', tool_use_id: 't', content: [{ type: 'text', text: bigLog() }] },
+  ] }] };
+  const out = proxy.compressAnthropicBody(body, fakeCx());
+  assert.equal(out.stats.blocks_compressed, 1);
+  assert.ok(out.body.messages[0].content[0].content[0].text.includes('⟦elided:'));
+});
+
+test('PXY-6: disabled compression context is a no-op', () => {
+  const body = { messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 't', content: bigLog() }] }] };
+  const out = proxy.compressAnthropicBody(body, { enabled: false, store: () => 'x' });
+  assert.equal(out.stats.blocks_compressed, 0);
+  assert.equal(out.body, body);
+});
+
+test('PXY-7: end-to-end — child request is crushed in flight, forwarded, response piped back', async () => {
+  const cwd = ws({ '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true } }) });
+
+  let received = null;
+  const upstream = http.createServer((req, res) => {
+    const cs = [];
+    req.on('data', (c) => cs.push(c));
+    req.on('end', () => {
+      received = { path: req.url, auth: req.headers['x-api-key'], body: Buffer.concat(cs).toString('utf-8') };
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, id: 'msg_123' }));
+    });
+  });
+  _servers.push(upstream);
+  await new Promise((r) => upstream.listen(0, '127.0.0.1', r));
+  const upstreamUrl = 'http://127.0.0.1:' + upstream.address().port;
+
+  const { server, baseUrl } = await proxy.start({ cwd, upstream: upstreamUrl });
+  _servers.push(server);
+
+  const reqBody = JSON.stringify({
+    model: 'claude',
+    messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu', content: bigLog() }] }],
+  });
+  const resp = await new Promise((resolve, reject) => {
+    const u = new URL(baseUrl + '/v1/messages');
+    const r = http.request({ hostname: u.hostname, port: u.port, path: u.pathname, method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-api-key': 'sk-test', 'content-length': Buffer.byteLength(reqBody) } },
+      (res) => { const cs = []; res.on('data', (c) => cs.push(c)); res.on('end', () => resolve({ status: res.statusCode, body: Buffer.concat(cs).toString('utf-8') })); });
+    r.on('error', reject);
+    r.end(reqBody);
+  });
+
+  assert.equal(resp.status, 200);
+  assert.deepEqual(JSON.parse(resp.body), { ok: true, id: 'msg_123' }, 'upstream response piped through unchanged');
+  assert.equal(received.path, '/v1/messages', 'path forwarded');
+  assert.equal(received.auth, 'sk-test', 'auth header forwarded');
+  assert.ok(received.body.length < reqBody.length, 'upstream got a smaller body');
+  assert.ok(received.body.includes('⟦elided:'), 'tool_result was crushed in flight');
+  const hash = JSON.parse(received.body).messages[0].content[0].content.match(/⟦elided:([a-f0-9]{12})/)[1];
+  const back = require('./elision.cjs').retrieve(hash, cwd);
+  assert.equal(back.status, 'ok');
+  assert.ok(back.original.includes('ERROR: boom at svc_0'), 'original recoverable from the ledger');
+});
+
+test('PXY-10: cache_align normalizes tools and adds a breakpoint in flight when opted in', async () => {
+  const cwd = ws({ '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true, cache_align: { enabled: true } } }) });
+  let received = null;
+  const upstream = http.createServer((req, res) => {
+    const cs = []; req.on('data', (c) => cs.push(c));
+    req.on('end', () => { received = Buffer.concat(cs).toString('utf-8'); res.writeHead(200, { 'content-type': 'application/json' }); res.end('{"ok":true}'); });
+  });
+  _servers.push(upstream);
+  await new Promise((r) => upstream.listen(0, '127.0.0.1', r));
+  const { server, baseUrl } = await proxy.start({ cwd, upstream: 'http://127.0.0.1:' + upstream.address().port });
+  _servers.push(server);
+
+  const reqBody = JSON.stringify({
+    model: 'claude',
+    system: 'plain stable system',
+    tools: [{ name: 'zeta' }, { name: 'alpha' }],
+    messages: [{ role: 'user', content: 'hi' }],
+  });
+  await new Promise((resolve, reject) => {
+    const u = new URL(baseUrl + '/v1/messages');
+    const r = http.request({ hostname: u.hostname, port: u.port, path: u.pathname, method: 'POST',
+      headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(reqBody) } },
+      (res) => { const cs = []; res.on('data', (c) => cs.push(c)); res.on('end', resolve); });
+    r.on('error', reject);
+    r.end(reqBody);
+  });
+  const got = JSON.parse(received);
+  assert.deepEqual(got.tools.map((t) => t.name), ['alpha', 'zeta'], 'tools sorted for a stable prefix');
+  assert.deepEqual(got.tools[1].cache_control, { type: 'ephemeral' }, 'breakpoint added on the last tool');
+});
+
+test('PXY-9: forked entry reports its baseUrl over IPC and crushes traffic (spawn-headless mechanism)', async () => {
+  const cwd = ws({ '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true, proxy: { enabled: true } } }) });
+  let received = null;
+  const upstream = http.createServer((req, res) => {
+    const cs = []; req.on('data', (c) => cs.push(c));
+    req.on('end', () => { received = Buffer.concat(cs).toString('utf-8'); res.writeHead(200, { 'content-type': 'application/json' }); res.end('{"ok":true}'); });
+  });
+  _servers.push(upstream);
+  await new Promise((r) => upstream.listen(0, '127.0.0.1', r));
+
+  const entry = path.join(__dirname, '..', 'bin', 'np-tools', '_elision-proxy-entry.cjs');
+  const proc = child_process.fork(entry, [], {
+    env: Object.assign({}, process.env, { ELISION_PROXY_CWD: cwd, ELISION_PROXY_UPSTREAM: 'http://127.0.0.1:' + upstream.address().port }),
+    stdio: ['ignore', 'ignore', 'inherit', 'ipc'],
+  });
+  _procs.push(proc);
+  const baseUrl = await new Promise((resolve, reject) => {
+    proc.once('message', (m) => (m && m.ready ? resolve(m.baseUrl) : reject(new Error(m && m.error))));
+    proc.once('error', reject);
+  });
+  assert.match(baseUrl, /^http:\/\/127\.0\.0\.1:\d+$/);
+
+  const reqBody = JSON.stringify({ model: 'claude', messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu', content: bigLog() }] }] });
+  const status = await new Promise((resolve, reject) => {
+    const u = new URL(baseUrl + '/v1/messages');
+    const r = http.request({ hostname: u.hostname, port: u.port, path: u.pathname, method: 'POST',
+      headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(reqBody) } },
+      (res) => { res.resume(); res.on('end', () => resolve(res.statusCode)); });
+    r.on('error', reject); r.end(reqBody);
+  });
+  assert.equal(status, 200);
+  assert.ok(received && received.includes('⟦elided:'), 'forked proxy crushed the tool_result before forwarding');
+});
+
+test('PXY-8: non-JSON body is forwarded untouched (no crash)', async () => {
+  const cwd = ws({ '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true } }) });
+  let received = null;
+  const upstream = http.createServer((req, res) => {
+    const cs = []; req.on('data', (c) => cs.push(c));
+    req.on('end', () => { received = Buffer.concat(cs).toString('utf-8'); res.writeHead(200); res.end('pong'); });
+  });
+  _servers.push(upstream);
+  await new Promise((r) => upstream.listen(0, '127.0.0.1', r));
+  const { server, baseUrl } = await proxy.start({ cwd, upstream: 'http://127.0.0.1:' + upstream.address().port });
+  _servers.push(server);
+
+  const resp = await new Promise((resolve, reject) => {
+    const u = new URL(baseUrl + '/v1/messages');
+    const r = http.request({ hostname: u.hostname, port: u.port, path: u.pathname, method: 'POST',
+      headers: { 'content-type': 'text/plain', 'content-length': 11 } }, (res) => {
+      const cs = []; res.on('data', (c) => cs.push(c)); res.on('end', () => resolve({ status: res.statusCode, body: Buffer.concat(cs).toString('utf-8') }));
+    });
+    r.on('error', reject); r.end('not a json!');
+  });
+  assert.equal(resp.status, 200);
+  assert.equal(resp.body, 'pong');
+  assert.equal(received, 'not a json!', 'non-JSON forwarded verbatim');
+});

package/lib/elision.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const { NubosPilotError, atomicWriteFileSync, withFileLock, findProjectRoot } = require('./core.cjs');
+const { validate } = require('./validate.cjs');
+const config = require('./config.cjs');
+const { DEFAULT_COMPRESSION } = require('./config-defaults.cjs');
+const logger = require('./logger.cjs').child('elision');
+
+const STORE_VERSION = 1;
+const STORE_SCHEMA = 'elision-entry.v1';
+const HASH_LEN = 12;
+const HASH_RE = /^[a-f0-9]{12}$/;
+const DEFAULT_TTL_MS = 30 * 60 * 1000;
+const DEFAULT_VERIFY_MAX_BYTES = 2000;
+
+function hashOf(text) {
+  return crypto.createHash('sha256').update(text == null ? '' : String(text)).digest('hex').slice(0, HASH_LEN);
+}
+
+function _elisionDir(cwd) {
+  let root;
+  try { root = findProjectRoot(cwd); }
+  catch { root = cwd || process.cwd(); }
+  return path.join(root, '.nubos-pilot', 'elision');
+}
+
+function _entryPath(cwd, hash) {
+  return path.join(_elisionDir(cwd), hash + '.json');
+}
+
+function _isExpired(entry, now) {
+  if (!entry || typeof entry.created_at !== 'string') return true;
+  const created = Date.parse(entry.created_at);
+  if (!Number.isFinite(created)) return true;
+  const ttl = Number.isFinite(entry.ttl_ms) ? entry.ttl_ms : DEFAULT_TTL_MS;
+  if (ttl <= 0) return false;
+  return now - created > ttl;
+}
+
+function store(original, meta, cwd) {
+  const text = original == null ? '' : String(original);
+  const m = meta || {};
+  const hash = hashOf(text);
+  if (!HASH_RE.test(hash)) {
+    throw new NubosPilotError('elision-hash-invalid', 'computed Elision hash is malformed', { hash });
+  }
+  const target = _entryPath(cwd, hash);
+  return withFileLock(target, () => {
+    if (fs.existsSync(target)) return hash;
+    const entry = {
+      version: STORE_VERSION,
+      hash,
+      original: text,
+      type: typeof m.type === 'string' ? m.type.slice(0, 64) : 'plain',
+      created_at: new Date().toISOString(),
+      ttl_ms: Number.isFinite(m.ttlMs) ? Math.max(0, Math.round(m.ttlMs)) : DEFAULT_TTL_MS,
+      original_bytes: Buffer.byteLength(text, 'utf-8'),
+      compressed_bytes: Number.isFinite(m.compressedBytes) ? Math.max(0, Math.round(m.compressedBytes)) : 0,
+    };
+    const errors = validate(entry, STORE_SCHEMA);
+    if (errors.length) {
+      throw new NubosPilotError('elision-entry-invalid', 'refusing to persist malformed Elision entry', { errors });
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    atomicWriteFileSync(target, JSON.stringify(entry), 'utf-8', 0o600);
+    logger.debug('stored', { hash, type: entry.type, original_bytes: entry.original_bytes });
+    return hash;
+  });
+}
+
+function retrieve(hash, cwd) {
+  if (typeof hash !== 'string' || !HASH_RE.test(hash)) {
+    return { status: 'not_found', hash: String(hash) };
+  }
+  const target = _entryPath(cwd, hash);
+  let raw;
+  try { raw = fs.readFileSync(target, 'utf-8'); }
+  catch { return { status: 'not_found', hash }; }
+  let entry;
+  try { entry = JSON.parse(raw); }
+  catch { return { status: 'not_found', hash }; }
+  if (_isExpired(entry, Date.now())) {
+    return { status: 'expired', hash, ttl_ms: entry.ttl_ms, created_at: entry.created_at };
+  }
+  return {
+    status: 'ok',
+    hash,
+    original: typeof entry.original === 'string' ? entry.original : '',
+    type: entry.type || 'plain',
+    original_bytes: entry.original_bytes || 0,
+  };
+}
+
+function prune(cwd) {
+  const dir = _elisionDir(cwd);
+  let names;
+  try { names = fs.readdirSync(dir); }
+  catch { return { removed: 0 }; }
+  const now = Date.now();
+  let removed = 0;
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const p = path.join(dir, name);
+    let entry;
+    try { entry = JSON.parse(fs.readFileSync(p, 'utf-8')); }
+    catch { continue; }
+    if (_isExpired(entry, now)) {
+      try { fs.unlinkSync(p); removed += 1; }
+      catch { /* leave lapsed entry for the next prune */ }
+    }
+  }
+  if (removed) logger.info('pruned', { removed });
+  return { removed };
+}
+
+function compressionContext(cwd) {
+  let cfg;
+  try { cfg = config.tryReadConfigPath(cwd, 'compression', DEFAULT_COMPRESSION) || DEFAULT_COMPRESSION; }
+  catch { cfg = DEFAULT_COMPRESSION; }
+  const enabled = cfg.enabled === true;
+  const elisionEnabled = enabled && (!cfg.elision || cfg.elision.enabled !== false);
+  const ttlMs = cfg.elision && Number.isFinite(cfg.elision.ttl_ms) ? cfg.elision.ttl_ms : undefined;
+  const storeFn = elisionEnabled
+    ? (original, type) => {
+        try { return store(original, { type, ttlMs }, cwd); }
+        catch { return null; }
+      }
+    : null;
+  const os = cfg.output_steering || {};
+  const er = os.effort_routing || {};
+  const baseEffort = typeof er.base_effort === 'string' && er.base_effort ? er.base_effort : null;
+  const outputSteering = {
+    enabled: enabled && os.enabled === true,
+    profile: typeof os.verbosity_profile === 'string' ? os.verbosity_profile : 'balanced',
+    effortRouting: enabled && os.enabled === true && er.enabled === true && baseEffort !== null,
+    baseEffort,
+    mechanicalEffort: typeof er.mechanical_effort === 'string' ? er.mechanical_effort : 'low',
+  };
+  return {
+    enabled,
+    store: storeFn,
+    minBlockBytes: Number.isFinite(cfg.min_block_bytes) ? cfg.min_block_bytes : undefined,
+    verifyMaxBytes: Number.isFinite(cfg.verify_max_bytes) ? cfg.verify_max_bytes : DEFAULT_VERIFY_MAX_BYTES,
+    outputSteering,
+    cacheAlign: enabled && !!(cfg.cache_align && cfg.cache_align.enabled === true),
+  };
+}
+
+module.exports = {
+  STORE_VERSION,
+  HASH_LEN,
+  HASH_RE,
+  DEFAULT_TTL_MS,
+  hashOf,
+  store,
+  retrieve,
+  prune,
+  compressionContext,
+};

package/lib/elision.test.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const elision = require('./elision.cjs');
+
+function sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-elision-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  return root;
+}
+
+function writeConfig(root, compression) {
+  fs.writeFileSync(
+    path.join(root, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ compression }),
+  );
+}
+
+test('ELISION-1: store then retrieve is lossless', () => {
+  const root = sandbox();
+  try {
+    const original = 'line one\nERROR boom\nline three';
+    const hash = elision.store(original, { type: 'log' }, root);
+    assert.match(hash, /^[a-f0-9]{12}$/);
+    const got = elision.retrieve(hash, root);
+    assert.equal(got.status, 'ok');
+    assert.equal(got.original, original);
+    assert.equal(got.type, 'log');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-2: store is idempotent for identical content', () => {
+  const root = sandbox();
+  try {
+    const h1 = elision.store('same', { type: 'plain' }, root);
+    const p = path.join(root, '.nubos-pilot', 'elision', h1 + '.json');
+    const mtime1 = fs.statSync(p).mtimeMs;
+    const h2 = elision.store('same', { type: 'plain' }, root);
+    assert.equal(h2, h1);
+    assert.equal(fs.statSync(p).mtimeMs, mtime1);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-3: unknown and malformed hashes return not_found', () => {
+  const root = sandbox();
+  try {
+    assert.equal(elision.retrieve('aaaaaaaaaaaa', root).status, 'not_found');
+    assert.equal(elision.retrieve('NOT-A-HASH', root).status, 'not_found');
+    assert.equal(elision.retrieve(null, root).status, 'not_found');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-4: an entry past its ttl reports expired', () => {
+  const root = sandbox();
+  try {
+    const hash = elision.hashOf('old payload');
+    const dir = path.join(root, '.nubos-pilot', 'elision');
+    fs.mkdirSync(dir, { recursive: true });
+    const entry = {
+      version: 1,
+      hash,
+      original: 'old payload',
+      type: 'plain',
+      created_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+      ttl_ms: 1000,
+      original_bytes: 11,
+      compressed_bytes: 0,
+    };
+    fs.writeFileSync(path.join(dir, hash + '.json'), JSON.stringify(entry));
+    assert.equal(elision.retrieve(hash, root).status, 'expired');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-5: prune removes only expired entries', () => {
+  const root = sandbox();
+  try {
+    const fresh = elision.store('fresh', { type: 'plain' }, root);
+    const staleHash = elision.hashOf('stale');
+    const dir = path.join(root, '.nubos-pilot', 'elision');
+    fs.writeFileSync(path.join(dir, staleHash + '.json'), JSON.stringify({
+      version: 1, hash: staleHash, original: 'stale', type: 'plain',
+      created_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+      ttl_ms: 1000, original_bytes: 5, compressed_bytes: 0,
+    }));
+    const res = elision.prune(root);
+    assert.equal(res.removed, 1);
+    assert.equal(elision.retrieve(fresh, root).status, 'ok');
+    assert.equal(elision.retrieve(staleHash, root).status, 'not_found');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-6: compressionContext is disabled by default', () => {
+  const root = sandbox();
+  try {
+    const cx = elision.compressionContext(root);
+    assert.equal(cx.enabled, false);
+    assert.equal(cx.store, null);
+    assert.equal(cx.verifyMaxBytes, 2000);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-7: compressionContext yields a working store when enabled', () => {
+  const root = sandbox();
+  try {
+    writeConfig(root, { enabled: true });
+    const cx = elision.compressionContext(root);
+    assert.equal(cx.enabled, true);
+    assert.equal(typeof cx.store, 'function');
+    const hash = cx.store('cached body', 'plain');
+    assert.equal(elision.retrieve(hash, root).original, 'cached body');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('ELISION-8: compressionContext store is null when elision is disabled', () => {
+  const root = sandbox();
+  try {
+    writeConfig(root, { enabled: true, elision: { enabled: false } });
+    const cx = elision.compressionContext(root);
+    assert.equal(cx.enabled, true);
+    assert.equal(cx.store, null);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/git.cjs

@@ -92,7 +92,7 @@ function commitTask(taskId, files, message) {
   };
 }
 
-function findCommitByTaskId(id) {
+function findCommitByTaskId(id, cwd) {
   if (typeof id !== 'string' || !TASK_ID_RE.test(id)) {
     throw new NubosPilotError(
       'task-commit-not-found',
@@ -101,6 +101,8 @@ function findCommitByTaskId(id) {
     );
   }
 
+  const spawnOpts = { encoding: 'utf-8', timeout: GIT_TIMEOUT_MS };
+  if (cwd) spawnOpts.cwd = cwd;
   const out = execFileSync(
     'git',
     [
@@ -112,7 +114,7 @@ function findCommitByTaskId(id) {
       '1',
       '--format=%H',
     ],
-    { encoding: 'utf-8', timeout: GIT_TIMEOUT_MS },
+    spawnOpts,
   ).trim();
   if (!out) {
     throw new NubosPilotError(

package/lib/nubosloop.cjs

@@ -357,7 +357,7 @@ async function preflightCacheLookup(query, opts, cwd) {
   const spawnInput = taskId
     ? { task_id: taskId, task_query: query }
     : { task_query: query };
-  const spawnSpecs = swarm.buildSpawnSpecs(spawnInput, o.k);
+  const spawnSpecs = swarm.buildSpawnSpecs(spawnInput, o.k, { cwd });
   const swarmBlock = {
     k: o.k,
     threshold: o.threshold,

package/lib/output-steering.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+const OPEN = '<nubos_output_shaping>';
+const CLOSE = '</nubos_output_shaping>';
+const SHAPING_RE = /\n*<nubos_output_shaping>[\s\S]*?<\/nubos_output_shaping>\s*$/;
+
+const PROFILES = Object.freeze({
+  balanced: '',
+  concise: 'Skip preamble and postamble; lead with the substance. Do not restate code, file '
+    + 'contents, diffs, or tool output that already appear above — reference them by path and line.',
+  terse: 'Skip preamble and postamble; lead with the substance. Never restate code, files, '
+    + 'diffs, or tool output already present — reference them by path and line. After a tool '
+    + 'call succeeds, continue without narrating the result.',
+  minimal: 'Minimum tokens. Fragments are fine. No preamble, no postamble, no narration. Never '
+    + 'restate existing code, files, diffs, or tool output — reference by path and line. State '
+    + 'only what changed or what the answer is.',
+});
+
+const EFFORT_RANK = Object.freeze({ low: 0, medium: 1, high: 2, xhigh: 3, max: 4 });
+
+function steeringDirective(profile) {
+  const key = typeof profile === 'string' ? profile.toLowerCase() : 'balanced';
+  return Object.prototype.hasOwnProperty.call(PROFILES, key) ? PROFILES[key] : '';
+}
+
+function enrichSystemPrompt(prompt, profile) {
+  const base = String(prompt == null ? '' : prompt).replace(SHAPING_RE, '');
+  const directive = steeringDirective(profile);
+  if (!directive) return base;
+  return base + '\n\n' + OPEN + '\n' + directive + '\n' + CLOSE;
+}
+
+function classifyTurn(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return 'new_user_ask';
+  let lastAssistant = -1;
+  for (let k = messages.length - 1; k >= 0; k -= 1) {
+    if (messages[k] && messages[k].role === 'assistant') { lastAssistant = k; break; }
+  }
+  const pending = messages.slice(lastAssistant + 1);
+  if (pending.length === 0) return 'new_user_ask';
+  if (pending.some((m) => m && m.role === 'user')) return 'new_user_ask';
+  const tools = pending.filter((m) => m && m.role === 'tool');
+  if (tools.length === 0) return 'new_user_ask';
+  return tools.some((m) => _isErrorResult(m.content)) ? 'error_continuation' : 'mechanical_continuation';
+}
+
+function _isErrorResult(content) {
+  const s = String(content == null ? '' : content);
+  return /^Error:/.test(s) || /\b(ERROR|FAILED|FATAL|Exception|Traceback)\b/.test(s);
+}
+
+function routeEffort(currentEffort, turnKind, opts) {
+  const o = opts || {};
+  if (typeof currentEffort !== 'string' || !(currentEffort in EFFORT_RANK)) return currentEffort;
+  if (turnKind !== 'mechanical_continuation') return currentEffort;
+  const target = typeof o.mechanicalEffort === 'string' && o.mechanicalEffort in EFFORT_RANK
+    ? o.mechanicalEffort : 'low';
+  return EFFORT_RANK[target] < EFFORT_RANK[currentEffort] ? target : currentEffort;
+}
+
+module.exports = {
+  PROFILES,
+  EFFORT_RANK,
+  steeringDirective,
+  enrichSystemPrompt,
+  classifyTurn,
+  routeEffort,
+};