woozlit 2.3.0 → 2.3.1

package/test/session/checkpoint-thresholds.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { parseThreshold, resolveThresholds } from "../../src/session/prune"
-
-describe("parseThreshold", () => {
-  test("parses percentage", () => {
-    expect(parseThreshold("40%", 200_000)).toBe(80_000)
-    expect(parseThreshold("50.5%", 200_000)).toBe(101_000)
-    expect(parseThreshold("100%", 200_000)).toBe(200_000)
-  })
-
-  test("parses kilotokens (K/k)", () => {
-    expect(parseThreshold("100K", 200_000)).toBe(100_000)
-    expect(parseThreshold("100k", 200_000)).toBe(100_000)
-    expect(parseThreshold("1.5K", 200_000)).toBe(1_500)
-  })
-
-  test("parses megatokens (M/m)", () => {
-    expect(parseThreshold("1M", 2_000_000)).toBe(1_000_000)
-    expect(parseThreshold("1.5M", 2_000_000)).toBe(1_500_000)
-    expect(parseThreshold("1.5m", 2_000_000)).toBe(1_500_000)
-  })
-
-  test("parses plain numbers", () => {
-    expect(parseThreshold("50000", 200_000)).toBe(50_000)
-  })
-
-  test("rejects invalid percentages", () => {
-    expect(() => parseThreshold("0%", 200_000)).toThrow()
-    expect(() => parseThreshold("101%", 200_000)).toThrow()
-    expect(() => parseThreshold("-10%", 200_000)).toThrow()
-    expect(() => parseThreshold("abc%", 200_000)).toThrow()
-  })
-
-  test("rejects invalid formats", () => {
-    expect(() => parseThreshold("invalid", 200_000)).toThrow()
-    expect(() => parseThreshold("100G", 200_000)).toThrow()
-    expect(() => parseThreshold("", 200_000)).toThrow()
-  })
-})
-
-describe("resolveThresholds", () => {
-  test("parses and sorts percentages", () => {
-    expect(resolveThresholds(["60%", "40%", "80%"], 200_000)).toEqual([80_000, 120_000, 160_000])
-  })
-
-  test("parses and sorts absolute values", () => {
-    expect(resolveThresholds(["200K", "100K", "150K"], 500_000)).toEqual([100_000, 150_000, 200_000])
-  })
-
-  test("allows mixed percentage and absolute", () => {
-    // window=200K, so 50%=100K, 25%=50K. Duplicate 100K is deduplicated.
-    expect(resolveThresholds(["100K", "50%", "25%"], 200_000)).toEqual([50_000, 100_000])
-  })
-
-  test("deduplicates identical values after parsing", () => {
-    // 50% of 200K = 100K, same as "100K"
-    expect(resolveThresholds(["50%", "100K"], 200_000)).toEqual([100_000])
-  })
-
-  test("clamps a single over-cap threshold to maxAllowed instead of throwing", () => {
-    // window=200K, default reserved=13K → maxAllowed=187K. "190K" exceeds; should clamp to 187K.
-    expect(resolveThresholds(["190K"], 200_000)).toEqual([187_000])
-  })
-
-  test("clamps with explicit reserved override", () => {
-    // window=200K, reserved=5K → maxAllowed=195K. "200K" exceeds; clamps to 195K.
-    expect(resolveThresholds(["200K"], 200_000, 5_000)).toEqual([195_000])
-  })
-
-  test("clamps the first over-cap entry and drops subsequent over-cap entries", () => {
-    // window=200K, default reserved=13K → maxAllowed=187K. ["60K", "190K", "195K"] →
-    //   60K kept; 190K clamped to 187K (first over-cap); 195K dropped.
-    expect(resolveThresholds(["60K", "190K", "195K"], 200_000)).toEqual([60_000, 187_000])
-  })
-
-  test("when ALL thresholds exceed cap, result is a single clamped entry", () => {
-    // ["190K", "195K", "300K"] all > 187K → clamp first (190→187), drop rest.
-    expect(resolveThresholds(["190K", "195K", "300K"], 200_000)).toEqual([187_000])
-  })
-
-  test("clamp respects user-provided order, not sorted order", () => {
-    // ["300K", "190K"]: 300K is the first over-cap → clamps to 187K. 190K is also over-cap → dropped.
-    // (Even though 190K is smaller, it doesn't beat 300K because 300K came first.)
-    expect(resolveThresholds(["300K", "190K"], 200_000)).toEqual([187_000])
-  })
-
-  test("dedupe collapses sub-cap input that happens to equal the clamped value", () => {
-    // window=200K, reserved=5K → maxAllowed=195K. ["195K", "200K"]:
-    //   195K kept (= maxAllowed, allowed); 200K clamped to 195K. After sort+dedupe → [195K].
-    expect(resolveThresholds(["195K", "200K"], 200_000, 5_000)).toEqual([195_000])
-  })
-
-  test("allows threshold exactly equal to maxAllowed (window - reserved)", () => {
-    // window=200K, default reserved=13K → maxAllowed=187K. "187K" is exactly at the cap, allowed.
-    expect(resolveThresholds(["187K"], 200_000)).toEqual([187_000])
-  })
-
-  test("throws when window is too small", () => {
-    expect(() => resolveThresholds(["1K"], 10_000)).toThrow(/too small/)
-  })
-
-  test("returns empty array for empty input", () => {
-    expect(resolveThresholds([], 200_000)).toEqual([])
-  })
-
-  test("defaults (40%, 60%, 80%) work on common window sizes", () => {
-    expect(resolveThresholds(["40%", "60%", "80%"], 200_000)).toEqual([80_000, 120_000, 160_000])
-    expect(resolveThresholds(["40%", "60%", "80%"], 1_000_000)).toEqual([400_000, 600_000, 800_000])
-  })
-
-  test("v7 defaults (30%, 60%, 90%) on 200K context produce [60K, 120K, 180K] (F5)", () => {
-    expect(resolveThresholds(["30%", "60%", "90%"], 200_000)).toEqual([60_000, 120_000, 180_000])
-  })
-
-  test("default reserved is 13K", () => {
-    // No `reserved` arg → CHECKPOINT_RESERVED kicks in. windowSize=200K, default reserved=13K → maxAllowed=187K.
-    // 187K is allowed (= maxAllowed); 188K would be over.
-    expect(resolveThresholds(["187K"], 200_000)).toEqual([187_000])
-  })
-})

package/test/session/checkpoint-validator.test.ts

@@ -1,189 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { validateSnapshot, TOPIC_MAX_CHARS, validateLearning, validateMemory, validateProgress, validateBudget, validateBudgetSections } from "../../src/session/checkpoint-validator"
-import { CHECKPOINT_SECTION_BUDGETS } from "../../src/session/checkpoint-templates"
-
-describe("validateSnapshot", () => {
-  const valid = `Topic: parseDecl handles forward declarations in unifier
-
-### Execution context
-(none)
-
-### Live resources
-(none)
-
-### Session metadata
-(none)
-`
-
-  test("valid snapshot passes", () => {
-    expect(validateSnapshot(valid, "snapshot-001.md")).toEqual([])
-  })
-
-  test("missing Topic line errors", () => {
-    const body = valid.replace(/^Topic:.*\n/, "")
-    const v = validateSnapshot(body, "snapshot-001.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "topic-missing", severity: "error" }))
-  })
-
-  test("Topic > 80 chars warns", () => {
-    const long = "x".repeat(TOPIC_MAX_CHARS + 10)
-    const body = valid.replace(/^Topic:.*$/m, `Topic: ${long}`)
-    const v = validateSnapshot(body, "snapshot-001.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "topic-too-long", severity: "warn" }))
-  })
-
-  test("# Checkpoint #N first line errors", () => {
-    const body = `# Checkpoint #007\n\n${valid}`
-    const v = validateSnapshot(body, "snapshot-007.md")
-    expect(v).toContainEqual(
-      expect.objectContaining({ rule: "topic-anti-pattern-checkpoint-header", severity: "error" }),
-    )
-  })
-
-  test("missing required sub-section errors", () => {
-    const body = valid.replace("### Live resources\n(none)\n\n", "")
-    const v = validateSnapshot(body, "snapshot-001.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "subsection-missing", severity: "error" }))
-  })
-
-  test("sub-sections out of order errors", () => {
-    const reordered = `Topic: ok
-
-### Live resources
-(none)
-
-### Execution context
-(none)
-
-### Session metadata
-(none)
-`
-    const v = validateSnapshot(reordered, "snapshot-001.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "subsection-out-of-order", severity: "error" }))
-  })
-})
-
-describe("validateLearning", () => {
-  const valid = `Topic: unifier handles forward declarations
-
-### Discovered
-- forward declarations are inert until resolved
-  Why: parser emits placeholder TokenKind.Forward
-  How to apply: when seeing TokenKind.Forward, look up the resolved sibling
-
-### Dead ends
-- (none)
-`
-
-  test("valid passes with empty priorTitles", () => {
-    expect(validateLearning(valid, "learning-001.md", new Set())).toEqual([])
-  })
-
-  test("duplicate Discovered title vs prior errors", () => {
-    const prior = new Set(["forward declarations are inert until resolved"])
-    const v = validateLearning(valid, "learning-005.md", prior)
-    expect(v).toContainEqual(
-      expect.objectContaining({ rule: "discovered-duplicate-title", severity: "error" }),
-    )
-  })
-
-  test("Discovered missing Why warns", () => {
-    const body = valid.replace(/  Why:.*\n/, "")
-    const v = validateLearning(body, "learning-001.md", new Set())
-    expect(v).toContainEqual(
-      expect.objectContaining({ rule: "discovered-missing-why", severity: "warn" }),
-    )
-  })
-
-  test("Discovered missing How to apply warns", () => {
-    const body = valid.replace(/  How to apply:.*\n/, "")
-    const v = validateLearning(body, "learning-001.md", new Set())
-    expect(v).toContainEqual(
-      expect.objectContaining({ rule: "discovered-missing-how-to-apply", severity: "warn" }),
-    )
-  })
-
-  test("missing Topic + missing sections still flagged", () => {
-    const body = `### Discovered\n- foo\n  Why: x\n  How to apply: y\n\n### Dead ends\n(none)\n`
-    const v = validateLearning(body, "learning-001.md", new Set())
-    expect(v).toContainEqual(expect.objectContaining({ rule: "topic-missing" }))
-  })
-
-  test("Discovered with (none) placeholder yields no entry violations", () => {
-    const body = `Topic: ok\n\n### Discovered\n(none)\n\n### Dead ends\n(none)\n`
-    expect(validateLearning(body, "learning-001.md", new Set())).toEqual([])
-  })
-})
-
-describe("validateMemory", () => {
-  const body = `# Pinned
-
-## Directives
-- D1: prefer functional methods
-- D5: tests must hit a real database
-`
-
-  test("valid + no expected revisions passes", () => {
-    expect(validateMemory(body, [])).toEqual([])
-  })
-
-  test("expected revision text present passes", () => {
-    expect(validateMemory(body, [{ id: "D1", expectedText: "functional methods" }])).toEqual([])
-  })
-
-  test("expected revision text missing errors", () => {
-    const v = validateMemory(body, [{ id: "D1", expectedText: "for-of exception" }])
-    expect(v).toContainEqual(expect.objectContaining({ rule: "directive-not-revised", severity: "error" }))
-  })
-})
-
-describe("validateProgress", () => {
-  test("concrete Next passes", () => {
-    const body = `## ckpt #5\n- Next: implement parseDecl(line 181)\n`
-    expect(validateProgress(body, "progress.md")).toEqual([])
-  })
-
-  test("Next: continue warns", () => {
-    const body = `## ckpt #5\n- Next: continue\n`
-    const v = validateProgress(body, "progress.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "next-filler", severity: "warn" }))
-  })
-
-  test("Next: keep going warns", () => {
-    const body = `## ckpt #5\n- Next: keep going\n`
-    const v = validateProgress(body, "progress.md")
-    expect(v).toContainEqual(expect.objectContaining({ rule: "next-filler", severity: "warn" }))
-  })
-})
-
-describe("validateBudget", () => {
-  test("passes when under budget", () => {
-    const violations = validateBudget("short content", 2000, "snapshot.md")
-    expect(violations).toEqual([])
-  })
-
-  test("emits extract-required when over budget", () => {
-    const longContent = "x ".repeat(5000) // ~2500 tokens at 4 chars per token
-    const violations = validateBudget(longContent, 2000, "snapshot.md")
-    expect(violations).toHaveLength(1)
-    expect(violations[0].severity).toBe("extract-required")
-    expect(violations[0].rule).toBe("budget-exceeded")
-    expect(violations[0].detail).toMatch(/tokens > 2000/)
-  })
-
-  test("exact budget boundary passes", () => {
-    // 8000 chars / 4 = 2000 tokens exactly
-    const content = "a".repeat(8000)
-    const violations = validateBudget(content, 2000, "snapshot.md")
-    expect(violations).toEqual([])
-  })
-})
-
-describe("validateBudgetSections", () => {
-  test("validateBudgetSections flags over-budget §7 in checkpoint.md", () => {
-    const big = "## §7 Discovered knowledge (cross-task)\n_instr_\n" + "- entry ".repeat(2000)
-    const violations = validateBudgetSections(big, CHECKPOINT_SECTION_BUDGETS, "checkpoint.md")
-    expect(violations.some((v) => v.detail.includes("§7"))).toBe(true)
-  })
-})
-