@integsec/agentic-pentest-proxy 0.3.4 → 0.3.6

package/docs/superpowers/plans/2026-03-29-manifest-builder.md

@@ -0,0 +1,3429 @@
+# Scope Manifest Builder Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build a CLI wizard and optional web companion for building, editing, reviewing, and sharing MCP scope manifests with smart validation and dry-run previews.
+
+**Architecture:** Three layers — shared validation core (smart-validator, dry-run engine, manifest writer), Ink-based CLI wizard with 8 steps, and a Node http/https web server for client intake. The CLI is primary; the web server is on-demand via `serve` subcommand.
+
+**Tech Stack:** TypeScript (ES2022, Node16 modules), React + Ink for TUI, Zod for validation, Node built-in http/https for web server, Vitest for tests. No new dependencies.
+
+---
+
+## File Structure
+
+```
+src/
+  builder/
+    smart-validator.ts        ← Tier 1-2 validation (shared core)
+    dry-run.ts                ← Tier 3 dry-run engine (shared core)
+    manifest-writer.ts        ← Serialize + write manifest to disk
+    wizard.tsx                ← Ink wizard (main flow, step management)
+    steps/
+      engagement-info.tsx     ← Step 1: ID, client, operator
+      engagement-window.tsx   ← Step 2: start/end dates
+      domains.tsx             ← Step 3: domain entry + live DNS
+      ip-ranges.tsx           ← Step 4: CIDR entry + warnings
+      urls-and-cloud.tsx      ← Step 5: URLs, cloud accounts
+      exclusions.tsx          ← Step 6: excluded targets
+      techniques.tsx          ← Step 7: technique multi-select
+      review.tsx              ← Step 8: summary + dry-run table
+    web/
+      server.ts               ← Node http/https server + TLS enforcement
+      api.ts                  ← GET /template, POST /submit handlers
+      client-form.html        ← Single-file client intake form
+
+bin/
+  integsec-agentic-pentest-manifest.ts  ← CLI entry point (new/edit/review/serve)
+
+tests/
+  unit/
+    builder/
+      smart-validator.test.ts
+      dry-run.test.ts
+      manifest-writer.test.ts
+    builder-web/
+      server.test.ts
+      api.test.ts
+```
+
+---
+
+## Phase 1: Shared Core + CLI Wizard (`new` mode)
+
+### Task 1: Smart Validator — Tier 1 Format Validation
+
+**Files:**
+- Create: `src/builder/smart-validator.ts`
+- Test: `tests/unit/builder/smart-validator.test.ts`
+
+- [ ] **Step 1: Write failing tests for Tier 1 format validation**
+
+```typescript
+// tests/unit/builder/smart-validator.test.ts
+import { describe, it, expect } from "vitest";
+import {
+  validateEngagementId,
+  validateCidr,
+  validateDomain,
+  validateIsoDate,
+  validateWindowSanity,
+  type ValidationMessage,
+} from "../../src/builder/smart-validator.js";
+
+describe("SmartValidator — Tier 1: Format Validation", () => {
+  describe("validateEngagementId", () => {
+    it("accepts a valid engagement ID", () => {
+      const msgs = validateEngagementId("ENG-2026-0142");
+      expect(msgs).toEqual([]);
+    });
+
+    it("rejects empty string", () => {
+      const msgs = validateEngagementId("");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+
+    it("suggests format when ID does not match ENG-YYYY-NNNN", () => {
+      const msgs = validateEngagementId("my-test");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("info");
+      expect(msgs[0].message).toContain("ENG-YYYY-");
+    });
+  });
+
+  describe("validateCidr", () => {
+    it("accepts a valid CIDR", () => {
+      const msgs = validateCidr("10.10.10.0/24");
+      expect(msgs).toEqual([]);
+    });
+
+    it("rejects invalid CIDR syntax", () => {
+      const msgs = validateCidr("not-a-cidr");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+
+    it("warns on broad range wider than /16", () => {
+      const msgs = validateCidr("10.0.0.0/8");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("warning");
+      expect(msgs[0].message).toContain("16,777,216");
+    });
+
+    it("accepts /16 without warning", () => {
+      const msgs = validateCidr("10.10.0.0/16");
+      expect(msgs).toEqual([]);
+    });
+
+    it("accepts bare IP as /32", () => {
+      const msgs = validateCidr("10.10.10.5");
+      expect(msgs).toEqual([]);
+    });
+  });
+
+  describe("validateDomain", () => {
+    it("accepts a valid domain", () => {
+      const msgs = validateDomain("app.acme.com");
+      expect(msgs).toEqual([]);
+    });
+
+    it("accepts a wildcard domain", () => {
+      const msgs = validateDomain("*.acme.com");
+      expect(msgs).toEqual([]);
+    });
+
+    it("rejects domain with spaces", () => {
+      const msgs = validateDomain("app .acme.com");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+
+    it("rejects empty string", () => {
+      const msgs = validateDomain("");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+  });
+
+  describe("validateIsoDate", () => {
+    it("accepts valid ISO 8601 datetime", () => {
+      const msgs = validateIsoDate("2026-03-29T08:00:00Z");
+      expect(msgs).toEqual([]);
+    });
+
+    it("accepts date-only string", () => {
+      const msgs = validateIsoDate("2026-03-29");
+      expect(msgs).toEqual([]);
+    });
+
+    it("rejects invalid date", () => {
+      const msgs = validateIsoDate("not-a-date");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+
+    it("rejects empty string", () => {
+      const msgs = validateIsoDate("");
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("error");
+    });
+  });
+
+  describe("validateWindowSanity", () => {
+    it("returns no messages for a normal window", () => {
+      const start = new Date(Date.now() + 3600_000).toISOString();
+      const end = new Date(Date.now() + 7 * 86400_000).toISOString();
+      const msgs = validateWindowSanity(start, end);
+      expect(msgs).toEqual([]);
+    });
+
+    it("warns if start is in the past", () => {
+      const start = "2020-01-01T00:00:00Z";
+      const end = new Date(Date.now() + 86400_000).toISOString();
+      const msgs = validateWindowSanity(start, end);
+      expect(msgs.some((m) => m.level === "warning" && m.message.includes("past"))).toBe(true);
+    });
+
+    it("warns if window exceeds 30 days", () => {
+      const start = new Date(Date.now() + 3600_000).toISOString();
+      const end = new Date(Date.now() + 60 * 86400_000).toISOString();
+      const msgs = validateWindowSanity(start, end);
+      expect(msgs.some((m) => m.level === "warning" && m.message.includes("30 days"))).toBe(true);
+    });
+
+    it("warns if window is less than 1 hour", () => {
+      const start = new Date(Date.now() + 3600_000).toISOString();
+      const end = new Date(Date.now() + 3600_000 + 1800_000).toISOString();
+      const msgs = validateWindowSanity(start, end);
+      expect(msgs.some((m) => m.level === "warning" && m.message.includes("1 hour"))).toBe(true);
+    });
+
+    it("errors if end is before start", () => {
+      const start = new Date(Date.now() + 86400_000).toISOString();
+      const end = new Date(Date.now() - 86400_000).toISOString();
+      const msgs = validateWindowSanity(start, end);
+      expect(msgs.some((m) => m.level === "error" && m.message.includes("before"))).toBe(true);
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npx vitest run tests/unit/builder/smart-validator.test.ts`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: Implement Tier 1 format validation**
+
+```typescript
+// src/builder/smart-validator.ts
+
+import IPCIDR from "ip-cidr";
+
+export interface ValidationMessage {
+  level: "error" | "warning" | "info";
+  message: string;
+}
+
+/**
+ * Validate an engagement ID string.
+ * Accepts any non-empty string; suggests ENG-YYYY-NNNN format if it doesn't match.
+ */
+export function validateEngagementId(id: string): ValidationMessage[] {
+  if (!id || id.trim() === "") {
+    return [{ level: "error", message: "Engagement ID must not be empty." }];
+  }
+  if (!/^ENG-\d{4}-\d{3,}$/.test(id)) {
+    return [{ level: "info", message: `Suggested format: ENG-YYYY-NNNN (e.g. ENG-${new Date().getFullYear()}-0001).` }];
+  }
+  return [];
+}
+
+/**
+ * Validate a CIDR range string.
+ * Accepts bare IPs (treated as /32 or /128). Warns on ranges broader than /16.
+ */
+export function validateCidr(cidr: string): ValidationMessage[] {
+  if (!cidr || cidr.trim() === "") {
+    return [{ level: "error", message: "CIDR range must not be empty." }];
+  }
+
+  // Normalise bare IPs to CIDR notation for validation
+  let normalized = cidr;
+  if (!cidr.includes("/")) {
+    normalized = cidr.includes(":") ? `${cidr}/128` : `${cidr}/32`;
+  }
+
+  if (!IPCIDR.isValidCIDR(normalized)) {
+    return [{ level: "error", message: `Invalid CIDR syntax: "${cidr}". Example: 10.10.10.0/24` }];
+  }
+
+  // Warn on broad ranges (IPv4 only — /16 or wider)
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex !== -1 && !normalized.includes(":")) {
+    const prefix = parseInt(normalized.slice(slashIndex + 1), 10);
+    if (prefix < 16) {
+      const count = Math.pow(2, 32 - prefix);
+      return [{ level: "warning", message: `This range covers ${count.toLocaleString()} addresses. Is /${prefix} intentional?` }];
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Validate a domain string.
+ * Accepts exact domains and wildcard domains (*.example.com).
+ */
+export function validateDomain(domain: string): ValidationMessage[] {
+  if (!domain || domain.trim() === "") {
+    return [{ level: "error", message: "Domain must not be empty." }];
+  }
+  if (/\s/.test(domain)) {
+    return [{ level: "error", message: `Domain "${domain}" contains whitespace.` }];
+  }
+  // Basic DNS label check: labels separated by dots, optional leading *.
+  const pattern = /^(\*\.)?([a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.)*[a-zA-Z]{2,}\.?$/;
+  if (!pattern.test(domain)) {
+    return [{ level: "error", message: `"${domain}" does not look like a valid domain.` }];
+  }
+  return [];
+}
+
+/**
+ * Validate an ISO 8601 date string.
+ */
+export function validateIsoDate(date: string): ValidationMessage[] {
+  if (!date || date.trim() === "") {
+    return [{ level: "error", message: "Date must not be empty." }];
+  }
+  if (isNaN(Date.parse(date))) {
+    return [{ level: "error", message: `"${date}" is not a valid ISO 8601 date. Example: 2026-03-29T08:00:00Z` }];
+  }
+  return [];
+}
+
+/**
+ * Validate the engagement window for sanity (start/end relationship, duration).
+ * Assumes both dates have already passed format validation.
+ */
+export function validateWindowSanity(start: string, end: string): ValidationMessage[] {
+  const msgs: ValidationMessage[] = [];
+  const startMs = Date.parse(start);
+  const endMs = Date.parse(end);
+
+  if (isNaN(startMs) || isNaN(endMs)) {
+    return []; // Format validation handles this
+  }
+
+  if (endMs <= startMs) {
+    msgs.push({ level: "error", message: "End date is before or equal to start date." });
+    return msgs; // No point checking duration
+  }
+
+  if (startMs < Date.now()) {
+    msgs.push({ level: "warning", message: "Start date is in the past." });
+  }
+
+  const durationMs = endMs - startMs;
+  const thirtyDaysMs = 30 * 24 * 3600_000;
+  const oneHourMs = 3600_000;
+
+  if (durationMs > thirtyDaysMs) {
+    msgs.push({ level: "warning", message: `Engagement window exceeds 30 days (${Math.round(durationMs / 86400_000)} days).` });
+  }
+
+  if (durationMs < oneHourMs) {
+    msgs.push({ level: "warning", message: "Engagement window is less than 1 hour." });
+  }
+
+  return msgs;
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder/smart-validator.test.ts`
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/builder/smart-validator.ts tests/unit/builder/smart-validator.test.ts
+git commit -m "feat(builder): add Tier 1 format validation for smart-validator"
+```
+
+---
+
+### Task 2: Smart Validator — Tier 2 Async Validation
+
+**Files:**
+- Modify: `src/builder/smart-validator.ts`
+- Modify: `tests/unit/builder/smart-validator.test.ts`
+
+- [ ] **Step 1: Write failing tests for Tier 2 async validation**
+
+Add to `tests/unit/builder/smart-validator.test.ts`:
+
+```typescript
+import {
+  validateEngagementId,
+  validateCidr,
+  validateDomain,
+  validateIsoDate,
+  validateWindowSanity,
+  resolveDomainPreview,
+  checkOverlap,
+  checkWildcardApex,
+  checkOrphanedExclusion,
+  type ValidationMessage,
+} from "../../src/builder/smart-validator.js";
+import { DnsResolver } from "../../src/dns-resolver.js";
+import { vi } from "vitest";
+
+// ... existing tests ...
+
+describe("SmartValidator — Tier 2: Async Validation", () => {
+  function mockResolver(resolveImpl: (target: string) => Promise<string[]>): DnsResolver {
+    const resolver = new DnsResolver();
+    resolver.resolve = vi.fn(resolveImpl);
+    return resolver;
+  }
+
+  describe("resolveDomainPreview", () => {
+    it("returns resolved IPs for a domain", async () => {
+      const resolver = mockResolver(async () => ["10.10.10.1", "10.10.10.2"]);
+      const result = await resolveDomainPreview("app.acme.com", resolver);
+      expect(result.ips).toEqual(["10.10.10.1", "10.10.10.2"]);
+      expect(result.messages).toEqual([]);
+    });
+
+    it("returns warning when DNS resolution fails", async () => {
+      const resolver = mockResolver(async () => []);
+      const result = await resolveDomainPreview("nonexistent.example.com", resolver);
+      expect(result.ips).toEqual([]);
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].level).toBe("warning");
+    });
+  });
+
+  describe("checkOverlap", () => {
+    it("returns info when domain resolves to IP already in an authorized range", () => {
+      const msgs = checkOverlap(["10.10.10.5"], ["10.10.10.0/24"]);
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("info");
+      expect(msgs[0].message).toContain("already covered");
+    });
+
+    it("returns no message when IPs are not in any authorized range", () => {
+      const msgs = checkOverlap(["8.8.8.8"], ["10.10.10.0/24"]);
+      expect(msgs).toEqual([]);
+    });
+  });
+
+  describe("checkWildcardApex", () => {
+    it("returns info suggesting apex when wildcard is added", () => {
+      const msgs = checkWildcardApex("*.acme.com", ["*.acme.com"]);
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("info");
+      expect(msgs[0].message).toContain("acme.com");
+    });
+
+    it("returns no message when apex is already in the list", () => {
+      const msgs = checkWildcardApex("*.acme.com", ["*.acme.com", "acme.com"]);
+      expect(msgs).toEqual([]);
+    });
+
+    it("returns no message for non-wildcard domain", () => {
+      const msgs = checkWildcardApex("app.acme.com", ["app.acme.com"]);
+      expect(msgs).toEqual([]);
+    });
+  });
+
+  describe("checkOrphanedExclusion", () => {
+    it("warns when excluded target is not in any authorized range or domain", () => {
+      const msgs = checkOrphanedExclusion(
+        "8.8.8.8",
+        { ip_ranges: ["10.10.10.0/24"], domains: ["*.acme.com"] }
+      );
+      expect(msgs).toHaveLength(1);
+      expect(msgs[0].level).toBe("warning");
+      expect(msgs[0].message).toContain("redundant");
+    });
+
+    it("returns no message when excluded IP is in an authorized range", () => {
+      const msgs = checkOrphanedExclusion(
+        "10.10.10.5",
+        { ip_ranges: ["10.10.10.0/24"], domains: [] }
+      );
+      expect(msgs).toEqual([]);
+    });
+
+    it("returns no message when excluded domain matches an authorized pattern", () => {
+      const msgs = checkOrphanedExclusion(
+        "hr.acme.com",
+        { ip_ranges: [], domains: ["*.acme.com"] }
+      );
+      expect(msgs).toEqual([]);
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify Tier 2 tests fail**
+
+Run: `npx vitest run tests/unit/builder/smart-validator.test.ts`
+Expected: FAIL — new functions not exported
+
+- [ ] **Step 3: Implement Tier 2 async validation**
+
+Add to `src/builder/smart-validator.ts`:
+
+```typescript
+import { DnsResolver } from "../dns-resolver.js";
+import { isIpInCidr } from "../ip-matcher.js";
+import { matchesDomain } from "../domain-matcher.js";
+
+// Add to existing imports at top of file
+
+export interface DomainPreviewResult {
+  ips: string[];
+  messages: ValidationMessage[];
+}
+
+/**
+ * Resolve a domain and return its IPs with any warnings.
+ */
+export async function resolveDomainPreview(
+  domain: string,
+  resolver: DnsResolver
+): Promise<DomainPreviewResult> {
+  // Strip wildcard prefix for resolution
+  const lookupDomain = domain.startsWith("*.") ? domain.slice(2) : domain;
+  const ips = await resolver.resolve(lookupDomain);
+
+  if (ips.length === 0) {
+    return {
+      ips: [],
+      messages: [{ level: "warning", message: `DNS resolution for "${lookupDomain}" returned no addresses.` }],
+    };
+  }
+
+  return { ips, messages: [] };
+}
+
+/**
+ * Check if resolved IPs are already covered by authorized CIDR ranges.
+ */
+export function checkOverlap(
+  resolvedIps: string[],
+  authorizedRanges: string[]
+): ValidationMessage[] {
+  for (const ip of resolvedIps) {
+    for (const range of authorizedRanges) {
+      if (isIpInCidr(ip, range)) {
+        return [{ level: "info", message: `Resolved IP ${ip} is already covered by authorized range ${range}.` }];
+      }
+    }
+  }
+  return [];
+}
+
+/**
+ * If a wildcard domain is being added, check whether the apex is also included.
+ */
+export function checkWildcardApex(
+  domain: string,
+  currentDomains: string[]
+): ValidationMessage[] {
+  if (!domain.startsWith("*.")) return [];
+
+  const apex = domain.slice(2);
+  const hasApex = currentDomains.some(
+    (d) => d.toLowerCase() === apex.toLowerCase()
+  );
+
+  if (!hasApex) {
+    return [{
+      level: "info",
+      message: `Wildcard "${domain}" does not cover the apex "${apex}". Add "${apex}" separately if needed.`,
+    }];
+  }
+
+  return [];
+}
+
+/**
+ * Check if an excluded target actually falls within any authorized range or domain.
+ * If not, the exclusion is redundant.
+ */
+export function checkOrphanedExclusion(
+  excludedTarget: string,
+  authorized: { ip_ranges: string[]; domains: string[] }
+): ValidationMessage[] {
+  // Check if it matches an authorized IP range
+  for (const range of authorized.ip_ranges) {
+    if (isIpInCidr(excludedTarget, range)) {
+      return [];
+    }
+  }
+
+  // Check if it matches an authorized domain pattern
+  for (const pattern of authorized.domains) {
+    if (matchesDomain(excludedTarget, pattern)) {
+      return [];
+    }
+  }
+
+  return [{
+    level: "warning",
+    message: `Excluded target "${excludedTarget}" does not fall within any authorized range or domain — this exclusion is redundant.`,
+  }];
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder/smart-validator.test.ts`
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/builder/smart-validator.ts tests/unit/builder/smart-validator.test.ts
+git commit -m "feat(builder): add Tier 2 async validation (DNS preview, overlap, wildcard, orphan)"
+```
+
+---
+
+### Task 3: Dry-Run Engine
+
+**Files:**
+- Create: `src/builder/dry-run.ts`
+- Test: `tests/unit/builder/dry-run.test.ts`
+
+- [ ] **Step 1: Write failing tests for dry-run engine**
+
+```typescript
+// tests/unit/builder/dry-run.test.ts
+import { describe, it, expect, vi } from "vitest";
+import { runDryRun, type DryRunResult } from "../../src/builder/dry-run.js";
+import type { ScopeManifest } from "../../src/types.js";
+import { DnsResolver } from "../../src/dns-resolver.js";
+
+const testManifest: ScopeManifest = {
+  engagement_id: "ENG-2026-0001",
+  client: "Test Corp",
+  operator: "test@test.com",
+  authorized_targets: {
+    ip_ranges: ["10.10.10.0/24"],
+    domains: ["*.acme.com"],
+    urls: [],
+    cloud_accounts: [],
+  },
+  excluded_targets: ["hr.acme.com"],
+  authorized_techniques: ["recon", "web_app"],
+  excluded_techniques: ["dos", "destructive"],
+  engagement_window: {
+    start: "2020-01-01T00:00:00Z",
+    end: "2099-12-31T23:59:59Z",
+  },
+};
+
+function mockResolver(): DnsResolver {
+  const resolver = new DnsResolver();
+  resolver.resolve = vi.fn(async (target: string) => {
+    const map: Record<string, string[]> = {
+      "app.acme.com": ["10.10.10.1"],
+      "hr.acme.com": ["10.10.10.2"],
+      "acme.com": ["10.10.10.3"],
+    };
+    if (target in map) return map[target];
+    // Bare IPs pass through
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(target)) return [target];
+    return [];
+  });
+  return resolver;
+}
+
+describe("DryRunEngine", () => {
+  it("returns ALLOWED for authorized domain", async () => {
+    const results = await runDryRun(testManifest, mockResolver());
+    const appResult = results.find((r) => r.target === "app.acme.com");
+    expect(appResult).toBeDefined();
+    expect(appResult!.actual).toBe("ALLOWED");
+    expect(appResult!.pass).toBe(true);
+  });
+
+  it("returns BLOCKED for excluded domain", async () => {
+    const results = await runDryRun(testManifest, mockResolver());
+    const hrResult = results.find((r) => r.target === "hr.acme.com");
+    expect(hrResult).toBeDefined();
+    expect(hrResult!.actual).toContain("BLOCKED");
+    expect(hrResult!.pass).toBe(true); // Expected to be blocked
+  });
+
+  it("returns BLOCKED for out-of-scope target", async () => {
+    const results = await runDryRun(testManifest, mockResolver());
+    const oosResult = results.find((r) => r.target === "8.8.8.8");
+    expect(oosResult).toBeDefined();
+    expect(oosResult!.actual).toContain("BLOCKED");
+    expect(oosResult!.pass).toBe(true);
+  });
+
+  it("returns BLOCKED for cloud metadata IP", async () => {
+    const results = await runDryRun(testManifest, mockResolver());
+    const metaResult = results.find((r) => r.target === "169.254.169.254");
+    expect(metaResult).toBeDefined();
+    expect(metaResult!.actual).toContain("BLOCKED");
+    expect(metaResult!.pass).toBe(true);
+  });
+
+  it("returns ALLOWED for IP in authorized range", async () => {
+    const results = await runDryRun(testManifest, mockResolver());
+    const ipResult = results.find((r) => r.target === "10.10.10.50");
+    expect(ipResult).toBeDefined();
+    expect(ipResult!.actual).toBe("ALLOWED");
+    expect(ipResult!.pass).toBe(true);
+  });
+
+  it("flags surprises when actual differs from expected", async () => {
+    // Manifest with no authorized targets — everything should be blocked
+    const emptyManifest: ScopeManifest = {
+      ...testManifest,
+      authorized_targets: { ip_ranges: [], domains: [], urls: [], cloud_accounts: [] },
+      excluded_targets: [],
+    };
+    const resolver = mockResolver();
+    const results = await runDryRun(emptyManifest, resolver);
+    // All domain/IP tests should fail (expected ALLOWED but got BLOCKED)
+    const surprises = results.filter((r) => !r.pass);
+    expect(surprises.length).toBeGreaterThan(0);
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npx vitest run tests/unit/builder/dry-run.test.ts`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: Implement dry-run engine**
+
+```typescript
+// src/builder/dry-run.ts
+
+import type { ScopeManifest, Decision } from "../types.js";
+import { ScopeValidator } from "../validator.js";
+import { DnsResolver } from "../dns-resolver.js";
+import { isIpInCidr } from "../ip-matcher.js";
+
+export interface DryRunResult {
+  target: string;
+  tool: string;
+  expected: "ALLOWED" | "BLOCKED";
+  actual: Decision;
+  pass: boolean;
+  reason: string;
+}
+
+/**
+ * Run a battery of synthetic tool calls against a manifest to preview
+ * what the proxy would allow and block.
+ */
+export async function runDryRun(
+  manifest: ScopeManifest,
+  resolver?: DnsResolver
+): Promise<DryRunResult[]> {
+  const dnsResolver = resolver ?? new DnsResolver(0); // TTL 0 = no caching for fresh results
+  const validator = new ScopeValidator(manifest, dnsResolver);
+  const results: DryRunResult[] = [];
+
+  // Test each authorized domain — should be ALLOWED
+  for (const domain of manifest.authorized_targets.domains) {
+    // Skip wildcards; generate a sample subdomain instead
+    const testDomain = domain.startsWith("*.")
+      ? `test-sample.${domain.slice(2)}`
+      : domain;
+
+    const result = await validator.validate("nmap", { target: testDomain });
+    results.push({
+      target: testDomain,
+      tool: "nmap",
+      expected: "ALLOWED",
+      actual: result.decision,
+      pass: result.decision === "ALLOWED",
+      reason: result.reason,
+    });
+  }
+
+  // Test a sample IP from each authorized range — should be ALLOWED
+  for (const range of manifest.authorized_targets.ip_ranges) {
+    const sampleIp = sampleIpFromCidr(range);
+    if (!sampleIp) continue;
+
+    const result = await validator.validate("nmap", { target: sampleIp });
+    results.push({
+      target: sampleIp,
+      tool: "nmap",
+      expected: "ALLOWED",
+      actual: result.decision,
+      pass: result.decision === "ALLOWED",
+      reason: result.reason,
+    });
+  }
+
+  // Test each excluded target — should be BLOCKED
+  for (const excluded of manifest.excluded_targets) {
+    const result = await validator.validate("nmap", { target: excluded });
+    results.push({
+      target: excluded,
+      tool: "nmap",
+      expected: "BLOCKED",
+      actual: result.decision,
+      pass: result.decision.startsWith("BLOCKED"),
+      reason: result.reason,
+    });
+  }
+
+  // Test sensitive targets — should be BLOCKED (unless explicitly authorized)
+  const sensitiveTargets = ["169.254.169.254", "8.8.8.8"];
+  for (const target of sensitiveTargets) {
+    const result = await validator.validate("curl", { url: `http://${target}/` });
+    // These are expected to be blocked unless the manifest explicitly authorizes them
+    const isAuthorized = manifest.authorized_targets.ip_ranges.some((range) =>
+      isIpInCidr(target, range)
+    );
+
+    results.push({
+      target,
+      tool: "curl",
+      expected: isAuthorized ? "ALLOWED" : "BLOCKED",
+      actual: result.decision,
+      pass: isAuthorized
+        ? result.decision === "ALLOWED"
+        : result.decision.startsWith("BLOCKED"),
+      reason: result.reason,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Extract a sample IP from a CIDR range for testing.
+ * For /32, returns the IP itself. For wider ranges, picks .50 in the last octet
+ * (or the first usable address for very small ranges).
+ */
+function sampleIpFromCidr(cidr: string): string | null {
+  // Handle bare IPs
+  if (!cidr.includes("/")) return cidr;
+
+  const [base, prefix] = cidr.split("/");
+  const prefixNum = parseInt(prefix, 10);
+
+  // For /32 or /128, just return the base IP
+  if (prefixNum >= 32 || (base.includes(":") && prefixNum >= 128)) {
+    return base;
+  }
+
+  // For IPv4, generate a sample by modifying the last octet
+  if (!base.includes(":")) {
+    const parts = base.split(".");
+    const lastOctet = parseInt(parts[3], 10);
+    // Pick an offset that stays in range
+    const offset = Math.min(50, Math.pow(2, 32 - prefixNum) - 2);
+    parts[3] = String(lastOctet + offset);
+    return parts.join(".");
+  }
+
+  // For IPv6, just return the base (good enough for dry-run)
+  return base;
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder/dry-run.test.ts`
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/builder/dry-run.ts tests/unit/builder/dry-run.test.ts
+git commit -m "feat(builder): add dry-run engine for scope manifest preview"
+```
+
+---
+
+### Task 4: Manifest Writer
+
+**Files:**
+- Create: `src/builder/manifest-writer.ts`
+- Test: `tests/unit/builder/manifest-writer.test.ts`
+
+- [ ] **Step 1: Write failing tests for manifest writer**
+
+```typescript
+// tests/unit/builder/manifest-writer.test.ts
+import { describe, it, expect, vi, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import {
+  writeManifest,
+  serializeManifest,
+} from "../../src/builder/manifest-writer.js";
+import type { ScopeManifest } from "../../src/types.js";
+
+const testManifest: ScopeManifest = {
+  engagement_id: "ENG-2026-0001",
+  client: "Test Corp",
+  operator: "test@test.com",
+  authorized_targets: {
+    ip_ranges: ["10.10.10.0/24"],
+    domains: ["*.acme.com"],
+    urls: [],
+    cloud_accounts: [],
+  },
+  excluded_targets: [],
+  authorized_techniques: ["recon"],
+  excluded_techniques: ["dos"],
+  engagement_window: {
+    start: "2026-01-01T00:00:00Z",
+    end: "2026-02-01T00:00:00Z",
+  },
+};
+
+describe("ManifestWriter", () => {
+  describe("serializeManifest", () => {
+    it("returns pretty-printed JSON", () => {
+      const json = serializeManifest(testManifest);
+      expect(JSON.parse(json)).toEqual(testManifest);
+      expect(json).toContain("\n"); // Pretty-printed
+    });
+
+    it("output is valid JSON that round-trips", () => {
+      const json = serializeManifest(testManifest);
+      const parsed = JSON.parse(json);
+      expect(parsed.engagement_id).toBe("ENG-2026-0001");
+      expect(parsed.authorized_targets.domains).toEqual(["*.acme.com"]);
+    });
+  });
+
+  describe("writeManifest", () => {
+    const testDir = path.join(process.cwd(), "test-output-manifest-writer");
+    const testPath = path.join(testDir, "test-scope.json");
+
+    afterEach(() => {
+      if (fs.existsSync(testDir)) {
+        fs.rmSync(testDir, { recursive: true });
+      }
+    });
+
+    it("writes manifest to the specified path", () => {
+      writeManifest(testManifest, testPath);
+      const content = fs.readFileSync(testPath, "utf-8");
+      expect(JSON.parse(content)).toEqual(testManifest);
+    });
+
+    it("creates parent directories if they do not exist", () => {
+      const nestedPath = path.join(testDir, "nested", "deep", "scope.json");
+      writeManifest(testManifest, nestedPath);
+      expect(fs.existsSync(nestedPath)).toBe(true);
+    });
+
+    it("refuses to overwrite existing file without force flag", () => {
+      writeManifest(testManifest, testPath);
+      expect(() => writeManifest(testManifest, testPath)).toThrow("already exists");
+    });
+
+    it("overwrites existing file with force flag", () => {
+      writeManifest(testManifest, testPath);
+      const updated = { ...testManifest, client: "Updated Corp" };
+      writeManifest(updated, testPath, { force: true });
+      const content = fs.readFileSync(testPath, "utf-8");
+      expect(JSON.parse(content).client).toBe("Updated Corp");
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npx vitest run tests/unit/builder/manifest-writer.test.ts`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: Implement manifest writer**
+
+```typescript
+// src/builder/manifest-writer.ts
+
+import fs from "fs";
+import path from "path";
+import type { ScopeManifest } from "../types.js";
+
+export interface WriteOptions {
+  force?: boolean;
+}
+
+/**
+ * Serialize a ScopeManifest to pretty-printed JSON.
+ */
+export function serializeManifest(manifest: ScopeManifest): string {
+  return JSON.stringify(manifest, null, 2) + "\n";
+}
+
+/**
+ * Write a manifest to disk. Creates parent directories if needed.
+ * Throws if the file already exists unless force is true.
+ */
+export function writeManifest(
+  manifest: ScopeManifest,
+  filePath: string,
+  options: WriteOptions = {}
+): void {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  if (fs.existsSync(filePath) && !options.force) {
+    throw new Error(`File "${filePath}" already exists. Use --force to overwrite.`);
+  }
+
+  const json = serializeManifest(manifest);
+  fs.writeFileSync(filePath, json, "utf-8");
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder/manifest-writer.test.ts`
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/builder/manifest-writer.ts tests/unit/builder/manifest-writer.test.ts
+git commit -m "feat(builder): add manifest writer with overwrite protection"
+```
+
+---
+
+### Task 5: Ink Wizard — Step Components (Steps 1–5)
+
+**Files:**
+- Create: `src/builder/steps/engagement-info.tsx`
+- Create: `src/builder/steps/engagement-window.tsx`
+- Create: `src/builder/steps/domains.tsx`
+- Create: `src/builder/steps/ip-ranges.tsx`
+- Create: `src/builder/steps/urls-and-cloud.tsx`
+
+These are Ink React components. Each step manages its own state and calls `onComplete(data)` when the user finishes the step. Testing Ink components requires `ink-testing-library` which is not currently installed — these will be tested via the integration-level wizard test in Task 7.
+
+- [ ] **Step 1: Create engagement-info step component**
+
+```tsx
+// src/builder/steps/engagement-info.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+
+interface Props {
+  initial?: { engagement_id?: string; client?: string; operator?: string };
+  onComplete: (data: { engagement_id: string; client: string; operator: string }) => void;
+  onBack?: () => void;
+}
+
+type Field = "engagement_id" | "client" | "operator";
+
+const FIELDS: { key: Field; label: string; placeholder: string }[] = [
+  { key: "engagement_id", label: "Engagement ID", placeholder: "ENG-2026-0001" },
+  { key: "client", label: "Client", placeholder: "Acme Corp" },
+  { key: "operator", label: "Operator", placeholder: "operator@integsec.com" },
+];
+
+export function EngagementInfoStep({ initial, onComplete, onBack }: Props): React.ReactElement {
+  const [fieldIndex, setFieldIndex] = useState(0);
+  const [values, setValues] = useState({
+    engagement_id: initial?.engagement_id ?? "",
+    client: initial?.client ?? "",
+    operator: initial?.operator ?? "",
+  });
+  const [input, setInput] = useState(values[FIELDS[0].key]);
+
+  useInput((ch, key) => {
+    if (key.escape && onBack) {
+      onBack();
+      return;
+    }
+
+    if (key.return) {
+      const field = FIELDS[fieldIndex];
+      const newValues = { ...values, [field.key]: input };
+      setValues(newValues);
+
+      if (fieldIndex < FIELDS.length - 1) {
+        const nextIndex = fieldIndex + 1;
+        setFieldIndex(nextIndex);
+        setInput(newValues[FIELDS[nextIndex].key]);
+      } else {
+        // Validate all fields are non-empty
+        if (newValues.engagement_id && newValues.client && newValues.operator) {
+          onComplete(newValues);
+        }
+      }
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+    }
+  });
+
+  const field = FIELDS[fieldIndex];
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 1: Engagement Info</Text>
+      <Text dimColor>Press Enter to confirm each field. Esc to go back.</Text>
+      <Box marginTop={1} />
+
+      {FIELDS.map((f, i) => (
+        <Box key={f.key}>
+          <Text dimColor={i !== fieldIndex}>
+            {i < fieldIndex ? "✓" : i === fieldIndex ? "›" : " "} {f.label}:{" "}
+          </Text>
+          {i < fieldIndex ? (
+            <Text color="green">{values[f.key]}</Text>
+          ) : i === fieldIndex ? (
+            <Text>{input}<Text dimColor>│</Text></Text>
+          ) : (
+            <Text dimColor>{f.placeholder}</Text>
+          )}
+        </Box>
+      ))}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 2: Create engagement-window step component**
+
+```tsx
+// src/builder/steps/engagement-window.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { validateIsoDate, validateWindowSanity, type ValidationMessage } from "../smart-validator.js";
+
+interface Props {
+  initial?: { start?: string; end?: string };
+  onComplete: (data: { start: string; end: string }) => void;
+  onBack?: () => void;
+}
+
+type Field = "start" | "end";
+
+const FIELDS: { key: Field; label: string; placeholder: string }[] = [
+  { key: "start", label: "Start (ISO 8601)", placeholder: "2026-04-01T08:00:00Z" },
+  { key: "end", label: "End (ISO 8601)", placeholder: "2026-04-15T17:00:00Z" },
+];
+
+export function EngagementWindowStep({ initial, onComplete, onBack }: Props): React.ReactElement {
+  const [fieldIndex, setFieldIndex] = useState(0);
+  const [values, setValues] = useState({
+    start: initial?.start ?? "",
+    end: initial?.end ?? "",
+  });
+  const [input, setInput] = useState(values[FIELDS[0].key]);
+  const [messages, setMessages] = useState<ValidationMessage[]>([]);
+
+  useInput((ch, key) => {
+    if (key.escape && onBack) {
+      onBack();
+      return;
+    }
+
+    if (key.return) {
+      const field = FIELDS[fieldIndex];
+
+      // Validate the current field
+      const fieldMsgs = validateIsoDate(input);
+      if (fieldMsgs.some((m) => m.level === "error")) {
+        setMessages(fieldMsgs);
+        return;
+      }
+
+      const newValues = { ...values, [field.key]: input };
+      setValues(newValues);
+      setMessages([]);
+
+      if (fieldIndex < FIELDS.length - 1) {
+        const nextIndex = fieldIndex + 1;
+        setFieldIndex(nextIndex);
+        setInput(newValues[FIELDS[nextIndex].key]);
+      } else {
+        // Validate window sanity
+        const windowMsgs = validateWindowSanity(newValues.start, newValues.end);
+        const errors = windowMsgs.filter((m) => m.level === "error");
+        if (errors.length > 0) {
+          setMessages(windowMsgs);
+          return;
+        }
+        // Show warnings but proceed
+        if (windowMsgs.length > 0) {
+          setMessages(windowMsgs);
+        }
+        onComplete(newValues);
+      }
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+    }
+  });
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 2: Engagement Window</Text>
+      <Text dimColor>Enter start and end dates in ISO 8601 format. Esc to go back.</Text>
+      <Box marginTop={1} />
+
+      {FIELDS.map((f, i) => (
+        <Box key={f.key}>
+          <Text dimColor={i !== fieldIndex}>
+            {i < fieldIndex ? "✓" : i === fieldIndex ? "›" : " "} {f.label}:{" "}
+          </Text>
+          {i < fieldIndex ? (
+            <Text color="green">{values[f.key]}</Text>
+          ) : i === fieldIndex ? (
+            <Text>{input}<Text dimColor>│</Text></Text>
+          ) : (
+            <Text dimColor>{f.placeholder}</Text>
+          )}
+        </Box>
+      ))}
+
+      {messages.map((msg, i) => (
+        <Box key={i} marginTop={i === 0 ? 1 : 0}>
+          <Text color={msg.level === "error" ? "red" : msg.level === "warning" ? "yellow" : "blue"}>
+            {msg.level === "error" ? "✗" : msg.level === "warning" ? "⚠" : "ℹ"} {msg.message}
+          </Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 3: Create domains step component**
+
+```tsx
+// src/builder/steps/domains.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import { validateDomain, checkWildcardApex, resolveDomainPreview, type ValidationMessage } from "../smart-validator.js";
+import { DnsResolver } from "../../dns-resolver.js";
+
+interface Props {
+  initial?: string[];
+  authorizedIpRanges?: string[];
+  onComplete: (domains: string[]) => void;
+  onBack?: () => void;
+}
+
+export function DomainsStep({ initial, authorizedIpRanges, onComplete, onBack }: Props): React.ReactElement {
+  const [domains, setDomains] = useState<string[]>(initial ?? []);
+  const [input, setInput] = useState("");
+  const [messages, setMessages] = useState<ValidationMessage[]>([]);
+  const [resolvedInfo, setResolvedInfo] = useState<string>("");
+  const resolver = React.useRef(new DnsResolver(0)).current;
+
+  useInput((ch, key) => {
+    if (key.escape) {
+      if (input === "" && onBack) {
+        onBack();
+      } else {
+        setInput("");
+        setMessages([]);
+      }
+      return;
+    }
+
+    // 'd' + ctrl = done
+    if (ch === "d" && key.ctrl) {
+      onComplete(domains);
+      return;
+    }
+
+    if (key.return) {
+      if (input.trim() === "") {
+        onComplete(domains);
+        return;
+      }
+
+      // Support comma-separated input
+      const newDomains = input.split(",").map((d) => d.trim()).filter(Boolean);
+      const allMsgs: ValidationMessage[] = [];
+      const validDomains: string[] = [];
+
+      for (const domain of newDomains) {
+        const domainMsgs = validateDomain(domain);
+        if (domainMsgs.some((m) => m.level === "error")) {
+          allMsgs.push(...domainMsgs);
+        } else {
+          validDomains.push(domain);
+          const apexMsgs = checkWildcardApex(domain, [...domains, ...validDomains]);
+          allMsgs.push(...apexMsgs);
+        }
+      }
+
+      if (allMsgs.some((m) => m.level === "error")) {
+        setMessages(allMsgs);
+        return;
+      }
+
+      setDomains((prev) => [...prev, ...validDomains]);
+      setMessages(allMsgs); // Show info/warnings
+      setInput("");
+
+      // Resolve DNS in background for display
+      for (const domain of validDomains) {
+        resolveDomainPreview(domain, resolver).then((result) => {
+          if (result.ips.length > 0) {
+            setResolvedInfo((prev) => prev + `${domain} → ${result.ips.join(", ")}\n`);
+          }
+        });
+      }
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+    }
+  });
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 3: Authorized Domains</Text>
+      <Text dimColor>Enter domains (comma-separated OK). Empty enter or Ctrl+D when done. Esc to go back.</Text>
+      <Box marginTop={1} />
+
+      {domains.map((d, i) => (
+        <Text key={i} color="green">  ✓ {d}</Text>
+      ))}
+
+      <Box>
+        <Text>› </Text>
+        <Text>{input}<Text dimColor>│</Text></Text>
+      </Box>
+
+      {resolvedInfo && (
+        <Box marginTop={1} flexDirection="column">
+          <Text dimColor>DNS Preview:</Text>
+          {resolvedInfo.trim().split("\n").map((line, i) => (
+            <Text key={i} dimColor>  {line}</Text>
+          ))}
+        </Box>
+      )}
+
+      {messages.map((msg, i) => (
+        <Box key={i} marginTop={i === 0 ? 1 : 0}>
+          <Text color={msg.level === "error" ? "red" : msg.level === "warning" ? "yellow" : "blue"}>
+            {msg.level === "error" ? "✗" : msg.level === "warning" ? "⚠" : "ℹ"} {msg.message}
+          </Text>
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>{domains.length} domain(s) added</Text>
+      </Box>
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 4: Create ip-ranges step component**
+
+```tsx
+// src/builder/steps/ip-ranges.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { validateCidr, checkOverlap, type ValidationMessage } from "../smart-validator.js";
+
+interface Props {
+  initial?: string[];
+  resolvedDomainIps?: string[];
+  onComplete: (ranges: string[]) => void;
+  onBack?: () => void;
+}
+
+export function IpRangesStep({ initial, resolvedDomainIps, onComplete, onBack }: Props): React.ReactElement {
+  const [ranges, setRanges] = useState<string[]>(initial ?? []);
+  const [input, setInput] = useState("");
+  const [messages, setMessages] = useState<ValidationMessage[]>([]);
+
+  useInput((ch, key) => {
+    if (key.escape) {
+      if (input === "" && onBack) {
+        onBack();
+      } else {
+        setInput("");
+        setMessages([]);
+      }
+      return;
+    }
+
+    if (ch === "d" && key.ctrl) {
+      onComplete(ranges);
+      return;
+    }
+
+    if (key.return) {
+      if (input.trim() === "") {
+        onComplete(ranges);
+        return;
+      }
+
+      const newRanges = input.split(",").map((r) => r.trim()).filter(Boolean);
+      const allMsgs: ValidationMessage[] = [];
+      const validRanges: string[] = [];
+
+      for (const range of newRanges) {
+        const cidrMsgs = validateCidr(range);
+        if (cidrMsgs.some((m) => m.level === "error")) {
+          allMsgs.push(...cidrMsgs);
+        } else {
+          validRanges.push(range);
+          allMsgs.push(...cidrMsgs); // Include warnings
+          // Check overlap with domain-resolved IPs
+          if (resolvedDomainIps) {
+            allMsgs.push(...checkOverlap(resolvedDomainIps, [range]));
+          }
+        }
+      }
+
+      if (allMsgs.some((m) => m.level === "error")) {
+        setMessages(allMsgs);
+        return;
+      }
+
+      setRanges((prev) => [...prev, ...validRanges]);
+      setMessages(allMsgs);
+      setInput("");
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+    }
+  });
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 4: Authorized IP Ranges</Text>
+      <Text dimColor>Enter CIDR ranges (e.g. 10.10.10.0/24). Empty enter or Ctrl+D when done. Esc to go back.</Text>
+      <Box marginTop={1} />
+
+      {ranges.map((r, i) => (
+        <Text key={i} color="green">  ✓ {r}</Text>
+      ))}
+
+      <Box>
+        <Text>› </Text>
+        <Text>{input}<Text dimColor>│</Text></Text>
+      </Box>
+
+      {messages.map((msg, i) => (
+        <Box key={i} marginTop={i === 0 ? 1 : 0}>
+          <Text color={msg.level === "error" ? "red" : msg.level === "warning" ? "yellow" : "blue"}>
+            {msg.level === "error" ? "✗" : msg.level === "warning" ? "⚠" : "ℹ"} {msg.message}
+          </Text>
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>{ranges.length} range(s) added</Text>
+      </Box>
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 5: Create urls-and-cloud step component**
+
+```tsx
+// src/builder/steps/urls-and-cloud.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+
+interface Props {
+  initial?: { urls?: string[]; cloud_accounts?: string[] };
+  onComplete: (data: { urls: string[]; cloud_accounts: string[] }) => void;
+  onBack?: () => void;
+}
+
+type Section = "urls" | "cloud_accounts";
+
+export function UrlsAndCloudStep({ initial, onComplete, onBack }: Props): React.ReactElement {
+  const [section, setSection] = useState<Section>("urls");
+  const [urls, setUrls] = useState<string[]>(initial?.urls ?? []);
+  const [cloudAccounts, setCloudAccounts] = useState<string[]>(initial?.cloud_accounts ?? []);
+  const [input, setInput] = useState("");
+
+  useInput((ch, key) => {
+    if (key.escape) {
+      if (input === "" && section === "urls" && onBack) {
+        onBack();
+      } else {
+        setInput("");
+      }
+      return;
+    }
+
+    if (ch === "d" && key.ctrl) {
+      onComplete({ urls, cloud_accounts: cloudAccounts });
+      return;
+    }
+
+    if (key.return) {
+      if (input.trim() === "") {
+        if (section === "urls") {
+          setSection("cloud_accounts");
+        } else {
+          onComplete({ urls, cloud_accounts: cloudAccounts });
+        }
+        return;
+      }
+
+      const items = input.split(",").map((s) => s.trim()).filter(Boolean);
+      if (section === "urls") {
+        setUrls((prev) => [...prev, ...items]);
+      } else {
+        setCloudAccounts((prev) => [...prev, ...items]);
+      }
+      setInput("");
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+    }
+  });
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 5: URLs & Cloud Accounts (optional)</Text>
+      <Text dimColor>Enter items or press Enter to skip. Ctrl+D to finish step.</Text>
+      <Box marginTop={1} />
+
+      <Text bold>{section === "urls" ? "› URLs:" : "URLs:"}</Text>
+      {urls.map((u, i) => <Text key={i} color="green">  ✓ {u}</Text>)}
+      {section === "urls" && (
+        <Box>
+          <Text>  › </Text>
+          <Text>{input}<Text dimColor>│</Text></Text>
+        </Box>
+      )}
+
+      <Box marginTop={1} />
+      <Text bold>{section === "cloud_accounts" ? "› Cloud Accounts:" : "Cloud Accounts:"}</Text>
+      {cloudAccounts.map((c, i) => <Text key={i} color="green">  ✓ {c}</Text>)}
+      {section === "cloud_accounts" && (
+        <Box>
+          <Text>  › </Text>
+          <Text>{input}<Text dimColor>│</Text></Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/builder/steps/engagement-info.tsx src/builder/steps/engagement-window.tsx src/builder/steps/domains.tsx src/builder/steps/ip-ranges.tsx src/builder/steps/urls-and-cloud.tsx
+git commit -m "feat(builder): add wizard step components 1-5 (info, window, domains, IPs, URLs)"
+```
+
+---
+
+### Task 6: Ink Wizard — Step Components (Steps 6–8)
+
+**Files:**
+- Create: `src/builder/steps/exclusions.tsx`
+- Create: `src/builder/steps/techniques.tsx`
+- Create: `src/builder/steps/review.tsx`
+
+- [ ] **Step 1: Create exclusions step component**
+
+```tsx
+// src/builder/steps/exclusions.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { checkOrphanedExclusion, type ValidationMessage } from "../smart-validator.js";
+
+interface Props {
+  initial?: string[];
+  authorized: { ip_ranges: string[]; domains: string[] };
+  onComplete: (excluded: string[]) => void;
+  onBack?: () => void;
+}
+
+const SUGGESTED_EXCLUSIONS = [
+  { target: "169.254.169.254", reason: "AWS/Azure/GCP metadata endpoint" },
+  { target: "127.0.0.1", reason: "localhost" },
+];
+
+export function ExclusionsStep({ initial, authorized, onComplete, onBack }: Props): React.ReactElement {
+  const [excluded, setExcluded] = useState<string[]>(initial ?? []);
+  const [input, setInput] = useState("");
+  const [messages, setMessages] = useState<ValidationMessage[]>([]);
+  const [showSuggestions, setShowSuggestions] = useState(true);
+
+  useInput((ch, key) => {
+    if (key.escape) {
+      if (input === "" && onBack) {
+        onBack();
+      } else {
+        setInput("");
+        setMessages([]);
+      }
+      return;
+    }
+
+    if (ch === "d" && key.ctrl) {
+      onComplete(excluded);
+      return;
+    }
+
+    if (key.return) {
+      if (input.trim() === "") {
+        onComplete(excluded);
+        return;
+      }
+
+      const items = input.split(",").map((s) => s.trim()).filter(Boolean);
+      const allMsgs: ValidationMessage[] = [];
+
+      for (const item of items) {
+        allMsgs.push(...checkOrphanedExclusion(item, authorized));
+      }
+
+      setExcluded((prev) => [...prev, ...items]);
+      setMessages(allMsgs);
+      setInput("");
+      setShowSuggestions(false);
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev + ch);
+      setShowSuggestions(false);
+    }
+  });
+
+  // Filter suggestions to exclude already-added items
+  const activeSuggestions = SUGGESTED_EXCLUSIONS.filter(
+    (s) => !excluded.includes(s.target)
+  );
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 6: Excluded Targets</Text>
+      <Text dimColor>Targets that are in scope but must NOT be tested. Empty enter or Ctrl+D when done.</Text>
+      <Box marginTop={1} />
+
+      {showSuggestions && activeSuggestions.length > 0 && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text dimColor>Suggested exclusions:</Text>
+          {activeSuggestions.map((s, i) => (
+            <Text key={i} dimColor>  • {s.target} ({s.reason})</Text>
+          ))}
+        </Box>
+      )}
+
+      {excluded.map((e, i) => (
+        <Text key={i} color="red">  ✗ {e}</Text>
+      ))}
+
+      <Box>
+        <Text>› </Text>
+        <Text>{input}<Text dimColor>│</Text></Text>
+      </Box>
+
+      {messages.map((msg, i) => (
+        <Box key={i} marginTop={i === 0 ? 1 : 0}>
+          <Text color={msg.level === "warning" ? "yellow" : "blue"}>
+            {msg.level === "warning" ? "⚠" : "ℹ"} {msg.message}
+          </Text>
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>{excluded.length} exclusion(s) added</Text>
+      </Box>
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 2: Create techniques step component**
+
+```tsx
+// src/builder/steps/techniques.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+
+interface Props {
+  initialAuthorized?: string[];
+  initialExcluded?: string[];
+  onComplete: (data: { authorized: string[]; excluded: string[] }) => void;
+  onBack?: () => void;
+}
+
+const KNOWN_CATEGORIES = [
+  { name: "recon", description: "Reconnaissance and scanning", tools: "nmap, whois, dig, amass" },
+  { name: "web_app", description: "Web application testing", tools: "burp, zap, nikto, sqlmap" },
+  { name: "api_testing", description: "API security testing", tools: "postman, curl, httpie" },
+  { name: "ssl_tls", description: "SSL/TLS analysis", tools: "sslyze, testssl" },
+  { name: "dos", description: "Denial of service", tools: "hping3, slowloris, synflood" },
+  { name: "destructive", description: "Destructive operations", tools: "disk_wiper, *destroy*, *wipe*" },
+  { name: "social_engineering", description: "Social engineering", tools: "gophish, setoolkit, evilginx" },
+];
+
+const DEFAULT_EXCLUDED = ["dos", "destructive", "social_engineering"];
+
+type Phase = "authorized" | "excluded";
+
+export function TechniquesStep({ initialAuthorized, initialExcluded, onComplete, onBack }: Props): React.ReactElement {
+  const [phase, setPhase] = useState<Phase>("authorized");
+  const [cursor, setCursor] = useState(0);
+  const [authorized, setAuthorized] = useState<Set<string>>(
+    new Set(initialAuthorized ?? ["recon", "web_app", "api_testing"])
+  );
+  const [excluded, setExcluded] = useState<Set<string>>(
+    new Set(initialExcluded ?? DEFAULT_EXCLUDED)
+  );
+
+  useInput((ch, key) => {
+    if (key.escape && onBack) {
+      if (phase === "excluded") {
+        setPhase("authorized");
+        setCursor(0);
+      } else {
+        onBack();
+      }
+      return;
+    }
+
+    if (key.upArrow) {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+
+    if (key.downArrow) {
+      setCursor((prev) => Math.min(KNOWN_CATEGORIES.length - 1, prev + 1));
+      return;
+    }
+
+    if (ch === " ") {
+      const category = KNOWN_CATEGORIES[cursor].name;
+      if (phase === "authorized") {
+        setAuthorized((prev) => {
+          const next = new Set(prev);
+          next.has(category) ? next.delete(category) : next.add(category);
+          return next;
+        });
+      } else {
+        setExcluded((prev) => {
+          const next = new Set(prev);
+          next.has(category) ? next.delete(category) : next.add(category);
+          return next;
+        });
+      }
+      return;
+    }
+
+    if (key.return) {
+      if (phase === "authorized") {
+        setPhase("excluded");
+        setCursor(0);
+      } else {
+        onComplete({
+          authorized: Array.from(authorized),
+          excluded: Array.from(excluded),
+        });
+      }
+      return;
+    }
+  });
+
+  const currentSet = phase === "authorized" ? authorized : excluded;
+  const title = phase === "authorized" ? "Authorized Techniques" : "Excluded Techniques";
+  const color = phase === "authorized" ? "green" : "red";
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 7: {title}</Text>
+      <Text dimColor>Space to toggle, Enter to confirm, ↑/↓ to navigate.</Text>
+      <Box marginTop={1} />
+
+      {KNOWN_CATEGORIES.map((cat, i) => (
+        <Box key={cat.name}>
+          <Text color={i === cursor ? "white" : undefined} dimColor={i !== cursor}>
+            {i === cursor ? "›" : " "} [{currentSet.has(cat.name) ? "×" : " "}]{" "}
+          </Text>
+          <Text color={currentSet.has(cat.name) ? color : undefined} bold={i === cursor}>
+            {cat.name}
+          </Text>
+          <Text dimColor> — {cat.description} ({cat.tools})</Text>
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>
+          {phase === "authorized"
+            ? `${authorized.size} authorized. Press Enter to configure excluded techniques.`
+            : `${excluded.size} excluded. Press Enter to finish.`}
+        </Text>
+      </Box>
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 3: Create review step component**
+
+```tsx
+// src/builder/steps/review.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import Spinner from "ink-spinner";
+import type { ScopeManifest } from "../../types.js";
+import { runDryRun, type DryRunResult } from "../dry-run.js";
+
+interface Props {
+  manifest: ScopeManifest;
+  onConfirm: () => void;
+  onBack?: () => void;
+}
+
+export function ReviewStep({ manifest, onConfirm, onBack }: Props): React.ReactElement {
+  const [dryRunResults, setDryRunResults] = useState<DryRunResult[] | null>(null);
+  const [dryRunError, setDryRunError] = useState<string | null>(null);
+  const [confirmed, setConfirmed] = useState(false);
+
+  useEffect(() => {
+    runDryRun(manifest)
+      .then(setDryRunResults)
+      .catch((err) => setDryRunError(err.message));
+  }, []);
+
+  useInput((ch, key) => {
+    if (key.escape && onBack) {
+      onBack();
+      return;
+    }
+    if (key.return && dryRunResults !== null) {
+      setConfirmed(true);
+      onConfirm();
+      return;
+    }
+  });
+
+  const { authorized_targets: at, excluded_targets: et } = manifest;
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Step 8: Review & Dry-Run</Text>
+      <Box marginTop={1} />
+
+      {/* Manifest summary */}
+      <Text bold>Engagement:</Text>
+      <Text>  ID: {manifest.engagement_id}</Text>
+      <Text>  Client: {manifest.client}</Text>
+      <Text>  Operator: {manifest.operator}</Text>
+      <Text>  Window: {manifest.engagement_window.start} → {manifest.engagement_window.end}</Text>
+
+      <Box marginTop={1} />
+      <Text bold>Authorized Targets:</Text>
+      <Text>  Domains ({at.domains.length}): {at.domains.join(", ") || "none"}</Text>
+      <Text>  IP Ranges ({at.ip_ranges.length}): {at.ip_ranges.join(", ") || "none"}</Text>
+      <Text>  URLs ({at.urls.length}): {at.urls.join(", ") || "none"}</Text>
+      <Text>  Cloud ({at.cloud_accounts.length}): {at.cloud_accounts.join(", ") || "none"}</Text>
+
+      <Box marginTop={1} />
+      <Text bold>Exclusions ({et.length}):</Text>
+      {et.length > 0
+        ? et.map((e, i) => <Text key={i} color="red">  ✗ {e}</Text>)
+        : <Text dimColor>  none</Text>}
+
+      <Box marginTop={1} />
+      <Text bold>Techniques:</Text>
+      <Text color="green">  Authorized: {manifest.authorized_techniques.join(", ") || "none"}</Text>
+      <Text color="red">  Excluded: {manifest.excluded_techniques.join(", ") || "none"}</Text>
+
+      {/* Dry-run results */}
+      <Box marginTop={1} />
+      <Text bold>Dry-Run Preview:</Text>
+      {dryRunError && <Text color="red">  Error: {dryRunError}</Text>}
+      {dryRunResults === null && !dryRunError && (
+        <Text>  <Spinner type="dots" /> Running dry-run...</Text>
+      )}
+      {dryRunResults !== null && (
+        <Box flexDirection="column">
+          {dryRunResults.map((r, i) => (
+            <Text key={i} color={r.pass ? "green" : "red"}>
+              {"  "}{r.pass ? "✓" : "✗"} {r.tool} → {r.target}: {r.actual}
+              {!r.pass ? ` (expected ${r.expected})` : ""}
+            </Text>
+          ))}
+          <Box marginTop={1} />
+          {dryRunResults.some((r) => !r.pass) ? (
+            <Text color="red" bold>⚠ Some dry-run checks did not match expectations. Review above.</Text>
+          ) : (
+            <Text color="green" bold>✓ All dry-run checks passed.</Text>
+          )}
+        </Box>
+      )}
+
+      <Box marginTop={1} />
+      {dryRunResults !== null && !confirmed && (
+        <Text dimColor>Press Enter to confirm and write manifest, Esc to go back.</Text>
+      )}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/builder/steps/exclusions.tsx src/builder/steps/techniques.tsx src/builder/steps/review.tsx
+git commit -m "feat(builder): add wizard step components 6-8 (exclusions, techniques, review)"
+```
+
+---
+
+### Task 7: Wizard Orchestrator
+
+**Files:**
+- Create: `src/builder/wizard.tsx`
+
+- [ ] **Step 1: Create the wizard orchestrator**
+
+```tsx
+// src/builder/wizard.tsx
+import React, { useState } from "react";
+import { Box, Text } from "ink";
+import type { ScopeManifest } from "../types.js";
+import { EngagementInfoStep } from "./steps/engagement-info.js";
+import { EngagementWindowStep } from "./steps/engagement-window.js";
+import { DomainsStep } from "./steps/domains.js";
+import { IpRangesStep } from "./steps/ip-ranges.js";
+import { UrlsAndCloudStep } from "./steps/urls-and-cloud.js";
+import { ExclusionsStep } from "./steps/exclusions.js";
+import { TechniquesStep } from "./steps/techniques.js";
+import { ReviewStep } from "./steps/review.js";
+
+type Step = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+interface Props {
+  /** Pre-fill values (from --from flag or edit mode) */
+  initial?: Partial<ScopeManifest>;
+  /** Called when the wizard completes with a fully built manifest */
+  onFinish: (manifest: ScopeManifest) => void;
+}
+
+interface WizardState {
+  engagement_id: string;
+  client: string;
+  operator: string;
+  engagement_window: { start: string; end: string };
+  domains: string[];
+  ip_ranges: string[];
+  urls: string[];
+  cloud_accounts: string[];
+  excluded_targets: string[];
+  authorized_techniques: string[];
+  excluded_techniques: string[];
+}
+
+function buildManifest(state: WizardState): ScopeManifest {
+  return {
+    engagement_id: state.engagement_id,
+    client: state.client,
+    operator: state.operator,
+    authorized_targets: {
+      ip_ranges: state.ip_ranges,
+      domains: state.domains,
+      urls: state.urls,
+      cloud_accounts: state.cloud_accounts,
+    },
+    excluded_targets: state.excluded_targets,
+    authorized_techniques: state.authorized_techniques,
+    excluded_techniques: state.excluded_techniques,
+    engagement_window: state.engagement_window,
+  };
+}
+
+export function Wizard({ initial, onFinish }: Props): React.ReactElement {
+  const [step, setStep] = useState<Step>(1);
+  const [state, setState] = useState<WizardState>({
+    engagement_id: initial?.engagement_id ?? "",
+    client: initial?.client ?? "",
+    operator: initial?.operator ?? "",
+    engagement_window: initial?.engagement_window ?? { start: "", end: "" },
+    domains: initial?.authorized_targets?.domains ?? [],
+    ip_ranges: initial?.authorized_targets?.ip_ranges ?? [],
+    urls: initial?.authorized_targets?.urls ?? [],
+    cloud_accounts: initial?.authorized_targets?.cloud_accounts ?? [],
+    excluded_targets: initial?.excluded_targets ?? [],
+    authorized_techniques: initial?.authorized_techniques ?? [],
+    excluded_techniques: initial?.excluded_techniques ?? [],
+  });
+
+  const goBack = () => setStep((s) => Math.max(1, s - 1) as Step);
+  const goNext = () => setStep((s) => Math.min(8, s + 1) as Step);
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1}>
+        <Text dimColor>─── Scope Manifest Builder ─── Step {step}/8 ───</Text>
+      </Box>
+
+      {step === 1 && (
+        <EngagementInfoStep
+          initial={{ engagement_id: state.engagement_id, client: state.client, operator: state.operator }}
+          onComplete={(data) => {
+            setState((s) => ({ ...s, ...data }));
+            goNext();
+          }}
+        />
+      )}
+
+      {step === 2 && (
+        <EngagementWindowStep
+          initial={state.engagement_window}
+          onComplete={(data) => {
+            setState((s) => ({ ...s, engagement_window: data }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 3 && (
+        <DomainsStep
+          initial={state.domains}
+          authorizedIpRanges={state.ip_ranges}
+          onComplete={(domains) => {
+            setState((s) => ({ ...s, domains }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 4 && (
+        <IpRangesStep
+          initial={state.ip_ranges}
+          onComplete={(ranges) => {
+            setState((s) => ({ ...s, ip_ranges: ranges }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 5 && (
+        <UrlsAndCloudStep
+          initial={{ urls: state.urls, cloud_accounts: state.cloud_accounts }}
+          onComplete={(data) => {
+            setState((s) => ({ ...s, urls: data.urls, cloud_accounts: data.cloud_accounts }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 6 && (
+        <ExclusionsStep
+          initial={state.excluded_targets}
+          authorized={{ ip_ranges: state.ip_ranges, domains: state.domains }}
+          onComplete={(excluded) => {
+            setState((s) => ({ ...s, excluded_targets: excluded }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 7 && (
+        <TechniquesStep
+          initialAuthorized={state.authorized_techniques}
+          initialExcluded={state.excluded_techniques}
+          onComplete={(data) => {
+            setState((s) => ({
+              ...s,
+              authorized_techniques: data.authorized,
+              excluded_techniques: data.excluded,
+            }));
+            goNext();
+          }}
+          onBack={goBack}
+        />
+      )}
+
+      {step === 8 && (
+        <ReviewStep
+          manifest={buildManifest(state)}
+          onConfirm={() => onFinish(buildManifest(state))}
+          onBack={goBack}
+        />
+      )}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/builder/wizard.tsx
+git commit -m "feat(builder): add wizard orchestrator with 8-step flow and back/forward navigation"
+```
+
+---
+
+### Task 8: CLI Entry Point (`new` mode)
+
+**Files:**
+- Create: `bin/integsec-agentic-pentest-manifest.ts`
+- Modify: `package.json`
+
+- [ ] **Step 1: Create the CLI entry point**
+
+```typescript
+// bin/integsec-agentic-pentest-manifest.ts
+#!/usr/bin/env node
+
+import React from "react";
+import { render } from "ink";
+import fs from "fs";
+import path from "path";
+import { Wizard } from "../src/builder/wizard.js";
+import { writeManifest } from "../src/builder/manifest-writer.js";
+import { ScopeManifestSchema } from "../src/manifest-schema.js";
+import type { ScopeManifest } from "../src/types.js";
+
+function parseArgs(): {
+  mode: "new" | "edit" | "review" | "serve" | "help";
+  fromTemplate?: string;
+  targetFile?: string;
+  section?: string;
+  output?: string;
+} {
+  const args = process.argv.slice(2);
+  const mode = (args[0] ?? "new") as "new" | "edit" | "review" | "serve" | "help";
+
+  let fromTemplate: string | undefined;
+  let targetFile: string | undefined;
+  let section: string | undefined;
+  let output: string | undefined;
+
+  // The second positional arg is the file for edit/review
+  if ((mode === "edit" || mode === "review") && args[1] && !args[1].startsWith("--")) {
+    targetFile = args[1];
+  }
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--from" && args[i + 1]) {
+      fromTemplate = args[i + 1];
+      i++;
+    } else if (args[i] === "--section" && args[i + 1]) {
+      section = args[i + 1];
+      i++;
+    } else if ((args[i] === "--output" || args[i] === "-o") && args[i + 1]) {
+      output = args[i + 1];
+      i++;
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      return { mode: "help" };
+    }
+  }
+
+  return { mode, fromTemplate, targetFile, section, output };
+}
+
+function printHelp(): void {
+  console.log(`
+IntegSec Agentic Pentest MCP Proxy — Manifest Builder
+
+Usage:
+  integsec-agentic-pentest-manifest [mode] [options]
+
+Modes:
+  new                           Create a new scope manifest (default)
+  edit <file>                   Edit an existing manifest
+  review <file>                 Review a client-submitted manifest
+  serve                         Start the client intake web server
+
+Options:
+  --from <template.json>        Pre-fill wizard from a template (new mode)
+  --section <name>              Jump to a specific section (edit mode)
+  -o, --output <file>           Output file path (default: ./scope-manifest.json)
+  -h, --help                    Show this help message
+
+Examples:
+  integsec-agentic-pentest-manifest new
+  integsec-agentic-pentest-manifest new --from template.json -o scope.json
+  integsec-agentic-pentest-manifest edit scope.json --section targets
+  integsec-agentic-pentest-manifest review submission.pending.json
+  integsec-agentic-pentest-manifest serve --template scope-template.json
+`);
+}
+
+function loadTemplate(filePath: string): Partial<ScopeManifest> {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const data = JSON.parse(content);
+  // Partial parse — don't require all fields for a template
+  return data as Partial<ScopeManifest>;
+}
+
+const config = parseArgs();
+
+if (config.mode === "help") {
+  printHelp();
+  process.exit(0);
+}
+
+if (config.mode === "new") {
+  const initial = config.fromTemplate ? loadTemplate(config.fromTemplate) : undefined;
+  const outputPath = config.output ?? "./scope-manifest.json";
+
+  const { unmount } = render(
+    <Wizard
+      initial={initial}
+      onFinish={(manifest) => {
+        unmount();
+        try {
+          writeManifest(manifest, outputPath);
+          console.log(`\n✓ Manifest written to ${outputPath}`);
+        } catch (err: any) {
+          console.error(`\n✗ ${err.message}`);
+          process.exit(1);
+        }
+      }}
+    />
+  );
+} else if (config.mode === "edit") {
+  if (!config.targetFile) {
+    console.error("Error: edit mode requires a file path. Usage: integsec-agentic-pentest-manifest edit <file>");
+    process.exit(1);
+  }
+  const content = fs.readFileSync(config.targetFile, "utf-8");
+  const manifest = ScopeManifestSchema.parse(JSON.parse(content));
+  const outputPath = config.output ?? config.targetFile;
+
+  const { unmount } = render(
+    <Wizard
+      initial={manifest}
+      onFinish={(updated) => {
+        unmount();
+        try {
+          writeManifest(updated, outputPath, { force: true });
+          console.log(`\n✓ Manifest updated at ${outputPath}`);
+        } catch (err: any) {
+          console.error(`\n✗ ${err.message}`);
+          process.exit(1);
+        }
+      }}
+    />
+  );
+} else if (config.mode === "review") {
+  if (!config.targetFile) {
+    console.error("Error: review mode requires a file path. Usage: integsec-agentic-pentest-manifest review <file>");
+    process.exit(1);
+  }
+  // Review mode — Phase 2 (placeholder message)
+  console.log("Review mode is coming in Phase 2. Use 'edit' to review and modify a manifest.");
+  process.exit(0);
+} else if (config.mode === "serve") {
+  // Serve mode — Phase 3 (placeholder message)
+  console.log("Serve mode is coming in Phase 3. Web-based client intake form.");
+  process.exit(0);
+}
+```
+
+- [ ] **Step 2: Add bin entry to package.json**
+
+Add to `package.json` `"bin"` section:
+
+```json
+"integsec-agentic-pentest-manifest": "dist/bin/integsec-agentic-pentest-manifest.js"
+```
+
+- [ ] **Step 3: Build and smoke test**
+
+Run: `npx tsc && node dist/bin/integsec-agentic-pentest-manifest.js --help`
+Expected: Help text prints without errors
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add bin/integsec-agentic-pentest-manifest.ts package.json
+git commit -m "feat(builder): add CLI entry point with new/edit modes and help"
+```
+
+---
+
+### Task 9: Run full test suite and fix issues
+
+**Files:**
+- All files from Tasks 1-8
+
+- [ ] **Step 1: Build the project**
+
+Run: `npx tsc`
+Expected: No type errors
+
+- [ ] **Step 2: Run all tests**
+
+Run: `npx vitest run`
+Expected: All tests pass (existing + new)
+
+- [ ] **Step 3: Fix any type errors or test failures**
+
+Address any issues found in Step 1-2.
+
+- [ ] **Step 4: Commit any fixes**
+
+```bash
+git add -A
+git commit -m "fix(builder): resolve type errors and test failures from Phase 1"
+```
+
+---
+
+## Phase 2: `edit` and `review` modes
+
+### Task 10: Review Mode CLI
+
+**Files:**
+- Modify: `bin/integsec-agentic-pentest-manifest.ts`
+- Create: `src/builder/review-display.tsx`
+
+- [ ] **Step 1: Create review display component**
+
+```tsx
+// src/builder/review-display.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import Spinner from "ink-spinner";
+import type { ScopeManifest } from "../types.js";
+import {
+  validateCidr,
+  validateDomain,
+  validateWindowSanity,
+  checkOrphanedExclusion,
+  type ValidationMessage,
+} from "./smart-validator.js";
+import { runDryRun, type DryRunResult } from "./dry-run.js";
+import { writeManifest } from "./manifest-writer.js";
+
+interface Props {
+  manifest: ScopeManifest;
+  sourcePath: string;
+  onDone: () => void;
+}
+
+type ReviewAction = "pending" | "approve" | "reject";
+
+export function ReviewDisplay({ manifest, sourcePath, onDone }: Props): React.ReactElement {
+  const [validationMsgs, setValidationMsgs] = useState<ValidationMessage[]>([]);
+  const [dryRunResults, setDryRunResults] = useState<DryRunResult[] | null>(null);
+  const [action, setAction] = useState<ReviewAction>("pending");
+
+  useEffect(() => {
+    // Run all smart validations
+    const msgs: ValidationMessage[] = [];
+
+    for (const cidr of manifest.authorized_targets.ip_ranges) {
+      msgs.push(...validateCidr(cidr));
+    }
+    for (const domain of manifest.authorized_targets.domains) {
+      msgs.push(...validateDomain(domain));
+    }
+    msgs.push(...validateWindowSanity(
+      manifest.engagement_window.start,
+      manifest.engagement_window.end
+    ));
+    for (const excluded of manifest.excluded_targets) {
+      msgs.push(...checkOrphanedExclusion(excluded, {
+        ip_ranges: manifest.authorized_targets.ip_ranges,
+        domains: manifest.authorized_targets.domains,
+      }));
+    }
+
+    setValidationMsgs(msgs);
+
+    // Run dry-run
+    runDryRun(manifest)
+      .then(setDryRunResults)
+      .catch(() => setDryRunResults([]));
+  }, []);
+
+  useInput((ch, key) => {
+    if (ch === "a" && action === "pending") {
+      // Approve — write final manifest
+      const outputPath = sourcePath.replace(".pending.json", ".json");
+      try {
+        writeManifest(manifest, outputPath, { force: true });
+        setAction("approve");
+        setTimeout(onDone, 500);
+      } catch {
+        // Error handled in display
+      }
+      return;
+    }
+    if (ch === "r" && action === "pending") {
+      setAction("reject");
+      setTimeout(onDone, 500);
+      return;
+    }
+    if (key.escape) {
+      onDone();
+      return;
+    }
+  });
+
+  const errors = validationMsgs.filter((m) => m.level === "error");
+  const warnings = validationMsgs.filter((m) => m.level === "warning");
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold color="cyan">Manifest Review: {sourcePath}</Text>
+      <Box marginTop={1} />
+
+      <Text bold>Engagement: {manifest.engagement_id} — {manifest.client}</Text>
+      <Text>Operator: {manifest.operator}</Text>
+      <Text>Window: {manifest.engagement_window.start} → {manifest.engagement_window.end}</Text>
+      <Text>Domains: {manifest.authorized_targets.domains.join(", ") || "none"}</Text>
+      <Text>IP Ranges: {manifest.authorized_targets.ip_ranges.join(", ") || "none"}</Text>
+      <Text>Exclusions: {manifest.excluded_targets.join(", ") || "none"}</Text>
+
+      {/* Validation */}
+      <Box marginTop={1} />
+      <Text bold>Validation:</Text>
+      {errors.length === 0 && warnings.length === 0 && (
+        <Text color="green">  ✓ No issues found</Text>
+      )}
+      {errors.map((m, i) => <Text key={`e${i}`} color="red">  ✗ {m.message}</Text>)}
+      {warnings.map((m, i) => <Text key={`w${i}`} color="yellow">  ⚠ {m.message}</Text>)}
+
+      {/* Dry-run */}
+      <Box marginTop={1} />
+      <Text bold>Dry-Run:</Text>
+      {dryRunResults === null ? (
+        <Text>  <Spinner type="dots" /> Running...</Text>
+      ) : (
+        dryRunResults.map((r, i) => (
+          <Text key={i} color={r.pass ? "green" : "red"}>
+            {"  "}{r.pass ? "✓" : "✗"} {r.tool} → {r.target}: {r.actual}
+          </Text>
+        ))
+      )}
+
+      {/* Actions */}
+      <Box marginTop={1} />
+      {action === "pending" && (
+        <Text dimColor>[a] Approve  [r] Reject  [Esc] Cancel</Text>
+      )}
+      {action === "approve" && (
+        <Text color="green" bold>✓ Approved and saved.</Text>
+      )}
+      {action === "reject" && (
+        <Text color="red" bold>✗ Rejected.</Text>
+      )}
+    </Box>
+  );
+}
+```
+
+- [ ] **Step 2: Wire review mode into CLI**
+
+In `bin/integsec-agentic-pentest-manifest.ts`, replace the review mode placeholder:
+
+```typescript
+} else if (config.mode === "review") {
+  if (!config.targetFile) {
+    console.error("Error: review mode requires a file path. Usage: integsec-agentic-pentest-manifest review <file>");
+    process.exit(1);
+  }
+  const content = fs.readFileSync(config.targetFile, "utf-8");
+  const manifest = ScopeManifestSchema.parse(JSON.parse(content));
+
+  const { unmount } = render(
+    <ReviewDisplay
+      manifest={manifest}
+      sourcePath={config.targetFile}
+      onDone={() => {
+        unmount();
+        process.exit(0);
+      }}
+    />
+  );
+}
+```
+
+Add import at top:
+```typescript
+import { ReviewDisplay } from "../src/builder/review-display.js";
+```
+
+- [ ] **Step 3: Build and test**
+
+Run: `npx tsc`
+Expected: No errors
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/builder/review-display.tsx bin/integsec-agentic-pentest-manifest.ts
+git commit -m "feat(builder): add review mode with smart validation and dry-run"
+```
+
+---
+
+## Phase 3: Web Server (`serve` mode)
+
+### Task 11: Web Server Core
+
+**Files:**
+- Create: `src/builder/web/server.ts`
+- Create: `src/builder/web/api.ts`
+- Test: `tests/unit/builder-web/server.test.ts`
+- Test: `tests/unit/builder-web/api.test.ts`
+
+- [ ] **Step 1: Write failing tests for API handlers**
+
+```typescript
+// tests/unit/builder-web/api.test.ts
+import { describe, it, expect } from "vitest";
+import {
+  handleGetTemplate,
+  handlePostSubmit,
+} from "../../../src/builder/web/api.js";
+import type { ScopeManifest } from "../../../src/types.js";
+import fs from "fs";
+import path from "path";
+
+const template: Partial<ScopeManifest> = {
+  engagement_id: "ENG-2026-0001",
+  client: "Test Corp",
+  operator: "test@test.com",
+  engagement_window: { start: "2026-04-01T00:00:00Z", end: "2026-04-15T00:00:00Z" },
+  excluded_techniques: ["dos", "destructive"],
+};
+
+describe("API Handlers", () => {
+  describe("handleGetTemplate", () => {
+    it("returns the template as JSON", () => {
+      const result = handleGetTemplate(template);
+      expect(result.status).toBe(200);
+      expect(JSON.parse(result.body)).toEqual(template);
+    });
+
+    it("returns empty object when no template", () => {
+      const result = handleGetTemplate(undefined);
+      expect(result.status).toBe(200);
+      expect(JSON.parse(result.body)).toEqual({});
+    });
+  });
+
+  describe("handlePostSubmit", () => {
+    const outputDir = path.join(process.cwd(), "test-output-api");
+
+    afterEach(() => {
+      if (fs.existsSync(outputDir)) {
+        fs.rmSync(outputDir, { recursive: true });
+      }
+    });
+
+    it("validates and saves a valid submission", () => {
+      const submission: ScopeManifest = {
+        engagement_id: "ENG-2026-0001",
+        client: "Test Corp",
+        operator: "test@test.com",
+        authorized_targets: { ip_ranges: ["10.0.0.0/24"], domains: ["*.test.com"], urls: [], cloud_accounts: [] },
+        excluded_targets: [],
+        authorized_techniques: ["recon"],
+        excluded_techniques: ["dos"],
+        engagement_window: { start: "2026-04-01T00:00:00Z", end: "2026-04-15T00:00:00Z" },
+      };
+
+      const result = handlePostSubmit(JSON.stringify(submission), outputDir);
+      expect(result.status).toBe(200);
+      expect(JSON.parse(result.body).success).toBe(true);
+
+      // Check file was written
+      const files = fs.readdirSync(outputDir).filter((f) => f.endsWith(".pending.json"));
+      expect(files).toHaveLength(1);
+    });
+
+    it("rejects invalid JSON", () => {
+      const result = handlePostSubmit("not json", outputDir);
+      expect(result.status).toBe(400);
+    });
+
+    it("rejects manifest that fails schema validation", () => {
+      const result = handlePostSubmit(JSON.stringify({ engagement_id: "" }), outputDir);
+      expect(result.status).toBe(400);
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npx vitest run tests/unit/builder-web/api.test.ts`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: Implement API handlers**
+
+```typescript
+// src/builder/web/api.ts
+
+import fs from "fs";
+import path from "path";
+import { ScopeManifestSchema } from "../../manifest-schema.js";
+import type { ScopeManifest } from "../../types.js";
+
+export interface ApiResponse {
+  status: number;
+  body: string;
+  contentType: string;
+}
+
+export function handleGetTemplate(template: Partial<ScopeManifest> | undefined): ApiResponse {
+  return {
+    status: 200,
+    body: JSON.stringify(template ?? {}),
+    contentType: "application/json",
+  };
+}
+
+export function handlePostSubmit(rawBody: string, outputDir: string): ApiResponse {
+  let data: unknown;
+  try {
+    data = JSON.parse(rawBody);
+  } catch {
+    return {
+      status: 400,
+      body: JSON.stringify({ success: false, error: "Invalid JSON" }),
+      contentType: "application/json",
+    };
+  }
+
+  const parseResult = ScopeManifestSchema.safeParse(data);
+  if (!parseResult.success) {
+    return {
+      status: 400,
+      body: JSON.stringify({
+        success: false,
+        error: "Schema validation failed",
+        details: parseResult.error.issues.map((i) => i.message),
+      }),
+      contentType: "application/json",
+    };
+  }
+
+  // Write to outputDir as a .pending.json file
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  const filename = `${parseResult.data.engagement_id}-${Date.now()}.pending.json`;
+  const filePath = path.join(outputDir, filename);
+  fs.writeFileSync(filePath, JSON.stringify(parseResult.data, null, 2) + "\n", "utf-8");
+
+  return {
+    status: 200,
+    body: JSON.stringify({ success: true, file: filename }),
+    contentType: "application/json",
+  };
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder-web/api.test.ts`
+Expected: All tests PASS
+
+- [ ] **Step 5: Implement web server with TLS enforcement**
+
+```typescript
+// src/builder/web/server.ts
+
+import http from "http";
+import https from "https";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { ScopeManifest } from "../../types.js";
+import { handleGetTemplate, handlePostSubmit } from "./api.js";
+
+export interface ServeOptions {
+  port: number;
+  host: string;
+  template?: Partial<ScopeManifest>;
+  outputDir: string;
+  tlsCert?: string;
+  tlsKey?: string;
+  timeoutMinutes: number;
+}
+
+export function startServer(options: ServeOptions): http.Server | https.Server {
+  const { port, host, template, outputDir, tlsCert, tlsKey, timeoutMinutes } = options;
+
+  // TLS enforcement: non-localhost requires TLS
+  const isLocalhost = host === "127.0.0.1" || host === "localhost" || host === "::1";
+  if (!isLocalhost && (!tlsCert || !tlsKey)) {
+    console.error(
+      "Refusing to serve client intake form over plaintext on a non-localhost interface. " +
+      "Provide --tls-cert and --tls-key."
+    );
+    process.exit(1);
+  }
+
+  // Load the client form HTML
+  const thisDir = path.dirname(fileURLToPath(import.meta.url));
+  const formPath = path.join(thisDir, "client-form.html");
+  const formHtml = fs.existsSync(formPath) ? fs.readFileSync(formPath, "utf-8") : "<h1>Form not found</h1>";
+
+  const handler = (req: http.IncomingMessage, res: http.ServerResponse) => {
+    // CORS headers for local development
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.method === "GET" && (req.url === "/" || req.url === "")) {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(formHtml);
+      return;
+    }
+
+    if (req.method === "GET" && req.url === "/template") {
+      const result = handleGetTemplate(template);
+      res.writeHead(result.status, { "Content-Type": result.contentType });
+      res.end(result.body);
+      return;
+    }
+
+    if (req.method === "POST" && req.url === "/submit") {
+      let body = "";
+      req.on("data", (chunk) => { body += chunk; });
+      req.on("end", () => {
+        const result = handlePostSubmit(body, outputDir);
+        res.writeHead(result.status, { "Content-Type": result.contentType });
+        res.end(result.body);
+
+        if (result.status === 200) {
+          console.log(`\n✓ Submission received and saved to ${outputDir}`);
+        }
+      });
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  };
+
+  let server: http.Server | https.Server;
+
+  if (tlsCert && tlsKey) {
+    const cert = fs.readFileSync(tlsCert, "utf-8");
+    const key = fs.readFileSync(tlsKey, "utf-8");
+    server = https.createServer({ cert, key }, handler);
+  } else {
+    server = http.createServer(handler);
+  }
+
+  // Auto-shutdown timer
+  let timeout: ReturnType<typeof setTimeout>;
+  const resetTimeout = () => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      console.log(`\nServer auto-shutdown after ${timeoutMinutes} minutes of inactivity.`);
+      server.close();
+      process.exit(0);
+    }, timeoutMinutes * 60_000);
+  };
+
+  server.on("request", resetTimeout);
+
+  server.listen(port, host, () => {
+    const protocol = tlsCert ? "https" : "http";
+    const displayHost = host === "0.0.0.0" ? "localhost" : host;
+    console.log(`\n🔒 Scope Manifest — Client Intake Form`);
+    console.log(`   ${protocol}://${displayHost}:${port}`);
+    console.log(`   Output: ${outputDir}`);
+    console.log(`   Auto-shutdown: ${timeoutMinutes} minutes\n`);
+    resetTimeout();
+  });
+
+  return server;
+}
+```
+
+- [ ] **Step 6: Write failing test for server TLS enforcement**
+
+```typescript
+// tests/unit/builder-web/server.test.ts
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+describe("Server TLS enforcement", () => {
+  it("exits with error when non-localhost host lacks TLS", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const { startServer } = await import("../../../src/builder/web/server.js");
+
+    expect(() => startServer({
+      port: 0,
+      host: "0.0.0.0",
+      outputDir: "/tmp/test",
+      timeoutMinutes: 60,
+    })).toThrow("exit");
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Refusing to serve")
+    );
+
+    exitSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+});
+```
+
+- [ ] **Step 7: Run tests to verify they pass**
+
+Run: `npx vitest run tests/unit/builder-web/`
+Expected: All tests PASS
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/builder/web/server.ts src/builder/web/api.ts tests/unit/builder-web/
+git commit -m "feat(builder): add web server with TLS enforcement and API handlers"
+```
+
+---
+
+### Task 12: Client Intake Form HTML
+
+**Files:**
+- Create: `src/builder/web/client-form.html`
+
+- [ ] **Step 1: Create the client intake form**
+
+```html
+<!-- src/builder/web/client-form.html -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>IntegSec — Scope Definition</title>
+  <style>
+    :root {
+      --bg: #0f1117;
+      --surface: #1a1d27;
+      --border: #2a2d3a;
+      --text: #e1e4ed;
+      --text-dim: #8b8fa3;
+      --accent: #6366f1;
+      --accent-hover: #818cf8;
+      --success: #10b981;
+      --error: #ef4444;
+      --warning: #f59e0b;
+    }
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.6;
+      padding: 2rem;
+      max-width: 800px;
+      margin: 0 auto;
+    }
+    h1 {
+      font-size: 1.5rem;
+      margin-bottom: 0.25rem;
+    }
+    .subtitle {
+      color: var(--text-dim);
+      margin-bottom: 2rem;
+    }
+    .section {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+    }
+    .section h2 {
+      font-size: 1.1rem;
+      margin-bottom: 1rem;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+    label {
+      display: block;
+      font-size: 0.875rem;
+      color: var(--text-dim);
+      margin-bottom: 0.25rem;
+    }
+    .tooltip {
+      font-size: 0.75rem;
+      color: var(--text-dim);
+      margin-bottom: 0.5rem;
+      font-style: italic;
+    }
+    input, textarea {
+      width: 100%;
+      padding: 0.5rem 0.75rem;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      color: var(--text);
+      font-family: "SF Mono", "Fira Code", monospace;
+      font-size: 0.875rem;
+      margin-bottom: 1rem;
+    }
+    input:focus, textarea:focus {
+      outline: none;
+      border-color: var(--accent);
+    }
+    input:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+    input.valid { border-color: var(--success); }
+    input.invalid { border-color: var(--error); }
+    .field-msg {
+      font-size: 0.75rem;
+      margin-top: -0.75rem;
+      margin-bottom: 0.75rem;
+    }
+    .field-msg.error { color: var(--error); }
+    .field-msg.warning { color: var(--warning); }
+    .field-msg.info { color: var(--accent); }
+    textarea { min-height: 80px; resize: vertical; }
+    button {
+      background: var(--accent);
+      color: white;
+      border: none;
+      padding: 0.75rem 2rem;
+      border-radius: 6px;
+      font-size: 1rem;
+      cursor: pointer;
+      display: block;
+      width: 100%;
+      margin-top: 1rem;
+    }
+    button:hover { background: var(--accent-hover); }
+    button:disabled { opacity: 0.5; cursor: not-allowed; }
+    .result {
+      padding: 1rem;
+      border-radius: 6px;
+      margin-top: 1rem;
+      text-align: center;
+    }
+    .result.success { background: rgba(16, 185, 129, 0.1); border: 1px solid var(--success); color: var(--success); }
+    .result.error { background: rgba(239, 68, 68, 0.1); border: 1px solid var(--error); color: var(--error); }
+    .locked-badge {
+      font-size: 0.65rem;
+      background: var(--border);
+      padding: 0.15rem 0.4rem;
+      border-radius: 3px;
+      color: var(--text-dim);
+      vertical-align: middle;
+    }
+    .brand {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-bottom: 1.5rem;
+      padding-bottom: 1rem;
+      border-bottom: 1px solid var(--border);
+    }
+    .brand-logo {
+      font-weight: 700;
+      font-size: 1.1rem;
+      color: var(--accent);
+    }
+  </style>
+</head>
+<body>
+  <div class="brand">
+    <span class="brand-logo">IntegSec</span>
+    <span class="subtitle" style="margin: 0">Scope Definition Form</span>
+  </div>
+
+  <form id="scopeForm" onsubmit="return submitForm(event)">
+    <!-- Engagement Info -->
+    <div class="section">
+      <h2>Engagement Info</h2>
+      <label for="engagement_id">Engagement ID</label>
+      <input type="text" id="engagement_id" placeholder="ENG-2026-0001">
+
+      <label for="client">Client Organization</label>
+      <input type="text" id="client" placeholder="Acme Corp">
+
+      <label for="operator">Operator Contact</label>
+      <input type="text" id="operator" placeholder="operator@integsec.com">
+    </div>
+
+    <!-- Engagement Window -->
+    <div class="section">
+      <h2>Engagement Window</h2>
+      <label for="window_start">Start (ISO 8601)</label>
+      <div class="tooltip">Example: 2026-04-01T08:00:00Z</div>
+      <input type="text" id="window_start" placeholder="2026-04-01T08:00:00Z">
+
+      <label for="window_end">End (ISO 8601)</label>
+      <input type="text" id="window_end" placeholder="2026-04-15T17:00:00Z">
+    </div>
+
+    <!-- Authorized Targets -->
+    <div class="section">
+      <h2>Authorized Targets</h2>
+
+      <label for="domains">Domains</label>
+      <div class="tooltip">One per line. Wildcards OK: *.acme.com matches app.acme.com but not acme.com</div>
+      <textarea id="domains" placeholder="*.acme.com&#10;acme-staging.example.com"></textarea>
+
+      <label for="ip_ranges">IP Ranges (CIDR)</label>
+      <div class="tooltip">CIDR notation. Example: 10.10.10.0/24 covers 10.10.10.0 through 10.10.10.255</div>
+      <textarea id="ip_ranges" placeholder="10.10.10.0/24&#10;203.0.113.0/28"></textarea>
+
+      <label for="urls">URLs (optional)</label>
+      <div class="tooltip">Reference URLs for the engagement. One per line.</div>
+      <textarea id="urls" placeholder="https://app.acme.com&#10;https://api.acme.com"></textarea>
+
+      <label for="cloud_accounts">Cloud Accounts (optional)</label>
+      <div class="tooltip">Format: provider:account-id. Example: aws:123456789012</div>
+      <textarea id="cloud_accounts" placeholder="aws:123456789012"></textarea>
+    </div>
+
+    <!-- Exclusions -->
+    <div class="section">
+      <h2>Exclusions</h2>
+      <label for="excluded_targets">Excluded Targets</label>
+      <div class="tooltip">Targets within scope that must NOT be tested. One per line.</div>
+      <textarea id="excluded_targets" placeholder="hr.acme.com&#10;203.0.113.5"></textarea>
+    </div>
+
+    <!-- Techniques -->
+    <div class="section">
+      <h2>Techniques</h2>
+
+      <label for="authorized_techniques">Authorized Techniques</label>
+      <div class="tooltip">Comma-separated. Common: recon, web_app, api_testing, ssl_tls</div>
+      <input type="text" id="authorized_techniques" placeholder="recon, web_app, api_testing">
+
+      <label for="excluded_techniques">Excluded Techniques</label>
+      <div class="tooltip">Comma-separated. Usually: dos, destructive, social_engineering</div>
+      <input type="text" id="excluded_techniques" placeholder="dos, destructive, social_engineering">
+    </div>
+
+    <button type="submit" id="submitBtn">Submit Scope Definition</button>
+    <div id="result"></div>
+  </form>
+
+  <script>
+    // Load template and lock pre-filled fields
+    fetch("/template")
+      .then((r) => r.json())
+      .then((tpl) => {
+        const fieldMap = {
+          engagement_id: "engagement_id",
+          client: "client",
+          operator: "operator",
+        };
+        for (const [key, id] of Object.entries(fieldMap)) {
+          if (tpl[key]) {
+            const el = document.getElementById(id);
+            el.value = tpl[key];
+            el.disabled = true;
+          }
+        }
+        if (tpl.engagement_window) {
+          if (tpl.engagement_window.start) {
+            const el = document.getElementById("window_start");
+            el.value = tpl.engagement_window.start;
+            el.disabled = true;
+          }
+          if (tpl.engagement_window.end) {
+            const el = document.getElementById("window_end");
+            el.value = tpl.engagement_window.end;
+            el.disabled = true;
+          }
+        }
+        if (tpl.excluded_techniques) {
+          const el = document.getElementById("excluded_techniques");
+          el.value = tpl.excluded_techniques.join(", ");
+          el.disabled = true;
+        }
+      })
+      .catch(() => {}); // No template, all fields editable
+
+    // Live validation on text inputs
+    document.querySelectorAll("input[type=text]").forEach((input) => {
+      input.addEventListener("blur", () => {
+        if (input.disabled) return;
+        if (input.value.trim()) {
+          input.classList.add("valid");
+          input.classList.remove("invalid");
+        } else if (input.required || ["engagement_id", "client", "operator"].includes(input.id)) {
+          input.classList.add("invalid");
+          input.classList.remove("valid");
+        }
+      });
+    });
+
+    function parseLines(id) {
+      return document.getElementById(id).value
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    }
+
+    function parseComma(id) {
+      return document.getElementById(id).value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    }
+
+    function val(id) {
+      return document.getElementById(id).value.trim();
+    }
+
+    async function submitForm(e) {
+      e.preventDefault();
+      const btn = document.getElementById("submitBtn");
+      const result = document.getElementById("result");
+      btn.disabled = true;
+      btn.textContent = "Submitting...";
+
+      const manifest = {
+        engagement_id: val("engagement_id"),
+        client: val("client"),
+        operator: val("operator"),
+        authorized_targets: {
+          ip_ranges: parseLines("ip_ranges"),
+          domains: parseLines("domains"),
+          urls: parseLines("urls"),
+          cloud_accounts: parseLines("cloud_accounts"),
+        },
+        excluded_targets: parseLines("excluded_targets"),
+        authorized_techniques: parseComma("authorized_techniques"),
+        excluded_techniques: parseComma("excluded_techniques"),
+        engagement_window: {
+          start: val("window_start"),
+          end: val("window_end"),
+        },
+      };
+
+      try {
+        const res = await fetch("/submit", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(manifest),
+        });
+        const data = await res.json();
+        if (data.success) {
+          result.className = "result success";
+          result.textContent = "Scope definition submitted successfully. Your operator will review it.";
+        } else {
+          result.className = "result error";
+          result.textContent = "Validation failed: " + (data.details?.join(", ") || data.error);
+        }
+      } catch (err) {
+        result.className = "result error";
+        result.textContent = "Network error: " + err.message;
+      }
+
+      btn.disabled = false;
+      btn.textContent = "Submit Scope Definition";
+      return false;
+    }
+  </script>
+</body>
+</html>
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/builder/web/client-form.html
+git commit -m "feat(builder): add client intake web form with live validation"
+```
+
+---
+
+### Task 13: Wire `serve` Mode into CLI
+
+**Files:**
+- Modify: `bin/integsec-agentic-pentest-manifest.ts`
+
+- [ ] **Step 1: Update CLI to support serve mode**
+
+In `bin/integsec-agentic-pentest-manifest.ts`, add serve-mode args to `parseArgs()`:
+
+```typescript
+// Add to the return type:
+  template?: string;
+  host?: string;
+  port?: number;
+  tlsCert?: string;
+  tlsKey?: string;
+  timeout?: number;
+```
+
+Add arg parsing in the for loop:
+
+```typescript
+    } else if (args[i] === "--template" && args[i + 1]) {
+      fromTemplate = args[i + 1]; // reuse fromTemplate for serve template
+      i++;
+    } else if (args[i] === "--host" && args[i + 1]) {
+      // Store host in a new variable
+      i++;
+    } else if (args[i] === "--port" && args[i + 1]) {
+      i++;
+    } else if (args[i] === "--tls-cert" && args[i + 1]) {
+      i++;
+    } else if (args[i] === "--tls-key" && args[i + 1]) {
+      i++;
+    } else if (args[i] === "--timeout" && args[i + 1]) {
+      i++;
+    }
+```
+
+Replace the serve mode placeholder:
+
+```typescript
+} else if (config.mode === "serve") {
+  const template = config.fromTemplate ? loadTemplate(config.fromTemplate) : undefined;
+
+  // Parse serve-specific args
+  const args = process.argv.slice(2);
+  let host = "127.0.0.1";
+  let port = 9471;
+  let tlsCert: string | undefined;
+  let tlsKey: string | undefined;
+  let timeout = 60;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--host" && args[i + 1]) { host = args[i + 1]; i++; }
+    if (args[i] === "--port" && args[i + 1]) { port = parseInt(args[i + 1], 10); i++; }
+    if (args[i] === "--tls-cert" && args[i + 1]) { tlsCert = args[i + 1]; i++; }
+    if (args[i] === "--tls-key" && args[i + 1]) { tlsKey = args[i + 1]; i++; }
+    if (args[i] === "--timeout" && args[i + 1]) { timeout = parseInt(args[i + 1], 10); i++; }
+  }
+
+  const { startServer } = await import("../src/builder/web/server.js");
+  startServer({
+    port,
+    host,
+    template,
+    outputDir: config.output ?? "./submissions",
+    tlsCert,
+    tlsKey,
+    timeoutMinutes: timeout,
+  });
+}
+```
+
+- [ ] **Step 2: Build and smoke test**
+
+Run: `npx tsc && node dist/bin/integsec-agentic-pentest-manifest.js serve --help`
+Expected: Help text shows serve mode
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add bin/integsec-agentic-pentest-manifest.ts
+git commit -m "feat(builder): wire serve mode into CLI with TLS and timeout options"
+```
+
+---
+
+## Phase 4: README & Polish
+
+### Task 14: Update README
+
+**Files:**
+- Modify: `README.md`
+
+- [ ] **Step 1: Read current README**
+
+Read `README.md` to understand current structure and find the right insertion point.
+
+- [ ] **Step 2: Add Manifest Builder section**
+
+Add a new section after the existing usage/configuration sections:
+
+```markdown
+## Manifest Builder
+
+Build scope manifests interactively with smart validation, or share a web form with clients for scope intake.
+
+### Quick Start
+
+```bash
+# Create a new manifest interactively
+integsec-agentic-pentest-manifest new
+
+# Create from a template
+integsec-agentic-pentest-manifest new --from template.json -o scope.json
+
+# Edit an existing manifest
+integsec-agentic-pentest-manifest edit scope.json
+
+# Review a client submission
+integsec-agentic-pentest-manifest review submission.pending.json
+```
+
+### Client Intake (Web Form)
+
+Share a web-based form with clients so they can define their own scope:
+
+```bash
+# Local only (default — localhost:9471)
+integsec-agentic-pentest-manifest serve --template engagement-template.json
+
+# Network-accessible (TLS required)
+integsec-agentic-pentest-manifest serve \
+  --host 0.0.0.0 \
+  --tls-cert ./certs/server.pem \
+  --tls-key ./certs/server-key.pem \
+  --template engagement-template.json
+```
+
+**Workflow:**
+1. Operator creates a template with engagement info, time window, and technique restrictions
+2. Operator runs `serve` and shares the URL with the client
+3. Client fills in their targets (domains, IPs, exclusions) via the web form
+4. Client submits → saved as `.pending.json`
+5. Operator reviews: `integsec-agentic-pentest-manifest review submission.pending.json`
+6. Operator approves, edits, or rejects
+
+**Security:** The web server binds to `127.0.0.1` by default. Exposing on `0.0.0.0` requires `--tls-cert` and `--tls-key` — the server refuses to start over plaintext on non-localhost interfaces.
+
+### Smart Validation
+
+The builder validates your manifest as you build it:
+
+- **Format checks** — valid CIDRs, ISO 8601 dates, non-empty required fields
+- **Live DNS resolution** — resolves domains and shows their IPs
+- **Overlap detection** — warns when domains resolve to IPs already covered by CIDR ranges
+- **Broad range warnings** — flags CIDR ranges wider than /16
+- **Wildcard/apex prompts** — suggests adding `acme.com` when `*.acme.com` is entered
+- **Exclusion checks** — warns if an excluded target isn't within any authorized range
+
+### Dry-Run Preview
+
+Before saving, the builder runs synthetic tool calls against your manifest to preview what the proxy will allow and block. This catches scope misconfigurations before an engagement starts.
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add README.md
+git commit -m "docs: add Manifest Builder section to README"
+```
+
+---
+
+### Task 15: Full Build, Test, and Polish
+
+**Files:**
+- All project files
+
+- [ ] **Step 1: Build the project**
+
+Run: `npx tsc`
+Expected: No type errors
+
+- [ ] **Step 2: Run full test suite**
+
+Run: `npx vitest run`
+Expected: All tests pass
+
+- [ ] **Step 3: Fix any remaining issues**
+
+Address any type errors, test failures, or lint issues.
+
+- [ ] **Step 4: Final commit**
+
+```bash
+git add -A
+git commit -m "chore(builder): Phase 4 polish — resolve remaining issues"
+```
+
+- [ ] **Step 5: Verify the three entry points work**
+
+Run:
+```bash
+node dist/bin/integsec-agentic-pentest-manifest.js --help
+node dist/bin/integsec-agentic-pentest-manifest.js serve &
+curl http://localhost:9471/ -s | head -5
+kill %1
+```
+
+Expected: Help prints, server starts, HTML form is served.