ai-spec-dev 0.38.0 → 0.41.0

package/tests/run-logger.test.ts

@@ -0,0 +1,289 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import {
+  RunLogger,
+  generateRunId,
+  reconstructRunLogFromJsonl,
+  setActiveLogger,
+  getActiveLogger,
+} from "../core/run-logger";
+
+describe("generateRunId", () => {
+  it("returns a non-empty string", () => {
+    expect(generateRunId()).toBeTruthy();
+  });
+
+  it("has expected format YYYYMMDD-HHMMSS-rand", () => {
+    const id = generateRunId();
+    expect(id).toMatch(/^\d{8}-\d{6}-[a-z0-9]{4}$/);
+  });
+
+  it("produces unique IDs", () => {
+    const ids = new Set(Array.from({ length: 20 }, () => generateRunId()));
+    // With 4-char random suffix, collisions within 20 calls are extremely unlikely
+    expect(ids.size).toBeGreaterThanOrEqual(15);
+  });
+});
+
+describe("RunLogger", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `rl-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("creates log directory and files on construction", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-001");
+    // flush is async — give it a tick
+    await new Promise((r) => setTimeout(r, 50));
+    const logDir = path.join(tmpDir, ".ai-spec-logs");
+    expect(await fs.pathExists(logDir)).toBe(true);
+    expect(await fs.pathExists(path.join(logDir, "test-run-001.json"))).toBe(true);
+    expect(await fs.pathExists(path.join(logDir, "test-run-001.jsonl"))).toBe(true);
+  });
+
+  it("stores provider and model metadata", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-002", {
+      provider: "gemini",
+      model: "gemini-2.5-pro",
+      specPath: "specs/test.md",
+    });
+    await new Promise((r) => setTimeout(r, 50));
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-002.json"));
+    expect(json.provider).toBe("gemini");
+    expect(json.model).toBe("gemini-2.5-pro");
+    expect(json.specPath).toBe("specs/test.md");
+  });
+
+  it("records stage start/end with duration", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-003");
+    logger.stageStart("spec");
+    await new Promise((r) => setTimeout(r, 20));
+    logger.stageEnd("spec", { tasks: 5 });
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-003.json"));
+    const startEntry = json.entries.find((e: { event: string }) => e.event === "spec");
+    const endEntry = json.entries.find((e: { event: string }) => e.event === "spec:done");
+    expect(startEntry).toBeDefined();
+    expect(endEntry).toBeDefined();
+    expect(endEntry.data.durationMs).toBeGreaterThanOrEqual(0);
+    expect(endEntry.data.tasks).toBe(5);
+  });
+
+  it("records stage failures with error message", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-004");
+    logger.stageStart("dsl");
+    logger.stageFail("dsl", "JSON parse error");
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-004.json"));
+    expect(json.errors).toContain("[dsl] JSON parse error");
+    const failEntry = json.entries.find((e: { event: string }) => e.event === "dsl:failed");
+    expect(failEntry).toBeDefined();
+    expect(failEntry.data.error).toBe("JSON parse error");
+  });
+
+  it("records promptHash via setPromptHash", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-005");
+    logger.setPromptHash("abc12345");
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-005.json"));
+    expect(json.promptHash).toBe("abc12345");
+  });
+
+  it("records harnessScore via setHarnessScore", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-006");
+    logger.setHarnessScore(7.5);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-006.json"));
+    expect(json.harnessScore).toBe(7.5);
+  });
+
+  it("records filesWritten and deduplicates", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-007");
+    logger.fileWritten("src/api/user.ts");
+    logger.fileWritten("src/api/user.ts"); // duplicate
+    logger.fileWritten("src/api/order.ts");
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-007.json"));
+    expect(json.filesWritten).toEqual(["src/api/user.ts", "src/api/order.ts"]);
+  });
+
+  it("finish() sets endedAt and totalDurationMs", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-008");
+    await new Promise((r) => setTimeout(r, 20));
+    logger.finish();
+    await new Promise((r) => setTimeout(r, 50));
+
+    const json = await fs.readJson(path.join(tmpDir, ".ai-spec-logs", "test-run-008.json"));
+    expect(json.endedAt).toBeTruthy();
+    expect(json.totalDurationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("printSummary does not throw", () => {
+    const logger = new RunLogger(tmpDir, "test-run-009");
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    logger.finish();
+    expect(() => logger.printSummary()).not.toThrow();
+    spy.mockRestore();
+  });
+
+  it("writes JSONL header on construction", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-010", { provider: "claude" });
+    await new Promise((r) => setTimeout(r, 50));
+
+    const jsonlContent = fs.readFileSync(
+      path.join(tmpDir, ".ai-spec-logs", "test-run-010.jsonl"),
+      "utf-8"
+    );
+    const lines = jsonlContent.trim().split("\n");
+    const header = JSON.parse(lines[0]);
+    expect(header.type).toBe("header");
+    expect(header.runId).toBe("test-run-010");
+    expect(header.provider).toBe("claude");
+  });
+
+  it("appends entry/error/file/meta/footer lines to JSONL", async () => {
+    const logger = new RunLogger(tmpDir, "test-run-011");
+    await new Promise((r) => setTimeout(r, 30));
+    logger.stageStart("codegen");
+    logger.fileWritten("src/a.ts");
+    logger.stageFail("codegen", "timeout");
+    logger.setPromptHash("deadbeef");
+    logger.setHarnessScore(6.0);
+    logger.finish();
+    await new Promise((r) => setTimeout(r, 50));
+
+    const jsonlContent = fs.readFileSync(
+      path.join(tmpDir, ".ai-spec-logs", "test-run-011.jsonl"),
+      "utf-8"
+    );
+    const lines = jsonlContent.trim().split("\n").map((l) => JSON.parse(l));
+    const types = lines.map((l) => l.type);
+
+    expect(types).toContain("header");
+    expect(types).toContain("entry");
+    expect(types).toContain("file");
+    expect(types).toContain("error");
+    expect(types).toContain("meta");
+    expect(types).toContain("footer");
+  });
+});
+
+// ─── reconstructRunLogFromJsonl ─────────────────────────────────────────────
+
+describe("reconstructRunLogFromJsonl", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `rl-recon-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  function writeJsonl(filename: string, lines: Record<string, unknown>[]) {
+    const content = lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
+    fs.writeFileSync(path.join(tmpDir, filename), content);
+  }
+
+  it("reconstructs a complete RunLog from JSONL", () => {
+    writeJsonl("run.jsonl", [
+      { type: "header", runId: "r001", startedAt: "2026-04-01T00:00:00Z", workingDir: "/tmp", provider: "gemini", model: "pro" },
+      { type: "entry", ts: "2026-04-01T00:00:01Z", event: "spec" },
+      { type: "entry", ts: "2026-04-01T00:00:02Z", event: "spec:done", durationMs: 1000 },
+      { type: "file", path: "src/api/user.ts" },
+      { type: "error", message: "[codegen] timeout" },
+      { type: "meta", key: "promptHash", value: "abc123" },
+      { type: "meta", key: "harnessScore", value: 7.5 },
+      { type: "footer", endedAt: "2026-04-01T00:00:10Z", totalDurationMs: 10000, harnessScore: 7.5 },
+    ]);
+
+    const log = reconstructRunLogFromJsonl(path.join(tmpDir, "run.jsonl"));
+    expect(log).not.toBeNull();
+    expect(log!.runId).toBe("r001");
+    expect(log!.provider).toBe("gemini");
+    expect(log!.model).toBe("pro");
+    expect(log!.entries).toHaveLength(2);
+    expect(log!.entries[1].durationMs).toBe(1000);
+    expect(log!.filesWritten).toEqual(["src/api/user.ts"]);
+    expect(log!.errors).toEqual(["[codegen] timeout"]);
+    expect(log!.promptHash).toBe("abc123");
+    expect(log!.harnessScore).toBe(7.5);
+    expect(log!.endedAt).toBe("2026-04-01T00:00:10Z");
+    expect(log!.totalDurationMs).toBe(10000);
+  });
+
+  it("returns null for non-existent file", () => {
+    expect(reconstructRunLogFromJsonl("/no/such/file.jsonl")).toBeNull();
+  });
+
+  it("returns null when header is missing (no runId)", () => {
+    writeJsonl("no-header.jsonl", [
+      { type: "entry", ts: "2026-04-01T00:00:01Z", event: "spec" },
+    ]);
+    expect(reconstructRunLogFromJsonl(path.join(tmpDir, "no-header.jsonl"))).toBeNull();
+  });
+
+  it("skips corrupt JSON lines without crashing", () => {
+    const filePath = path.join(tmpDir, "corrupt.jsonl");
+    fs.writeFileSync(
+      filePath,
+      `{"type":"header","runId":"r002","startedAt":"2026-04-01T00:00:00Z","workingDir":"/tmp"}\n`
+        + `{not valid json}\n`
+        + `{"type":"entry","ts":"2026-04-01T00:00:01Z","event":"spec"}\n`
+    );
+    const log = reconstructRunLogFromJsonl(filePath);
+    expect(log).not.toBeNull();
+    expect(log!.entries).toHaveLength(1);
+  });
+
+  it("reconstructs partial log from crashed run (no footer)", () => {
+    writeJsonl("crashed.jsonl", [
+      { type: "header", runId: "r003", startedAt: "2026-04-01T00:00:00Z", workingDir: "/tmp" },
+      { type: "entry", ts: "2026-04-01T00:00:01Z", event: "spec" },
+      { type: "file", path: "src/a.ts" },
+    ]);
+    const log = reconstructRunLogFromJsonl(path.join(tmpDir, "crashed.jsonl"));
+    expect(log).not.toBeNull();
+    expect(log!.runId).toBe("r003");
+    expect(log!.entries).toHaveLength(1);
+    expect(log!.filesWritten).toEqual(["src/a.ts"]);
+    expect(log!.endedAt).toBeUndefined();
+  });
+
+  it("handles empty file", () => {
+    fs.writeFileSync(path.join(tmpDir, "empty.jsonl"), "");
+    expect(reconstructRunLogFromJsonl(path.join(tmpDir, "empty.jsonl"))).toBeNull();
+  });
+});
+
+// ─── Singleton accessors ────────────────────────────────────────────────────
+
+describe("active logger singleton", () => {
+  it("get returns null by default", () => {
+    // Reset by setting null manually — singleton is module-level
+    setActiveLogger(null as unknown as RunLogger);
+    // getActiveLogger returns what was set
+  });
+
+  it("set/get round-trips", () => {
+    const tmpDir = os.tmpdir();
+    const logger = new RunLogger(tmpDir, "singleton-test");
+    setActiveLogger(logger);
+    expect(getActiveLogger()).toBe(logger);
+  });
+});

package/tests/run-snapshot.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import {
+  RunSnapshot,
+  setActiveSnapshot,
+  getActiveSnapshot,
+} from "../core/run-snapshot";
+
+describe("RunSnapshot", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `snap-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("starts with fileCount = 0", () => {
+    const snap = new RunSnapshot(tmpDir, "run-001");
+    expect(snap.fileCount).toBe(0);
+  });
+
+  it("snapshotFile copies an existing file to backup dir", async () => {
+    const filePath = path.join(tmpDir, "src", "app.ts");
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, "original content", "utf-8");
+
+    const snap = new RunSnapshot(tmpDir, "run-002");
+    await snap.snapshotFile(filePath);
+
+    expect(snap.fileCount).toBe(1);
+    const backupPath = path.join(tmpDir, ".ai-spec-backup", "run-002", "src", "app.ts");
+    expect(await fs.pathExists(backupPath)).toBe(true);
+    expect(await fs.readFile(backupPath, "utf-8")).toBe("original content");
+  });
+
+  it("snapshotFile is no-op for non-existent files", async () => {
+    const snap = new RunSnapshot(tmpDir, "run-003");
+    await snap.snapshotFile(path.join(tmpDir, "does-not-exist.ts"));
+    expect(snap.fileCount).toBe(0);
+  });
+
+  it("snapshotFile deduplicates — only backs up once per file", async () => {
+    const filePath = path.join(tmpDir, "file.ts");
+    await fs.writeFile(filePath, "v1", "utf-8");
+
+    const snap = new RunSnapshot(tmpDir, "run-004");
+    await snap.snapshotFile(filePath);
+    // Overwrite the original
+    await fs.writeFile(filePath, "v2", "utf-8");
+    await snap.snapshotFile(filePath);
+
+    expect(snap.fileCount).toBe(1);
+    // Backup should still be v1
+    const backupPath = path.join(tmpDir, ".ai-spec-backup", "run-004", "file.ts");
+    expect(await fs.readFile(backupPath, "utf-8")).toBe("v1");
+  });
+
+  it("snapshotFile handles relative paths", async () => {
+    const filePath = path.join(tmpDir, "rel.ts");
+    await fs.writeFile(filePath, "relative", "utf-8");
+
+    const snap = new RunSnapshot(tmpDir, "run-005");
+    await snap.snapshotFile("rel.ts");
+
+    expect(snap.fileCount).toBe(1);
+  });
+
+  it("restore() restores all snapshotted files", async () => {
+    const f1 = path.join(tmpDir, "a.ts");
+    const f2 = path.join(tmpDir, "sub", "b.ts");
+    await fs.writeFile(f1, "original-a", "utf-8");
+    await fs.ensureDir(path.dirname(f2));
+    await fs.writeFile(f2, "original-b", "utf-8");
+
+    const snap = new RunSnapshot(tmpDir, "run-006");
+    await snap.snapshotFile(f1);
+    await snap.snapshotFile(f2);
+
+    // Overwrite originals
+    await fs.writeFile(f1, "modified-a", "utf-8");
+    await fs.writeFile(f2, "modified-b", "utf-8");
+
+    const restored = await snap.restore();
+    expect(restored).toHaveLength(2);
+    expect(await fs.readFile(f1, "utf-8")).toBe("original-a");
+    expect(await fs.readFile(f2, "utf-8")).toBe("original-b");
+  });
+
+  it("restore() returns empty array when no backup exists", async () => {
+    const snap = new RunSnapshot(tmpDir, "run-007");
+    const restored = await snap.restore();
+    expect(restored).toEqual([]);
+  });
+});
+
+describe("active snapshot singleton", () => {
+  it("set/get round-trips", () => {
+    const snap = new RunSnapshot(os.tmpdir(), "singleton-test");
+    setActiveSnapshot(snap);
+    expect(getActiveSnapshot()).toBe(snap);
+  });
+
+  it("returns null when not set", () => {
+    setActiveSnapshot(null as unknown as RunSnapshot);
+    expect(getActiveSnapshot()).toBeNull();
+  });
+});

package/tests/safe-json.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { safeParseJson, parseJsonFromAiOutput } from "../core/safe-json";
+
+describe("safeParseJson", () => {
+  it("parses bare JSON object", () => {
+    expect(safeParseJson('{"a": 1}')).toEqual({ a: 1 });
+  });
+
+  it("parses bare JSON array", () => {
+    expect(safeParseJson('[1, 2, 3]')).toEqual([1, 2, 3]);
+  });
+
+  it("parses fenced JSON", () => {
+    const input = "Here is the result:\n```json\n{\"x\": true}\n```\nDone.";
+    expect(safeParseJson(input)).toEqual({ x: true });
+  });
+
+  it("parses JSON embedded in text", () => {
+    const input = "The output is: {\"key\": \"value\"} and that's it.";
+    expect(safeParseJson(input)).toEqual({ key: "value" });
+  });
+
+  it("returns null for non-JSON text", () => {
+    expect(safeParseJson("hello world")).toBeNull();
+  });
+
+  it("returns null for malformed JSON", () => {
+    expect(safeParseJson("{broken")).toBeNull();
+  });
+
+  it("handles whitespace-wrapped JSON", () => {
+    expect(safeParseJson("  \n  {\"ok\": true}  \n  ")).toEqual({ ok: true });
+  });
+
+  it("handles fenced JSON with language tag", () => {
+    const input = "```json\n[1, 2]\n```";
+    expect(safeParseJson(input)).toEqual([1, 2]);
+  });
+
+  it("supports generic type parameter", () => {
+    const result = safeParseJson<{ name: string }>('{"name": "test"}');
+    expect(result?.name).toBe("test");
+  });
+
+  it("handles embedded array in text", () => {
+    const input = 'The tasks are: [{"id": 1}, {"id": 2}] above.';
+    expect(safeParseJson(input)).toEqual([{ id: 1 }, { id: 2 }]);
+  });
+});
+
+describe("parseJsonFromAiOutput", () => {
+  it("returns parsed JSON on valid input", () => {
+    expect(parseJsonFromAiOutput('{"a": 1}')).toEqual({ a: 1 });
+  });
+
+  it("throws SyntaxError on invalid input", () => {
+    expect(() => parseJsonFromAiOutput("no json here")).toThrow(SyntaxError);
+  });
+
+  it("throws on completely empty input", () => {
+    expect(() => parseJsonFromAiOutput("")).toThrow(SyntaxError);
+  });
+});

package/tests/spec-updater.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import { SpecUpdater } from "../core/spec-updater";
+
+describe("SpecUpdater.findLatestSpec", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `su-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("returns null when specs dir does not exist", async () => {
+    const result = await SpecUpdater.findLatestSpec(path.join(tmpDir, "specs"));
+    expect(result).toBeNull();
+  });
+
+  it("returns null when no spec files match the pattern", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    await fs.writeFile(path.join(specsDir, "readme.md"), "not a spec");
+    const result = await SpecUpdater.findLatestSpec(specsDir);
+    expect(result).toBeNull();
+  });
+
+  it("finds the latest version", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    await fs.writeFile(path.join(specsDir, "feature-orders-v1.md"), "# v1 spec");
+    await fs.writeFile(path.join(specsDir, "feature-orders-v2.md"), "# v2 spec");
+    await fs.writeFile(path.join(specsDir, "feature-orders-v3.md"), "# v3 spec");
+
+    const result = await SpecUpdater.findLatestSpec(specsDir);
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe(3);
+    expect(result!.slug).toBe("orders");
+    expect(result!.content).toBe("# v3 spec");
+  });
+
+  it("returns slug correctly from filename", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    await fs.writeFile(path.join(specsDir, "feature-user-auth-v1.md"), "# auth");
+
+    const result = await SpecUpdater.findLatestSpec(specsDir);
+    expect(result!.slug).toBe("user-auth");
+  });
+
+  it("handles multiple features and picks highest version per slug", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    await fs.writeFile(path.join(specsDir, "feature-orders-v1.md"), "orders v1");
+    await fs.writeFile(path.join(specsDir, "feature-auth-v5.md"), "auth v5");
+
+    const result = await SpecUpdater.findLatestSpec(specsDir);
+    // Should return the highest version across ALL features
+    expect(result!.version).toBe(5);
+    expect(result!.slug).toBe("auth");
+  });
+});
+
+describe("SpecUpdater.update", () => {
+  let tmpDir: string;
+  const mockProvider = {
+    generate: vi.fn(),
+    providerName: "test",
+    modelName: "test-model",
+  };
+  const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `su-update-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+    mockProvider.generate.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  const validDslJson = JSON.stringify({
+    feature: { title: "Orders", description: "Updated" },
+    models: [],
+    endpoints: [],
+    behaviors: [],
+  });
+
+  it("generates updated spec and saves new version", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    const specPath = path.join(specsDir, "feature-orders-v1.md");
+    await fs.writeFile(specPath, "# Original Spec\n\nExisting content.");
+
+    // Mock: 1) spec update, 2+) DslExtractor.extract (retries on validation)
+    mockProvider.generate
+      .mockResolvedValueOnce("# Updated Spec\n\nNew content.")
+      .mockResolvedValue(validDslJson);
+
+    const updater = new SpecUpdater(mockProvider);
+    const result = await updater.update("Add pagination", specPath, tmpDir);
+
+    expect(result.newVersion).toBe(2);
+    expect(result.newSpecPath).toContain("feature-orders-v2.md");
+    expect(await fs.readFile(result.newSpecPath, "utf-8")).toContain("Updated Spec");
+  });
+
+  it("returns null DSL when extraction fails", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    const specPath = path.join(specsDir, "feature-test-v1.md");
+    await fs.writeFile(specPath, "# Spec");
+
+    // Mock: 1) spec update, 2+3) DslExtractor.extract retries → all invalid
+    mockProvider.generate
+      .mockResolvedValueOnce("# Updated Spec")
+      .mockResolvedValue("not json at all");
+
+    const updater = new SpecUpdater(mockProvider);
+    const result = await updater.update("Change something", specPath, tmpDir);
+
+    expect(result.newSpecPath).toContain("v2.md");
+    expect(result.updatedDsl).toBeNull();
+    expect(result.newDslPath).toBeNull();
+  });
+
+  it("throws when spec generation fails", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    const specPath = path.join(specsDir, "feature-fail-v1.md");
+    await fs.writeFile(specPath, "# Spec");
+
+    mockProvider.generate.mockRejectedValueOnce(new Error("API down"));
+
+    const updater = new SpecUpdater(mockProvider);
+    await expect(updater.update("Change", specPath, tmpDir)).rejects.toThrow("Spec update generation failed");
+  });
+
+  it("strips markdown fences from AI output", async () => {
+    const specsDir = path.join(tmpDir, "specs");
+    await fs.ensureDir(specsDir);
+    const specPath = path.join(specsDir, "feature-fenced-v1.md");
+    await fs.writeFile(specPath, "# Spec");
+
+    // Mock: 1) spec update (fenced), 2+) DslExtractor.extract retries → invalid
+    mockProvider.generate
+      .mockResolvedValueOnce("```markdown\n# Clean Spec\n```")
+      .mockResolvedValue("not valid dsl");
+
+    const updater = new SpecUpdater(mockProvider);
+    const result = await updater.update("Update", specPath, tmpDir);
+    const content = await fs.readFile(result.newSpecPath, "utf-8");
+    expect(content).not.toContain("```");
+    expect(content).toContain("# Clean Spec");
+  });
+});