@build-astron-co/nimbus 0.3.0 → 0.4.0

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@build-astron-co/nimbus",
-  "version": "0.3.0",
-  "description": "AI-Powered Cloud Engineering Agent",
-  "main": "src/nimbus.ts",
+  "version": "0.4.0",
+  "description": "AI-Powered DevOps Engineering Agent",
+  "main": "dist/src/nimbus.js",
   "bin": {
-    "nimbus": "bin/nimbus"
+    "nimbus": "bin/nimbus.mjs"
   },
   "files": [
     "bin/",
     "src/",
+    "dist/",
+    "completions/",
     "package.json",
     "tsconfig.json"
   ],
@@ -28,20 +30,24 @@
     "build:binary": "./scripts/build-binary.sh",
     "build:binary:all": "./scripts/build-binary.sh all",
     "nimbus": "node --loader ./node_modules/tsx/dist/esm/index.mjs src/nimbus.ts",
-    "precommit": "npm run lint && npm run format:check && npm run type-check"
+    "build:npm": "tsc --project tsconfig.build.json",
+    "prepare": "npm run build:npm",
+    "prepack": "tsc --project tsconfig.build.json",
+    "precommit": "npm run lint && npm run format:check && npm run type-check",
+    "postinstall": "node -e \"process.stdout.write('\\n  Nimbus installed! Next steps:\\n  1. Run: nimbus login              (configure your LLM provider)\\n  2. Run: nimbus doctor             (check your DevOps toolchain)\\n  3. Run: nimbus completions install (enable tab completion)\\n  4. Run: nimbus                    (start the DevOps agent)\\n\\n')\""
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.0.0",
     "@types/react": "^19.2.14",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
-    "@vitest/coverage-v8": "^2.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^8.57.0",
     "prettier": "^3.2.5",
     "typescript": "^5.3.3",
-    "vitest": "^2.0.0"
+    "vitest": "^3.2.4"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -62,20 +68,21 @@
     "openai": "^6.22.0",
     "react": "^19.2.4",
     "simple-git": "^3.32.1",
-    "better-sqlite3": "^11.0.0",
     "tsx": "^4.7.0",
     "zod": "^4.3.6"
   },
   "optionalDependencies": {
-    "@azure/identity": "^4.0.0",
+    "better-sqlite3": "^11.0.0",
+    "sql.js": "^1.12.0",
     "@azure/arm-compute": "^22.0.0",
-    "@azure/arm-storage": "^18.0.0",
     "@azure/arm-containerservice": "^21.0.0",
     "@azure/arm-network": "^33.0.0",
-    "google-auth-library": "^9.0.0",
+    "@azure/arm-storage": "^18.0.0",
+    "@azure/identity": "^4.0.0",
     "@google-cloud/compute": "^4.0.0",
-    "@google-cloud/storage": "^7.0.0",
     "@google-cloud/container": "^5.0.0",
-    "@octokit/rest": "^21.0.0"
+    "@google-cloud/storage": "^7.0.0",
+    "@octokit/rest": "^21.0.0",
+    "google-auth-library": "^9.0.0"
   }
 }

package/src/__tests__/alias.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Alias Command Tests — L2
+ *
+ * Tests resolveAlias expansion and alias file management.
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+// Patch homedir so aliases are stored in a temp dir during tests
+let tmpDir: string;
+
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof os>('node:os');
+  return {
+    ...actual,
+    homedir: () => tmpDir ?? actual.homedir(),
+  };
+});
+
+// Re-import after mock is set up (dynamic to pick up the homedir mock)
+async function getAliasModule() {
+  // Force re-import so homedir mock is active
+  return await import('../commands/alias');
+}
+
+describe('resolveAlias (L2)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-alias-test-'));
+    // Clear module cache so homedir mock takes effect
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.resetModules();
+  });
+
+  test('returns args unchanged when no alias exists', async () => {
+    const { resolveAlias } = await getAliasModule();
+    expect(resolveAlias(['run', '--help'])).toEqual(['run', '--help']);
+  });
+
+  test('returns empty array for empty input', async () => {
+    const { resolveAlias } = await getAliasModule();
+    expect(resolveAlias([])).toEqual([]);
+  });
+
+  test('expands a defined alias', async () => {
+    // Write alias file manually
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(nimbusDir, 'aliases.json'),
+      JSON.stringify({ deploy: 'run --auto-approve "deploy staging"' }),
+      'utf-8'
+    );
+
+    const { resolveAlias } = await getAliasModule();
+    const result = resolveAlias(['deploy']);
+    expect(result[0]).toBe('run');
+    expect(result).toContain('--auto-approve');
+  });
+
+  test('appends remaining args after expanding alias', async () => {
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(nimbusDir, 'aliases.json'),
+      JSON.stringify({ tf: 'run "terraform plan"' }),
+      'utf-8'
+    );
+
+    const { resolveAlias } = await getAliasModule();
+    const result = resolveAlias(['tf', '--verbose']);
+    expect(result[result.length - 1]).toBe('--verbose');
+  });
+});
+
+describe('aliasCommand list/add/remove (L2)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-alias-cmd-test-'));
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.resetModules();
+  });
+
+  test('list shows "no aliases" when file is absent', async () => {
+    const { aliasCommand } = await getAliasModule();
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+    // Should not throw even if file doesn't exist
+    await expect(aliasCommand('list', [])).resolves.not.toThrow();
+    vi.restoreAllMocks();
+  });
+
+  test('set writes alias to file', async () => {
+    const { aliasCommand } = await getAliasModule();
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await aliasCommand('myalias=run "do something"', []);
+
+    const aliasFile = path.join(tmpDir, '.nimbus', 'aliases.json');
+    const data = JSON.parse(fs.readFileSync(aliasFile, 'utf-8')) as Record<string, string>;
+    expect(data['myalias']).toBe('run "do something"');
+    vi.restoreAllMocks();
+  });
+
+  test('remove deletes alias from file', async () => {
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(nimbusDir, 'aliases.json'),
+      JSON.stringify({ myalias: 'run stuff' }),
+      'utf-8'
+    );
+
+    const { aliasCommand } = await getAliasModule();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await aliasCommand('remove', ['myalias']);
+
+    const data = JSON.parse(fs.readFileSync(path.join(nimbusDir, 'aliases.json'), 'utf-8')) as Record<string, string>;
+    expect(data['myalias']).toBeUndefined();
+    vi.restoreAllMocks();
+  });
+});

package/src/__tests__/cli-run.test.ts

@@ -5,7 +5,7 @@
  * structured RunOptions for the non-interactive nimbus run command.
  */
 
-import { describe, test, expect } from 'vitest';
+import { describe, test, it, expect } from 'vitest';
 import { parseRunArgs } from '../cli/run';
 
 // ===========================================================================
@@ -29,6 +29,12 @@ describe('parseRunArgs', () => {
     expect(result.format).toBe('json');
   });
 
+  test('parses --format table (H4)', () => {
+    const result = parseRunArgs(['--format', 'table', 'my prompt']);
+    expect(result.format).toBe('table');
+    expect(result.prompt).toBe('my prompt');
+  });
+
   test('parses --auto-approve', () => {
     const result = parseRunArgs(['--auto-approve', 'do', 'stuff']);
     expect(result.autoApprove).toBe(true);
@@ -112,4 +118,234 @@ describe('parseRunArgs', () => {
     expect(result.model).toBe('openai/gpt-4');
     expect(result.prompt).toBe('deploy everything');
   });
+
+  // G13: --timeout flag
+  test('G13: parses --timeout <seconds> into milliseconds', () => {
+    const result = parseRunArgs(['--timeout', '30', 'my prompt']);
+    expect(result.timeout).toBe(30000);
+    expect(result.prompt).toBe('my prompt');
+  });
+
+  test('G13: timeout defaults to undefined when not specified', () => {
+    const result = parseRunArgs(['my prompt']);
+    expect(result.timeout).toBeUndefined();
+  });
+
+  test('G13: parses --timeout 0 as 0 ms', () => {
+    const result = parseRunArgs(['--timeout', '0', 'prompt']);
+    expect(result.timeout).toBe(0);
+  });
+
+  // G15: --raw-tool-output flag
+  test('G15: parses --raw-tool-output flag', () => {
+    const result = parseRunArgs(['--raw-tool-output', 'show pod status']);
+    expect(result.rawToolOutput).toBe(true);
+    expect(result.prompt).toBe('show pod status');
+  });
+
+  test('G15: rawToolOutput defaults to false', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.rawToolOutput).toBe(false);
+  });
+
+  test('G13 + G15: combines timeout and raw-tool-output with other flags', () => {
+    const result = parseRunArgs([
+      '--timeout', '60',
+      '--raw-tool-output',
+      '--auto-approve',
+      'list all pods',
+    ]);
+    expect(result.timeout).toBe(60000);
+    expect(result.rawToolOutput).toBe(true);
+    expect(result.autoApprove).toBe(true);
+    expect(result.prompt).toBe('list all pods');
+  });
+
+  // H3: CI/CD flags
+  test('H3: parses --exit-code-on-error flag', () => {
+    const result = parseRunArgs(['--exit-code-on-error', 'run tests']);
+    expect(result.exitOnError).toBe(true);
+    expect(result.prompt).toBe('run tests');
+  });
+
+  test('C5: exitOnError defaults to true (POSIX convention)', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.exitOnError).toBe(true);
+  });
+
+  test('C5: --no-exit-on-error disables exitOnError', () => {
+    const result = parseRunArgs(['--no-exit-on-error', 'prompt']);
+    expect(result.exitOnError).toBe(false);
+  });
+
+  test('H3: parses --context <kubectl-context>', () => {
+    const result = parseRunArgs(['--context', 'prod-cluster', 'deploy app']);
+    expect(result.context).toBe('prod-cluster');
+    expect(result.prompt).toBe('deploy app');
+  });
+
+  test('H3: context defaults to undefined', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.context).toBeUndefined();
+  });
+
+  test('H3: parses --workspace <tf-workspace>', () => {
+    const result = parseRunArgs(['--workspace', 'production', 'run plan']);
+    expect(result.workspace).toBe('production');
+    expect(result.prompt).toBe('run plan');
+  });
+
+  test('H3: workspace defaults to undefined', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.workspace).toBeUndefined();
+  });
+
+  test('H3: parses --namespace <k8s-namespace>', () => {
+    const result = parseRunArgs(['--namespace', 'prod', 'list pods']);
+    expect(result.namespace).toBe('prod');
+    expect(result.prompt).toBe('list pods');
+  });
+
+  test('H3: parses -n as short form for --namespace', () => {
+    const result = parseRunArgs(['-n', 'kube-system', 'get pods']);
+    expect(result.namespace).toBe('kube-system');
+    expect(result.prompt).toBe('get pods');
+  });
+
+  test('H3: namespace defaults to undefined', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.namespace).toBeUndefined();
+  });
+
+  test('H3: parses --notify <url>', () => {
+    const result = parseRunArgs(['--notify', 'https://hooks.example.com/notify', 'do work']);
+    expect(result.notify).toBe('https://hooks.example.com/notify');
+    expect(result.prompt).toBe('do work');
+  });
+
+  test('H3: parses --notify-slack <url>', () => {
+    const result = parseRunArgs(['--notify-slack', 'https://hooks.slack.com/T123/B456', 'deploy']);
+    expect(result.notifySlack).toBe('https://hooks.slack.com/T123/B456');
+    expect(result.prompt).toBe('deploy');
+  });
+
+  test('H3: all CI/CD flags combined', () => {
+    const result = parseRunArgs([
+      '--exit-code-on-error',
+      '--context', 'staging-cluster',
+      '--workspace', 'staging',
+      '--namespace', 'staging',
+      '--notify', 'https://example.com/webhook',
+      '--notify-slack', 'https://hooks.slack.com/abc',
+      'run deployment',
+    ]);
+    expect(result.exitOnError).toBe(true);
+    expect(result.context).toBe('staging-cluster');
+    expect(result.workspace).toBe('staging');
+    expect(result.namespace).toBe('staging');
+    expect(result.notify).toBe('https://example.com/webhook');
+    expect(result.notifySlack).toBe('https://hooks.slack.com/abc');
+    expect(result.prompt).toBe('run deployment');
+  });
+
+  test('H3: --context sets KUBECTL_CONTEXT env var when executeRun processes it', () => {
+    // Test that parseRunArgs properly captures context for env injection
+    const result = parseRunArgs(['--context', 'my-context', 'test prompt']);
+    expect(result.context).toBe('my-context');
+    // The env var injection happens in executeRun; we test parseRunArgs captures it correctly
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L2: planSummary in JSON output
+// ---------------------------------------------------------------------------
+
+describe('planSummary in RunJsonOutput (L2)', () => {
+  it('RunJsonOutput interface has planSummary field', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/cli/run.ts'), 'utf-8');
+    expect(src).toContain('planSummary');
+  });
+
+  it('planSummary regex matches terraform plan output', () => {
+    const planOutput = 'Plan: 3 to add, 1 to change, 0 to destroy.';
+    const planLine = planOutput.match(/Plan:\s*(\d+)\s*to add,\s*(\d+)\s*to change,\s*(\d+)\s*to destroy/i);
+    expect(planLine).not.toBeNull();
+    expect(parseInt(planLine![1])).toBe(3);
+    expect(parseInt(planLine![2])).toBe(1);
+    expect(parseInt(planLine![3])).toBe(0);
+  });
+
+  it('planSummary regex works with large numbers', () => {
+    const planOutput = 'Plan: 150 to add, 42 to change, 7 to destroy.';
+    const planLine = planOutput.match(/Plan:\s*(\d+)\s*to add,\s*(\d+)\s*to change,\s*(\d+)\s*to destroy/i);
+    expect(planLine).not.toBeNull();
+    expect(parseInt(planLine![1])).toBe(150);
+    expect(parseInt(planLine![2])).toBe(42);
+    expect(parseInt(planLine![3])).toBe(7);
+  });
+});
+
+// ===========================================================================
+// C2: No staleness check in bin/nimbus.mjs
+// ===========================================================================
+
+describe('C2 — bin/nimbus.mjs startup optimizations', () => {
+  it('bin/nimbus.mjs does not import statSync', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'bin/nimbus.mjs'), 'utf-8');
+    expect(src).not.toContain('statSync');
+  });
+
+  it('bin/nimbus.mjs uses simple existsSync check for dist entry', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'bin/nimbus.mjs'), 'utf-8');
+    expect(src).toContain('existsSync(DIST_ENTRY)');
+  });
+});
+
+// ===========================================================================
+// H5: nimbus whoami wiring
+// ===========================================================================
+
+describe('H5 — nimbus whoami command', () => {
+  it('cli.ts contains whoami handler', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("command === 'whoami'");
+  });
+
+  it('cli.ts whoami calls authStatusCommand', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    // whoami section should call authStatusCommand
+    const whoamiIdx = src.indexOf("command === 'whoami'");
+    const authStatusIdx = src.indexOf('authStatusCommand({})', whoamiIdx);
+    expect(authStatusIdx).toBeGreaterThan(whoamiIdx);
+  });
+});
+
+// ===========================================================================
+// M1: nimbus diff top-level alias
+// ===========================================================================
+
+describe('M1 — nimbus diff alias', () => {
+  it('cli.ts contains diff command handler', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("command === 'diff'");
+  });
+
+  it('cli.ts diff calls fsCommand with "diff" subcommand', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("fsCommand('diff', args.slice(1))");
+  });
 });

package/src/__tests__/compat-sqlite.test.ts

@@ -0,0 +1,68 @@
+/**
+ * SQLite Compat Layer Tests — G1
+ *
+ * Validates that the sqlite compat module:
+ * - Has proper fallback entries in package.json optionalDependencies
+ * - Contains sql.js fallback code
+ * - Contains the in-memory warning text
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = join(__dirname, '..', '..');
+
+describe('package.json SQLite compat configuration (G1)', () => {
+  const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')) as {
+    scripts?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    dependencies?: Record<string, string>;
+  };
+
+  it('has better-sqlite3 in optionalDependencies', () => {
+    expect(pkg.optionalDependencies).toBeDefined();
+    expect(Object.keys(pkg.optionalDependencies!)).toContain('better-sqlite3');
+  });
+
+  it('has sql.js in optionalDependencies', () => {
+    expect(pkg.optionalDependencies).toBeDefined();
+    expect(Object.keys(pkg.optionalDependencies!)).toContain('sql.js');
+  });
+
+  it('has a prepack script defined', () => {
+    expect(pkg.scripts).toBeDefined();
+    expect(pkg.scripts!['prepack']).toBeDefined();
+    expect(typeof pkg.scripts!['prepack']).toBe('string');
+  });
+});
+
+describe('src/compat/sqlite.ts fallback implementation (G1)', () => {
+  const sqliteSrc = readFileSync(join(ROOT, 'src', 'compat', 'sqlite.ts'), 'utf-8');
+
+  it('contains the sql.js fallback require call', () => {
+    expect(sqliteSrc).toContain('sql.js');
+  });
+
+  it('contains the in-memory warning text', () => {
+    expect(sqliteSrc).toContain('in-memory');
+  });
+
+  it('contains the better-sqlite3 require call', () => {
+    expect(sqliteSrc).toContain('better-sqlite3');
+  });
+
+  it('defines a SqlJsDatabase class for the fallback path', () => {
+    expect(sqliteSrc).toContain('SqlJsDatabase');
+  });
+
+  it('exports exec, prepare, and close methods in SqlJsDatabase', () => {
+    expect(sqliteSrc).toContain('exec(sql');
+    expect(sqliteSrc).toContain('prepare(sql');
+    expect(sqliteSrc).toContain('close()');
+  });
+
+  it('contains install hint for better-sqlite3', () => {
+    expect(sqliteSrc).toContain('npm install better-sqlite3');
+  });
+});

package/src/__tests__/context-manager.test.ts

@@ -500,3 +500,133 @@ describe('Context Breakdown Formatting', () => {
     expect(display).toContain('1%');
   });
 });
+
+// ---------------------------------------------------------------------------
+// PERF-2b: Token count caching in ContextManager
+// ---------------------------------------------------------------------------
+
+describe('PERF-2b: ContextManager token count caching', () => {
+  let cm: ContextManager;
+
+  beforeEach(() => {
+    cm = new ContextManager({ maxContextTokens: 100_000 });
+  });
+
+  it('clearTokenCache() is a public method and does not throw', () => {
+    expect(() => cm.clearTokenCache()).not.toThrow();
+  });
+
+  it('calculateUsage returns the same result before and after clearTokenCache', () => {
+    const msgs: LLMMessage[] = [
+      { role: 'user', content: 'Hello there' },
+      { role: 'assistant', content: 'Hi! How can I help?' },
+    ];
+    const before = cm.calculateUsage('System prompt', msgs, 50);
+    cm.clearTokenCache();
+    const after = cm.calculateUsage('System prompt', msgs, 50);
+    expect(before.messages).toBe(after.messages);
+    expect(before.total).toBe(after.total);
+  });
+
+  it('repeated calculateUsage calls return identical token counts (cache consistent)', () => {
+    const msgs: LLMMessage[] = Array.from({ length: 20 }, (_, i) => ({
+      role: i % 2 === 0 ? ('user' as const) : ('assistant' as const),
+      content: `Message ${i}: ${'x'.repeat(50)}`,
+    }));
+    const first = cm.calculateUsage('sys', msgs, 0);
+    const second = cm.calculateUsage('sys', msgs, 0);
+    const third = cm.calculateUsage('sys', msgs, 0);
+    expect(first.messages).toBe(second.messages);
+    expect(second.messages).toBe(third.messages);
+  });
+
+  it('cache is invalidated by clearTokenCache (new message gets fresh count)', () => {
+    const msg: LLMMessage = { role: 'user', content: 'short' };
+    const msgs = [msg];
+    const before = cm.calculateUsage('sys', msgs, 0);
+    cm.clearTokenCache();
+    const after = cm.calculateUsage('sys', msgs, 0);
+    // Counts should still be equal — same message, same content
+    expect(before.messages).toBe(after.messages);
+  });
+
+  it('token cache handles tool call messages without error', () => {
+    const msgs: LLMMessage[] = [
+      {
+        role: 'assistant',
+        content: 'Calling tool',
+        toolCalls: [
+          {
+            id: 'tc1',
+            type: 'function',
+            function: { name: 'bash', arguments: '{"command":"ls"}' },
+          },
+        ],
+      },
+    ];
+    expect(() => cm.calculateUsage('sys', msgs, 0)).not.toThrow();
+    expect(() => cm.calculateUsage('sys', msgs, 0)).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// H3: Compaction preserves infraContext
+// ---------------------------------------------------------------------------
+
+describe('compaction preserves infraContext (H3)', () => {
+  it('compaction-agent.ts CompactionOptions has infraContext field', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/compaction-agent.ts'), 'utf-8');
+    expect(src).toContain('infraContext?:');
+  });
+
+  it('compaction injects ALWAYS PRESERVE section when infraContext provided', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/compaction-agent.ts'), 'utf-8');
+    expect(src).toContain('ALWAYS PRESERVE IN SUMMARY');
+  });
+
+  it('compaction prepends Infrastructure Context to summary', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/compaction-agent.ts'), 'utf-8');
+    expect(src).toContain('## Infrastructure Context');
+  });
+
+  it('context-manager default alwaysInContext includes Infrastructure Context', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/context-manager.ts'), 'utf-8');
+    expect(src).toContain("'Infrastructure Context'");
+  });
+
+  it('context-manager default alwaysInContext includes Tool Timeouts', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/context-manager.ts'), 'utf-8');
+    expect(src).toContain("'Tool Timeouts'");
+  });
+
+  it('compaction passes infraContext from runAgentLoop options', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
+    expect(src).toContain('infraContext: options.infraContext');
+  });
+
+  it('compaction-agent terraformWorkspace is serialized in infraLines', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/compaction-agent.ts'), 'utf-8');
+    expect(src).toContain('ic.terraformWorkspace');
+  });
+
+  it('compaction-agent kubectlContext is serialized in infraLines', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/agent/compaction-agent.ts'), 'utf-8');
+    expect(src).toContain('ic.kubectlContext');
+  });
+});