nubos-pilot 1.2.4 → 1.3.1

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/learnings/extract.cjs

@@ -124,7 +124,7 @@ function parseExtractorOutput(raw) {
   return { candidates, parse_ok: true };
 }
 
-function _defaultSpawn(promptText, opts) {
+async function _defaultSpawn(promptText, opts) {
   const spawnHeadless = require('../../bin/np-tools/spawn-headless.cjs');
   const tmp = os.tmpdir();
   const tag = process.pid + '-' + crypto.randomBytes(4).toString('hex');
@@ -132,7 +132,7 @@ function _defaultSpawn(promptText, opts) {
   const outputPath = path.join(tmp, 'np-learn-out-' + tag + '.json');
   fs.writeFileSync(promptPath, promptText, 'utf-8');
   try {
-    spawnHeadless.run(
+    await spawnHeadless.run(
       ['--agent', EXTRACTOR_AGENT, '--prompt-path', promptPath, '--output-path', outputPath,
         '--timeout-ms', String(opts.timeoutMs)],
       { cwd: opts.cwd, stdout: { write: () => {} } },
@@ -144,7 +144,7 @@ function _defaultSpawn(promptText, opts) {
   }
 }
 
-function runExtract(opts) {
+async function runExtract(opts) {
   const o = opts || {};
   const cwd = o.cwd || process.cwd();
   const config = o.config || {};
@@ -164,7 +164,7 @@ function runExtract(opts) {
   const promptText = buildExtractorPrompt(diff);
   let raw = '';
   try {
-    raw = spawn(promptText, { cwd, timeoutMs: config.timeout_ms || 120000 });
+    raw = await spawn(promptText, { cwd, timeoutMs: config.timeout_ms || 120000 });
   } catch {
     return { ran: true, logged: 0, reason: 'spawn-failed' };
   }

package/lib/learnings/extract.test.cjs

@@ -67,31 +67,31 @@ test('EX-6: non-JSON output → parse_ok false', () => {
   assert.strictEqual(extract.parseExtractorOutput('').parse_ok, false);
 });
 
-test('EX-7: runExtract on a non-repo returns not-a-repo, logs nothing', () => {
+test('EX-7: runExtract on a non-repo returns not-a-repo, logs nothing', async () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-norepo-'));
   try {
     const logged = [];
-    const r = extract.runExtract({ cwd: dir, spawnImpl: () => '{}', logImpl: (c) => logged.push(c) });
+    const r = await extract.runExtract({ cwd: dir, spawnImpl: () => '{}', logImpl: (c) => logged.push(c) });
     assert.strictEqual(r.ran, false);
     assert.strictEqual(r.reason, 'not-a-repo');
     assert.strictEqual(logged.length, 0);
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
 
-test('EX-8: runExtract on empty repo (no commit, no changes) → empty-diff', () => {
+test('EX-8: runExtract on empty repo (no commit, no changes) → empty-diff', async () => {
   const dir = _gitRepo(false);
   try {
-    const r = extract.runExtract({ cwd: dir, spawnImpl: () => '{}', logImpl: () => {} });
+    const r = await extract.runExtract({ cwd: dir, spawnImpl: () => '{}', logImpl: () => {} });
     assert.strictEqual(r.ran, true);
     assert.strictEqual(r.reason, 'empty-diff');
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
 
-test('EX-9: runExtract over a commit logs parsed candidates', () => {
+test('EX-9: runExtract over a commit logs parsed candidates', async () => {
   const dir = _gitRepo(true);
   try {
     const logged = [];
-    const r = extract.runExtract({
+    const r = await extract.runExtract({
       cwd: dir,
       spawnImpl: () => JSON.stringify({ result: JSON.stringify({ learnings: [
         { pattern: 'keep add() pure and total', outcome: 'verified' },
@@ -104,11 +104,11 @@ test('EX-9: runExtract over a commit logs parsed candidates', () => {
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
 
-test('EX-10: runExtract with unparseable spawn output → parse-failed, no log', () => {
+test('EX-10: runExtract with unparseable spawn output → parse-failed, no log', async () => {
   const dir = _gitRepo(true);
   try {
     const logged = [];
-    const r = extract.runExtract({ cwd: dir, spawnImpl: () => 'garbage', logImpl: (c) => logged.push(c) });
+    const r = await extract.runExtract({ cwd: dir, spawnImpl: () => 'garbage', logImpl: (c) => logged.push(c) });
     assert.strictEqual(r.reason, 'parse-failed');
     assert.strictEqual(logged.length, 0);
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }