@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/__tests__/tool-schemas.test.ts

@@ -5,7 +5,7 @@
  * structures for both standard and DevOps tools.
  */
 
-import { describe, test, expect, beforeEach } from 'bun:test';
+import { describe, test, it, expect, beforeEach } from 'vitest';
 import { z } from 'zod';
 import {
   ToolRegistry,
@@ -14,7 +14,7 @@ import {
   type ToolDefinition,
 } from '../tools/schemas/types';
 import { standardTools } from '../tools/schemas/standard';
-import { devopsTools } from '../tools/schemas/devops';
+import { devopsTools, formatKubectlPodsOutput, formatHelmListOutput } from '../tools/schemas/devops';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -353,8 +353,8 @@ describe('Tool counts and metadata', () => {
     expect(standardTools).toHaveLength(12);
   });
 
-  test('devopsTools has exactly 9 tools', () => {
-    expect(devopsTools).toHaveLength(9);
+  test('devopsTools has exactly 28 tools', () => {
+    expect(devopsTools).toHaveLength(28);
   });
 
   test('all standard tools have category "standard"', () => {
@@ -395,3 +395,208 @@ describe('Tool counts and metadata', () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// C2: infraContext in ToolExecuteContext
+// ---------------------------------------------------------------------------
+
+describe('infraContext in ToolExecuteContext (C2)', () => {
+  it('ToolExecuteContext type has infraContext field', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/types.ts'), 'utf-8');
+    expect(src).toContain('infraContext?:');
+  });
+
+  it('kubectl tool uses contextFlag from infraContext', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).toContain('ctx?.infraContext?.kubectlContext');
+  });
+
+  it('terraform tool reads sessionWorkspace from infraContext', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).toContain('ctx?.infraContext?.terraformWorkspace');
+  });
+
+  it('generateInfraTool is in devopsTools array', async () => {
+    const { devopsTools } = await import('../tools/schemas/devops');
+    const names = devopsTools.map(t => t.name);
+    expect(names).toContain('generate_infra');
+  });
+
+  it('generateInfraTool has ask_once permissionTier', async () => {
+    const { devopsTools } = await import('../tools/schemas/devops');
+    const tool = devopsTools.find(t => t.name === 'generate_infra');
+    expect(tool?.permissionTier).toBe('ask_once');
+  });
+
+  it('generateInfraTool schema accepts terraform/kubernetes/helm types', async () => {
+    const { devopsTools } = await import('../tools/schemas/devops');
+    const tool = devopsTools.find(t => t.name === 'generate_infra');
+    expect(tool).toBeDefined();
+    // The schema should parse valid input without throwing
+    const { z } = await import('zod');
+    // Just verify the tool exists and has a schema
+    expect(tool?.inputSchema).toBeDefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// M2: Docker build streaming
+// ---------------------------------------------------------------------------
+
+describe('docker build streaming (M2)', () => {
+  it('dockerTool execute accepts ctx parameter', async () => {
+    const { readFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
+    expect(src).toContain("input.action === 'build' && ctx?.onProgress");
+  });
+
+  it('docker build output filter keeps Step N/M lines', () => {
+    // Inline the filter logic to unit test it
+    const filterDockerBuildLine = (line: string): boolean => {
+      const trimmed = line.trim();
+      if (!trimmed) return false;
+      return /^Step\s+\d+\/\d+/i.test(trimmed) ||
+        /---> Using cache/i.test(trimmed) ||
+        /Successfully built/i.test(trimmed) ||
+        /Successfully tagged/i.test(trimmed) ||
+        /error/i.test(trimmed) ||
+        /warning/i.test(trimmed);
+    };
+
+    expect(filterDockerBuildLine('Step 3/12: RUN npm install')).toBe(true);
+    expect(filterDockerBuildLine(' ---> Using cache')).toBe(true);
+    expect(filterDockerBuildLine('Successfully built abc123')).toBe(true);
+    expect(filterDockerBuildLine('Successfully tagged myapp:latest')).toBe(true);
+    expect(filterDockerBuildLine(' ---> sha256:abc123def456')).toBe(false);
+    expect(filterDockerBuildLine('Removing intermediate container abc123')).toBe(false);
+  });
+});
+
+// ===========================================================================
+// H6: kubectl pods output formatting
+// ===========================================================================
+
+describe('H6 — formatKubectlPodsOutput', () => {
+  const sampleOutput = [
+    'NAME                       READY   STATUS             RESTARTS   AGE',
+    'web-7d4f6b9c5-abc12        1/1     Running            0          2d',
+    'worker-6b5c8d7f4-xyz99     0/1     CrashLoopBackOff   5          1h',
+    'db-5f4e3d2c1-pqr55         0/1     Pending            0          30m',
+    'init-job-abc               0/1     Init:0/1           0          5m',
+    'old-pod-done               0/1     Completed          0          7d',
+    'failing-app-xyz            0/1     Error              3          2h',
+    'evicted-pod                0/1     Evicted            0          1d',
+  ].join('\n');
+
+  it('prefixes Running pods with [OK]', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    expect(result).toContain('[OK]');
+    const lines = result.split('\n');
+    const runningLine = lines.find(l => l.includes('Running'));
+    expect(runningLine).toMatch(/^\[OK\]/);
+  });
+
+  it('prefixes CrashLoopBackOff pods with [XX]', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    const lines = result.split('\n');
+    const crashLine = lines.find(l => l.includes('CrashLoopBackOff'));
+    expect(crashLine).toMatch(/^\[XX\]/);
+  });
+
+  it('prefixes Pending pods with [!!]', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    const lines = result.split('\n');
+    const pendingLine = lines.find(l => l.includes('Pending'));
+    expect(pendingLine).toMatch(/^\[!!\]/);
+  });
+
+  it('prefixes Error pods with [XX]', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    const lines = result.split('\n');
+    const errorLine = lines.find(l => l.includes('Error') && !l.includes('CrashLoop'));
+    expect(errorLine).toMatch(/^\[XX\]/);
+  });
+
+  it('prefixes Completed pods with [OK]', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    const lines = result.split('\n');
+    const completedLine = lines.find(l => l.includes('Completed'));
+    expect(completedLine).toMatch(/^\[OK\]/);
+  });
+
+  it('preserves header line without emoji prefix', () => {
+    const result = formatKubectlPodsOutput(sampleOutput);
+    const headerLine = result.split('\n')[0];
+    expect(headerLine).toBe('NAME                       READY   STATUS             RESTARTS   AGE');
+  });
+
+  it('returns original line for empty input', () => {
+    const result = formatKubectlPodsOutput('');
+    expect(result).toBe('');
+  });
+
+  it('handles single Running pod', () => {
+    const input = 'NAME   READY   STATUS    RESTARTS   AGE\nmypod  1/1     Running   0          1m';
+    const result = formatKubectlPodsOutput(input);
+    const lines = result.split('\n');
+    expect(lines[1]).toMatch(/^\[OK\]/);
+  });
+});
+
+// ===========================================================================
+// H6: helm list output formatting
+// ===========================================================================
+
+describe('H6 — formatHelmListOutput', () => {
+  const sampleJson = JSON.stringify([
+    { name: 'nginx', namespace: 'default', revision: '3', status: 'deployed', chart: 'nginx-1.2.0', app_version: '1.21', updated: '2024-01-01' },
+    { name: 'redis', namespace: 'cache', revision: '1', status: 'failed', chart: 'redis-7.0.0', app_version: '7.0', updated: '2024-01-02' },
+    { name: 'postgres', namespace: 'db', revision: '2', status: 'pending-upgrade', chart: 'postgresql-12.1.0', app_version: '15', updated: '2024-01-03' },
+  ]);
+
+  it('prefixes deployed releases with [OK]', () => {
+    const result = formatHelmListOutput(sampleJson);
+    expect(result).toContain('[OK]');
+    const lines = result.split('\n');
+    const deployedLine = lines.find(l => l.includes('deployed'));
+    expect(deployedLine).toMatch(/^\[OK\]/);
+  });
+
+  it('prefixes failed releases with [XX]', () => {
+    const result = formatHelmListOutput(sampleJson);
+    const lines = result.split('\n');
+    const failedLine = lines.find(l => l.includes('failed'));
+    expect(failedLine).toMatch(/^\[XX\]/);
+  });
+
+  it('prefixes pending releases with [!!]', () => {
+    const result = formatHelmListOutput(sampleJson);
+    const lines = result.split('\n');
+    const pendingLine = lines.find(l => l.includes('pending'));
+    expect(pendingLine).toMatch(/^\[!!\]/);
+  });
+
+  it('returns "No Helm releases found." for empty array', () => {
+    const result = formatHelmListOutput('[]');
+    expect(result).toBe('No Helm releases found.');
+  });
+
+  it('falls back to raw string for invalid JSON', () => {
+    const result = formatHelmListOutput('not json');
+    expect(result).toBe('not json');
+  });
+
+  it('includes release name and namespace in output', () => {
+    const result = formatHelmListOutput(sampleJson);
+    expect(result).toContain('nginx');
+    expect(result).toContain('default');
+  });
+});
+

package/src/__tests__/tools.test.ts

@@ -9,13 +9,14 @@
  * tests fast and hermetic.
  */
 
-import { describe, it, expect } from 'bun:test';
-import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
 import { FileSystemOperations } from '../tools/file-ops';
 import { GitOperations } from '../tools/git-ops';
 
 // The repository root is two levels above this test file: src/__tests__/ -> src/ -> repo-root
-const REPO_ROOT = join(import.meta.dir, '..', '..');
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 // ---------------------------------------------------------------------------
 // FileSystemOperations

package/src/__tests__/version-json.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Version Command Tests — L3
+ *
+ * Validates that `nimbus version --json` returns valid JSON with
+ * required fields: version, node, platform, arch.
+ *
+ * Also validates that `nimbus update` is an alias for `upgrade` in cli.ts.
+ */
+
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// ---------------------------------------------------------------------------
+// L3: version --json
+// ---------------------------------------------------------------------------
+
+describe('versionCommand --json (L3)', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let consoleSpy: any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let exitSpy: any;
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test('outputs valid JSON to stdout when json option is true', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    // process.exit(0) should have been called
+    expect(exitSpy).toHaveBeenCalledWith(0);
+
+    // console.log should have been called with JSON
+    expect(consoleSpy).toHaveBeenCalled();
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    expect(() => JSON.parse(jsonArg)).not.toThrow();
+  });
+
+  test('JSON output contains required fields: version, node, platform, arch', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(jsonArg);
+
+    expect(parsed).toHaveProperty('version');
+    expect(parsed).toHaveProperty('node');
+    expect(parsed).toHaveProperty('platform');
+    expect(parsed).toHaveProperty('arch');
+  });
+
+  test('JSON version field is a non-empty string', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(jsonArg);
+
+    expect(typeof parsed.version).toBe('string');
+    expect(parsed.version.length).toBeGreaterThan(0);
+  });
+
+  test('JSON node field matches process.version', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(jsonArg);
+
+    expect(parsed.node).toBe(process.version);
+  });
+
+  test('JSON platform field matches process.platform', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(jsonArg);
+
+    expect(parsed.platform).toBe(process.platform);
+  });
+
+  test('JSON arch field matches process.arch', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: true });
+
+    const jsonArg = consoleSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(jsonArg);
+
+    expect(parsed.arch).toBe(process.arch);
+  });
+
+  test('without --json flag, does not call process.exit(0)', async () => {
+    const { versionCommand } = await import('../commands/version');
+    await versionCommand({ json: false });
+
+    expect(exitSpy).not.toHaveBeenCalledWith(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L1: `nimbus update` alias for `upgrade`
+// ---------------------------------------------------------------------------
+
+describe('nimbus update alias (L1)', () => {
+  test('runCommand treats "update" the same as "upgrade"', async () => {
+    // Verify that both 'upgrade' and 'update' route to the upgrade handler
+    // by checking the COMMAND_ALIASES or the if-condition in cli.ts.
+    // We test this by importing runCommand and stubbing upgradeCommand.
+
+    const upgradeMod = await import('../commands/upgrade');
+    const upgradeSpy = vi.spyOn(upgradeMod, 'upgradeCommand').mockResolvedValue(undefined);
+
+    const { runCommand } = await import('../cli');
+    await runCommand(['update', '--check']);
+
+    expect(upgradeSpy).toHaveBeenCalledWith(expect.objectContaining({ check: true }));
+
+    upgradeSpy.mockRestore();
+  });
+
+  test('runCommand treats "upgrade" the same as "update"', async () => {
+    const upgradeMod = await import('../commands/upgrade');
+    const upgradeSpy = vi.spyOn(upgradeMod, 'upgradeCommand').mockResolvedValue(undefined);
+
+    const { runCommand } = await import('../cli');
+    await runCommand(['upgrade', '--check']);
+
+    expect(upgradeSpy).toHaveBeenCalledWith(expect.objectContaining({ check: true }));
+
+    upgradeSpy.mockRestore();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L2: --quiet flag for doctor
+// ---------------------------------------------------------------------------
+
+describe('doctorCommand --quiet (L2)', () => {
+  test('DoctorOptions interface accepts quiet field', async () => {
+    const { doctorCommand } = await import('../commands/doctor');
+    // Just verifying the function can be called with quiet option without type errors
+    expect(typeof doctorCommand).toBe('function');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L2: --quiet flag for logs
+// ---------------------------------------------------------------------------
+
+describe('parseLogsArgs --quiet (L2)', () => {
+  test('parses -q as quiet option', async () => {
+    const { parseLogsArgs } = await import('../commands/logs');
+    const { options } = parseLogsArgs(['my-pod', '-q']);
+    expect(options.quiet).toBe(true);
+  });
+
+  test('parses --quiet as quiet option', async () => {
+    const { parseLogsArgs } = await import('../commands/logs');
+    const { options } = parseLogsArgs(['my-pod', '--quiet']);
+    expect(options.quiet).toBe(true);
+  });
+
+  test('quiet is false when not provided', async () => {
+    const { parseLogsArgs } = await import('../commands/logs');
+    const { options } = parseLogsArgs(['my-pod']);
+    expect(options.quiet).toBeUndefined();
+  });
+
+  test('parses --quiet along with other flags', async () => {
+    const { parseLogsArgs } = await import('../commands/logs');
+    const { pod, options } = parseLogsArgs(['my-pod', '-n', 'default', '--quiet', '-f']);
+    expect(pod).toBe('my-pod');
+    expect(options.namespace).toBe('default');
+    expect(options.quiet).toBe(true);
+    expect(options.follow).toBe(true);
+  });
+});

package/src/__tests__/version.test.ts

@@ -5,7 +5,7 @@
  * non-empty BUILD_DATE string.
  */
 
-import { describe, it, expect } from 'bun:test';
+import { describe, it, expect } from 'vitest';
 import { VERSION, BUILD_DATE } from '../version';
 
 describe('version', () => {

package/src/__tests__/watch.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Watch Command Tests (M3)
+ *
+ * Tests the nimbus watch command which watches files and triggers agent runs.
+ * Validates glob matching, option parsing, and command export.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Import and verify exports
+// ---------------------------------------------------------------------------
+
+describe('watchCommand exports', () => {
+  it('watchCommand is exported from commands/watch.ts', async () => {
+    const { watchCommand } = await import('../commands/watch');
+    expect(typeof watchCommand).toBe('function');
+  });
+
+  it('WatchOptions interface supports required fields', () => {
+    // Type-level check via source inspection
+    const src = readFileSync(join(process.cwd(), 'src/commands/watch.ts'), 'utf-8');
+    expect(src).toContain('glob: string');
+    expect(src).toContain('run?:');
+    expect(src).toContain('debounce?:');
+    expect(src).toContain('autoApprove?:');
+    expect(src).toContain('maxRuns?:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Glob matching logic (inline reproduction)
+// ---------------------------------------------------------------------------
+
+function matchGlob(filename: string, pattern: string): boolean {
+  const f = filename.replace(/\\/g, '/');
+  const p = pattern.replace(/\\/g, '/');
+
+  const regexStr = p
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '__GLOBSTAR__')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]')
+    .replace(/__GLOBSTAR__/g, '.*');
+
+  const re = new RegExp(`^${regexStr}$`);
+  const { basename } = require('node:path');
+  const base = basename(f);
+  return re.test(f) || (!/\//.test(p) && re.test(base));
+}
+
+describe('matchGlob (M3 — watch command glob matching)', () => {
+  it('matches *.tf against main.tf', () => {
+    expect(matchGlob('main.tf', '*.tf')).toBe(true);
+  });
+
+  it('matches *.tf against variables.tf', () => {
+    expect(matchGlob('variables.tf', '*.tf')).toBe(true);
+  });
+
+  it('does not match *.tf against main.ts', () => {
+    expect(matchGlob('main.ts', '*.tf')).toBe(false);
+  });
+
+  it('matches *.yaml against deploy.yaml', () => {
+    expect(matchGlob('deploy.yaml', '*.yaml')).toBe(true);
+  });
+
+  it('matches *.yaml against deploy.yml', () => {
+    expect(matchGlob('deploy.yml', '*.yaml')).toBe(false);
+  });
+
+  it('matches *.yml against deploy.yml', () => {
+    expect(matchGlob('deploy.yml', '*.yml')).toBe(true);
+  });
+
+  it('matches src/** against src/index.ts', () => {
+    expect(matchGlob('src/index.ts', 'src/**')).toBe(true);
+  });
+
+  it('matches src/** against src/utils/helper.ts', () => {
+    expect(matchGlob('src/utils/helper.ts', 'src/**')).toBe(true);
+  });
+
+  it('does not match src/** against lib/index.ts', () => {
+    expect(matchGlob('lib/index.ts', 'src/**')).toBe(false);
+  });
+
+  it('matches Dockerfile exactly', () => {
+    expect(matchGlob('Dockerfile', 'Dockerfile')).toBe(true);
+  });
+
+  it('matches nested *.tf in subdir', () => {
+    expect(matchGlob('modules/vpc/main.tf', '*.tf')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CLI wiring — watch is registered in cli.ts
+// ---------------------------------------------------------------------------
+
+describe('watch command wired in CLI (M3)', () => {
+  it('cli.ts contains nimbus watch handler', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("command === 'watch'");
+  });
+
+  it('cli.ts imports watchCommand from commands/watch', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("import('./commands/watch')");
+  });
+
+  it('cli.ts parses --run flag for watch', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("watchOptions.run = args[++i]");
+  });
+
+  it('cli.ts parses --debounce flag for watch', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("watchOptions.debounce");
+  });
+
+  it('cli.ts parses --auto-approve flag for watch', () => {
+    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
+    expect(src).toContain("watchOptions.autoApprove = true");
+  });
+});

package/src/agent/compaction-agent.ts

@@ -33,6 +33,15 @@ export interface CompactionOptions {
   focusArea?: string;
   /** Model to use for compaction (default: haiku). */
   model?: string;
+  /** H3: Infrastructure context to preserve during compaction. */
+  infraContext?: {
+    terraformWorkspace?: string;
+    kubectlContext?: string;
+    awsProfile?: string;
+    awsRegion?: string;
+    gcpProject?: string;
+    azureSubscription?: string;
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -107,6 +116,21 @@ export async function runCompaction(
     userPrompt += `\n\nPay special attention to: ${options.focusArea}`;
   }
 
+  // H3: Inject current infraContext into compaction prompt so it's never omitted
+  if (options.infraContext) {
+    const ic = options.infraContext;
+    const infraLines: string[] = [];
+    if (ic.terraformWorkspace) infraLines.push(`- Terraform workspace: ${ic.terraformWorkspace}`);
+    if (ic.kubectlContext) infraLines.push(`- kubectl context: ${ic.kubectlContext}`);
+    if (ic.awsProfile) infraLines.push(`- AWS profile: ${ic.awsProfile}`);
+    if (ic.awsRegion) infraLines.push(`- AWS region: ${ic.awsRegion}`);
+    if (ic.gcpProject) infraLines.push(`- GCP project: ${ic.gcpProject}`);
+    if (ic.azureSubscription) infraLines.push(`- Azure subscription: ${ic.azureSubscription}`);
+    if (infraLines.length > 0) {
+      userPrompt += `\n\n## ALWAYS PRESERVE IN SUMMARY (do not omit):\n${infraLines.join('\n')}`;
+    }
+  }
+
   // Call the LLM for summarization using a fast, cheap model
   const model = options.model ?? 'haiku';
   let summary: string;
@@ -126,8 +150,23 @@ export async function runCompaction(
     summary = fallbackSummary(toSummarize);
   }
 
+  // H3: Prepend infraContext block to summary so it survives compaction
+  let finalSummary = summary;
+  if (options.infraContext) {
+    const ic = options.infraContext;
+    const infraLines: string[] = [];
+    if (ic.terraformWorkspace) infraLines.push(`- Terraform workspace: ${ic.terraformWorkspace}`);
+    if (ic.kubectlContext) infraLines.push(`- kubectl context: ${ic.kubectlContext}`);
+    if (ic.awsProfile) infraLines.push(`- AWS profile: ${ic.awsProfile}`);
+    if (ic.awsRegion) infraLines.push(`- AWS region: ${ic.awsRegion}`);
+    if (ic.gcpProject) infraLines.push(`- GCP project: ${ic.gcpProject}`);
+    if (ic.azureSubscription) infraLines.push(`- Azure subscription: ${ic.azureSubscription}`);
+    if (infraLines.length > 0) {
+      finalSummary = `## Infrastructure Context\n${infraLines.join('\n')}\n\n${summary}`;
+    }
+  }
   // Reassemble the compacted message array
-  const compactedMessages = contextManager.buildCompactedMessages(preserved, summary);
+  const compactedMessages = contextManager.buildCompactedMessages(preserved, finalSummary);
   const compactedTokens = compactedMessages.reduce(
     (sum, m) => sum + estimateTokens(getTextContent(m.content)),
     0