@monotykamary/pi-vcc 0.3.17 → 0.4.1

package/tests/build-sections.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { buildSections } from "../src/core/build-sections";
-import type { NormalizedBlock } from "../src/types";
-
-describe("buildSections", () => {
-  it("returns all-empty for no blocks", () => {
-    const r = buildSections({ blocks: [] });
-    expect(r.sessionGoal).toEqual([]);
-    expect(r.outstandingContext).toEqual([]);
-    expect(r.briefTranscript).toBe("");
-  });
-
-  it("populates sections from realistic blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix the auth bug" },
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
-      { kind: "tool_result", name: "Read", text: "const x = 1;", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-      { kind: "assistant", text: "- run tests next" },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.sessionGoal).toContain("Fix the auth bug");
-    expect(r.briefTranscript).toContain('[user]');
-    expect(r.briefTranscript).toContain('* Read "auth.ts"');
-    expect(r.briefTranscript).toContain('* Edit "auth.ts"');
-  });
-
-  it("captures outstanding context from errors", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "FAIL: test broken\ndetails here", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("FAIL");
-  });
-
-  it("brief transcript hides tool results but shows errors", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "Read", text: "lots of code here ...", isError: false },
-      { kind: "tool_result", name: "bash", text: "Command not found", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.briefTranscript).not.toContain("lots of code");
-    expect(r.briefTranscript).toContain("[tool_error] bash");
-    expect(r.briefTranscript).toContain("Command not found");
-  });
-
-  it("brief transcript merges adjacent assistant sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Part one." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      { kind: "assistant", text: "Part two." },
-    ];
-    const r = buildSections({ blocks });
-    const matches = r.briefTranscript.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-});

package/tests/compile.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compile } from "../src/core/summarize";
-import {
-  userMsg,
-  assistantText,
-  assistantWithToolCall,
-  toolResult,
-} from "./fixtures";
-
-describe("compile", () => {
-  it("returns empty string for no messages", () => {
-    expect(compile({ messages: [] })).toBe("");
-  });
-
-  it("produces hybrid output with header + brief transcript", () => {
-    const r = compile({
-      messages: [
-        userMsg("Fix login bug"),
-        assistantWithToolCall("Read", { path: "auth.ts" }),
-        assistantText("Found the issue.\n1. Fix validation"),
-      ],
-    });
-    expect(r).toContain("[Session Goal]");
-    expect(r).toContain("Fix login bug");
-    expect(r).toContain("---");
-    expect(r).toContain("[user]\nFix login bug");
-    expect(r).toContain('* Read "auth.ts"');
-    expect(r).toContain("Found the issue.");
-  });
-
-  it("merges previous summary goals", () => {
-    const r = compile({
-      messages: [userMsg("New task")],
-      previousSummary: "[Session Goal]\n- Original goal\n\n---\n\n[user]\nOriginal goal",
-    });
-    expect(r).toContain("- Original goal");
-    expect(r).toContain("- New task");
-  });
-
-  it("appends brief transcript on merge", () => {
-    const previousSummary = [
-      "[Session Goal]\n- Original goal",
-      "---",
-      "[user]\nOriginal goal\n\n[assistant]\n* Read \"old.ts\"",
-    ].join("\n\n");
-    const r = compile({
-      previousSummary,
-      messages: [
-        userMsg("Next step"),
-        assistantWithToolCall("Read", { path: "new.ts" }),
-      ],
-    });
-    expect(r).toContain('* Read "old.ts"');
-    expect(r).toContain('* Read "new.ts"');
-    expect(r).toContain("Next step");
-  });
-
-  it("outstanding context is volatile (fresh only)", () => {
-    const previousSummary = "[Outstanding Context]\n- old blocker\n\n---\n\n[user]\nhi";
-    const r = compile({
-      previousSummary,
-      messages: [userMsg("continue")],
-    });
-    expect(r).not.toContain("old blocker");
-  });
-
-  it("caps long brief transcript with rolling window", () => {
-    // Build a very long previous transcript
-    const longTranscript = Array.from({ length: 200 }, (_, i) =>
-      `[user]\nmessage ${i}`
-    ).join("\n\n");
-    const previousSummary = `[Session Goal]\n- goal\n\n---\n\n${longTranscript}`;
-    const r = compile({
-      previousSummary,
-      messages: [userMsg("latest")],
-    });
-    expect(r).toContain("earlier lines omitted");
-    expect(r).toContain("latest");
-  });
-
-  it("wraps final output including recall note", () => {
-    const r = compile({
-      messages: [userMsg("check final summary wrapping")],
-    });
-    const maxLineLength = Math.max(...r.split("\n").map((line) => line.length));
-    expect(r).toContain("vcc_recall");
-    expect(maxLineLength).toBeLessThanOrEqual(120);
-  });
-});

package/tests/content.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { textOf, thinkingOf, clip, firstLine } from "../src/core/content";
-
-describe("textOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(textOf(undefined as any)).toBe("");
-  });
-
-  it("returns empty string for null content", () => {
-    expect(textOf(null as any)).toBe("");
-  });
-
-  it("returns string content as-is", () => {
-    expect(textOf("hello")).toBe("hello");
-  });
-
-  it("extracts text parts from array content", () => {
-    const content = [
-      { type: "text" as const, text: "first" },
-      { type: "toolCall" as const, name: "x", id: "1", arguments: {} },
-      { type: "text" as const, text: "second" },
-    ];
-    expect(textOf(content)).toBe("first\nsecond");
-  });
-
-  it("ignores thinking parts", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "let me think" },
-      { type: "text" as const, text: "here is the answer" },
-    ];
-    expect(textOf(content)).toBe("here is the answer");
-  });
-});
-
-describe("thinkingOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(thinkingOf(undefined as any)).toBe("");
-  });
-
-  it("returns empty string for string content", () => {
-    expect(thinkingOf("hello")).toBe("");
-  });
-
-  it("extracts thinking parts from array content", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "let me think" },
-      { type: "text" as const, text: "here is the answer" },
-    ];
-    expect(thinkingOf(content)).toBe("let me think");
-  });
-
-  it("joins multiple thinking parts", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "first thought" },
-      { type: "text" as const, text: "answer" },
-      { type: "thinking" as const, thinking: "second thought" },
-    ];
-    expect(thinkingOf(content)).toBe("first thought\nsecond thought");
-  });
-});
-
-describe("textOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(textOf(undefined as any)).toBe("");
-  });
-});

package/tests/deep-extraction.test.ts

@@ -1,313 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { buildSections } from "../src/core/build-sections";
-import type { NormalizedBlock } from "../src/types";
-
-describe("outstanding context: deep error extraction", () => {
-  it("captures bash non-zero exit codes", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "npm test", output: "1 failed", exitCode: 1 },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("bash:exit 1");
-    expect(r.outstandingContext[0]).toContain("npm test");
-  });
-
-  it("captures bash non-zero exit code with output context", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "cargo build", output: "error: could not compile", exitCode: 101 },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("bash:exit 101");
-    expect(r.outstandingContext[0]).toContain("cargo build");
-    expect(r.outstandingContext[0]).toContain("could not compile");
-  });
-
-  it("skips bash with exit code 0", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "echo ok", output: "ok", exitCode: 0 },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext).toEqual([]);
-  });
-
-  it("skips bash with undefined exit code", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "echo ok", output: "ok", exitCode: undefined },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext).toEqual([]);
-  });
-
-  it("captures TypeScript compiler errors", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "tsc --noEmit", output: "src/auth.ts(12,5): error TS2322: Type 'string' is not assignable to type 'number'.", exitCode: 0 },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext.some(c => c.includes("[tsc]"))).toBe(true);
-    expect(r.outstandingContext.some(c => c.includes("TS2322"))).toBe(true);
-  });
-
-  it("captures test failures in bash output", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "bun test", output: "2 failed\nFAIL auth.test.ts", exitCode: 1 },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    // Should capture both the exit code AND the test failure signal
-    const hasExitCode = r.outstandingContext.some(c => c.includes("bash:exit 1"));
-    const hasTests = r.outstandingContext.some(c => c.includes("[tests]"));
-    expect(hasExitCode || hasTests).toBe(true);
-  });
-
-  it("captures empty grep results", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "grep", args: { pattern: "verifyToken", path: "src/" } },
-      { kind: "tool_result", name: "grep", text: "No matches found", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("[no matches]");
-    expect(r.outstandingContext[0]).toContain("grep");
-    expect(r.outstandingContext[0]).toContain("verifyToken");
-  });
-
-  it("captures empty glob results", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "glob", args: { pattern: "**/*.proto" } },
-      { kind: "tool_result", name: "glob", text: "No files matched.", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("[no matches]");
-    expect(r.outstandingContext[0]).toContain("glob");
-  });
-
-  it("captures tsc errors from tool_result with bash error", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "src/utils.ts(5,1): error TS2305: Module has no exported member 'foo'.", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext.some(c => c.includes("[tsc]"))).toBe(true);
-  });
-
-  it("still captures BLOCKER_RE text from assistant", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "The deployment is still failing because of the auth configuration." },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("still failing");
-  });
-
-  it("deduplicates error items", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "Command not found", isError: true },
-      { kind: "tool_result", name: "bash", text: "Command not found", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    const matchCount = r.outstandingContext.filter(c => c.includes("Command not found")).length;
-    expect(matchCount).toBeLessThanOrEqual(1);
-  });
-});
-
-describe("files and changes: symbol annotations", () => {
-  it("annotates modified files with exported symbol names from Edit newText", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts", newText: "export function login() {}\nexport function verifyToken() {}\nconst _internal = 1;" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges.length).toBeGreaterThan(0);
-    expect(r.filesAndChanges[0]).toContain("Modified");
-    expect(r.filesAndChanges[0]).toContain("login");
-    expect(r.filesAndChanges[0]).toContain("verifyToken");
-  });
-
-  it("annotates read files with exported symbol names from Read result", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "types.ts" } },
-      { kind: "tool_result", name: "Read", text: "export interface User { name: string; }\nexport type AuthPayload = { email: string; }", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges.length).toBeGreaterThan(0);
-    expect(r.filesAndChanges[0]).toContain("Read");
-    expect(r.filesAndChanges[0]).toContain("User");
-    expect(r.filesAndChanges[0]).toContain("AuthPayload");
-  });
-
-  it("does not annotate files when no symbols are found", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "config.json" } },
-      { kind: "tool_result", name: "Read", text: '{ "name": "test" }', isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges[0]).toContain("config.json");
-    expect(r.filesAndChanges[0]).not.toContain("(");
-  });
-
-  it("handles Mixed Edit+Read with combined symbols", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "utils.ts" } },
-      { kind: "tool_result", name: "Read", text: "export function helper() {}\nexport class Util {}", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "utils.ts", newText: "export function newHelper() {}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges[0]).toContain("Modified");
-    expect(r.filesAndChanges[0]).toContain("utils.ts");
-    // Should contain symbols from both Read result and Edit newText
-    expect(r.filesAndChanges[0]).toContain("newHelper");
-  });
-
-  it("annotates Python def and class exports", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.py" } },
-      { kind: "tool_result", name: "Read", text: "def login(email, pwd):\n    pass\n\nclass AuthProvider:\n    pass", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges[0]).toContain("login");
-    expect(r.filesAndChanges[0]).toContain("AuthProvider");
-  });
-
-  it("annotates Go exported functions", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "handler.go" } },
-      { kind: "tool_result", name: "Read", text: "func HandleRequest(w http.ResponseWriter, r *http.Request) {\n\t// ...\n}\n\nfunc internalHelper() {}", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.filesAndChanges[0]).toContain("HandleRequest");
-    // unexported Go functions (lowercase) should not be included
-    expect(r.filesAndChanges[0]).not.toContain("internalHelper");
-  });
-});
-
-describe("type catalog", () => {
-  it("extracts exported signatures from modified files", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts", newText: "export function login(email: string, pwd: string): Promise<Session> {\n  // impl\n}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.typeCatalog.length).toBeGreaterThan(0);
-    expect(r.typeCatalog[0]).toContain("auth.ts");
-    expect(r.typeCatalog.some(l => l.includes("login"))).toBe(true);
-  });
-
-  it("extracts exported signatures from Read results", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "types.ts" } },
-      { kind: "tool_result", name: "Read", text: "export interface User {\n  name: string;\n  email: string;\n}\n\nexport type Session = {\n  token: string;\n  user: User;\n}", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.typeCatalog.length).toBeGreaterThan(0);
-    expect(r.typeCatalog.some(l => l.includes("interface User"))).toBe(true);
-    expect(r.typeCatalog.some(l => l.includes("type Session"))).toBe(true);
-  });
-
-  it("prioritizes modified files over read files", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "read_only.ts" } },
-      { kind: "tool_result", name: "Read", text: "export function readOnly() {}", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "modified.ts", newText: "export function modified() {}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.typeCatalog.length).toBeGreaterThan(0);
-    // Modified file should appear first
-    expect(r.typeCatalog[0]).toContain("modified.ts");
-    expect(r.typeCatalog[0]).toContain("[modified]");
-  });
-
-  it("returns empty for files with no exportable signatures", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "data.json" } },
-      { kind: "tool_result", name: "Read", text: '{ "key": "value" }', isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.typeCatalog).toEqual([]);
-  });
-
-  it("caps signatures per file to 8", () => {
-    const sigs = Array.from({ length: 15 }, (_, i) => `export function fn${i}(): void {}`).join("\n");
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "big.ts" } },
-      { kind: "tool_result", name: "Read", text: sigs, isError: false },
-    ];
-    const r = buildSections({ blocks });
-    // The catalog should have the file but max 8 signatures
-    const sigLines = r.typeCatalog.filter(l => l.startsWith("  "));
-    expect(sigLines.length).toBeLessThanOrEqual(8);
-  });
-});
-
-describe("symbol changes", () => {
-  it("extracts symbol refs from Edit/Write tool calls", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts", newText: "export function login() {}\nexport function verifyToken() {}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.symbolChanges.length).toBeGreaterThan(0);
-    expect(r.symbolChanges.some(s => s.name === "login" && s.file === "auth.ts")).toBe(true);
-    expect(r.symbolChanges.some(s => s.name === "verifyToken" && s.kind === "function")).toBe(true);
-  });
-
-  it("marks read vs modified access correctly", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "types.ts" } },
-      { kind: "tool_result", name: "Read", text: "export interface User {}", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts", newText: "export function login() {}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    const loginSym = r.symbolChanges.find(s => s.name === "login");
-    const userSym = r.symbolChanges.find(s => s.name === "User");
-    expect(loginSym?.access).toBe("modified");
-    expect(userSym?.access).toBe("read");
-  });
-
-  it("deduplicates symbols by name+file", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
-      { kind: "tool_result", name: "Read", text: "export function login() {}", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts", newText: "export function login() {}" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    const loginSymCount = r.symbolChanges.filter(s => s.name === "login" && s.file === "auth.ts").length;
-    expect(loginSymCount).toBe(1);
-  });
-});
-
-describe("format output integration", () => {
-  it("includes Type Catalog section in formatted output between Files and Commits", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_call", name: "Read", args: { file_path: "types.ts" } },
-      { kind: "tool_result", name: "Read", text: "export interface User { name: string; }", isError: false },
-    ];
-    const r = buildSections({ blocks });
-    const { formatSummary } = require("../src/core/format");
-    const output = formatSummary(r);
-    expect(output).toContain("[Type Catalog]");
-    // Should appear after Files And Changes and before Commits
-    const filesIdx = output.indexOf("[Files And Changes]");
-    const typeIdx = output.indexOf("[Type Catalog]");
-    const commitsIdx = output.indexOf("[Commits]");
-    if (filesIdx >= 0 && typeIdx >= 0) expect(filesIdx).toBeLessThan(typeIdx);
-    // Commits may or may not be present
-    if (commitsIdx >= 0 && typeIdx >= 0) expect(typeIdx).toBeLessThan(commitsIdx);
-  });
-
-  it("Type Catalog is volatile (fresh only) on merge", () => {
-    const { compile } = require("../src/core/summarize");
-    const prev = "[Session Goal]\n- goal\n\n[Type Catalog]\n- old-file.ts [read]:\n  export function old()";
-    const fresh = compile({ messages: [], previousSummary: prev });
-    // Type Catalog should be fresh-only, not merged from previous
-    expect(fresh).not.toContain("old-file.ts");
-    expect(fresh).not.toContain("old()");
-  });
-});

package/tests/extract-goals.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { extractGoals } from "../src/extract/goals";
-import type { NormalizedBlock } from "../src/types";
-
-describe("extractGoals", () => {
-  it("returns empty for no blocks", () => {
-    expect(extractGoals([])).toEqual([]);
-  });
-
-  it("returns empty when no user blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "hello" },
-    ];
-    expect(extractGoals(blocks)).toEqual([]);
-  });
-
-  it("extracts first user message lines as goals", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix login bug\nCheck auth flow" },
-    ];
-    const goals = extractGoals(blocks);
-    expect(goals).toEqual(["Fix login bug", "Check auth flow"]);
-  });
-
-  it("takes up to 6 lines from first user block", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "fix the login bug\ncheck auth flow\nupdate the tests\nrefactor utils\nclean up" },
-    ];
-    expect(extractGoals(blocks)).toHaveLength(5);
-  });
-
-  it("ignores subsequent user blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "first goal" },
-      { kind: "assistant", text: "ok" },
-      { kind: "user", text: "second request" },
-    ];
-    expect(extractGoals(blocks)).toEqual(["first goal"]);
-  });
-
-  it("detects scope change with explicit pivot keywords", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix login bug" },
-      { kind: "assistant", text: "ok" },
-      { kind: "user", text: "Actually, instead let's refactor the auth module" },
-    ];
-    const goals = extractGoals(blocks);
-    expect(goals).toContain("Fix login bug");
-    expect(goals).toContain("[Scope change]");
-    expect(goals.some((g) => g.includes("refactor"))).toBe(true);
-  });
-
-  it("detects scope change from new task statements", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix login bug" },
-      { kind: "assistant", text: "done" },
-      { kind: "user", text: "Now implement the user registration flow" },
-    ];
-    const goals = extractGoals(blocks);
-    expect(goals).toContain("[Scope change]");
-  });
-
-  it("keeps latest scope change only", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix login bug" },
-      { kind: "assistant", text: "done" },
-      { kind: "user", text: "Actually, fix the signup page instead" },
-      { kind: "assistant", text: "ok" },
-      { kind: "user", text: "Change of plan, implement password reset" },
-    ];
-    const goals = extractGoals(blocks);
-    const scopeIdx = goals.indexOf("[Scope change]");
-    expect(goals[scopeIdx + 1]).toContain("password reset");
-  });
-
-  it("skips noise short user messages as goals", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "ok" },
-      { kind: "assistant", text: "hello" },
-      { kind: "user", text: "Fix the authentication module" },
-    ];
-    const goals = extractGoals(blocks);
-    expect(goals[0]).toContain("Fix the authentication");
-    expect(goals.some((g) => g === "ok")).toBe(false);
-  });
-});

package/tests/extract-preferences.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { extractPreferences } from "../src/extract/preferences";
-import type { NormalizedBlock } from "../src/types";
-
-describe("extractPreferences", () => {
-  it("returns empty for no blocks", () => {
-    expect(extractPreferences([])).toEqual([]);
-  });
-
-  it("captures preference patterns from user", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "I prefer TypeScript over JavaScript" },
-    ];
-    expect(extractPreferences(blocks).length).toBe(1);
-  });
-
-  it("ignores assistant blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "I always use best practices" },
-    ];
-    expect(extractPreferences(blocks)).toEqual([]);
-  });
-
-  it("captures please use pattern", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "please use bun instead of node" },
-    ];
-    expect(extractPreferences(blocks).length).toBe(1);
-  });
-});