akm-cli 0.7.0 → 0.7.1

package/dist/tests/remember-frontmatter.test.js

@@ -1,378 +0,0 @@
-/**
- * Tests for `akm remember` frontmatter support (issue #169).
- *
- * Covers:
- * - CLI arg round-trip (--tag, --expires, --source)
- * - --auto heuristics (code, subjective, source, observed_at)
- * - --enrich with mocked chatCompletion (success + failure)
- * - Required-field rejection before any file write
- * - --expires duration → ISO date computation
- * - Zero-flag remember still works (no frontmatter written)
- * - memoryMdRenderer.extractMetadata populates StashEntry fields
- */
-import { afterEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { parseFrontmatter } from "../src/core/frontmatter";
-import { buildFileContext, buildRenderContext } from "../src/indexer/file-context";
-import { memoryMdRenderer } from "../src/output/renderers";
-// ── CLI harness ──────────────────────────────────────────────────────────────
-const CLI = path.join(__dirname, "..", "src", "cli.ts");
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function runCli(args, options) {
-    const stashDir = options?.stashDir ?? makeTempDir("akm-rmfm-stash-");
-    const xdgCache = makeTempDir("akm-rmfm-cache-");
-    const xdgConfig = makeTempDir("akm-rmfm-config-");
-    const result = spawnSync("bun", [CLI, ...args], {
-        encoding: "utf8",
-        timeout: 30_000,
-        input: options?.input,
-        env: {
-            ...process.env,
-            AKM_STASH_DIR: stashDir,
-            XDG_CACHE_HOME: xdgCache,
-            XDG_CONFIG_HOME: xdgConfig,
-        },
-    });
-    return { stashDir, result };
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-// ── Zero-flag path (backward compatibility) ──────────────────────────────────
-describe("zero-flag remember", () => {
-    test("writes bare memory with no frontmatter", () => {
-        const { stashDir, result } = runCli(["remember", "Deployment needs VPN access"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        // No frontmatter delimiter present
-        expect(content.startsWith("---")).toBe(false);
-        expect(content).toContain("Deployment needs VPN access");
-        expect(stashDir).toBeTruthy();
-    });
-    test("writes bare memory when reading from stdin", () => {
-        const { result } = runCli(["remember"], { input: "VPN needed for staging deploys" });
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        expect(content.startsWith("---")).toBe(false);
-    });
-    test("reads stdin when --format json is present", () => {
-        const { result } = runCli(["remember", "--name", "from-stdin", "--format", "json"], { input: "stdin body" });
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        expect(fs.readFileSync(json.path, "utf8")).toContain("stdin body");
-        expect(fs.readFileSync(json.path, "utf8")).not.toContain("\njson");
-    });
-});
-// ── CLI args (Mode 1) ────────────────────────────────────────────────────────
-describe("remember --tag", () => {
-    test("single --tag writes frontmatter with tags array", () => {
-        const { result } = runCli(["remember", "VPN required for staging", "--tag", "ops"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.tags).toEqual(["ops"]);
-        expect(parsed.content).toContain("VPN required for staging");
-    });
-    test("multiple --tag flags write all tags", () => {
-        const { result } = runCli(["remember", "VPN required for staging", "--tag", "ops", "--tag", "networking"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.tags).toEqual(["ops", "networking"]);
-    });
-});
-describe("remember --source", () => {
-    test("--source stores a URL as-is", () => {
-        const { result } = runCli([
-            "remember",
-            "Read the deployment guide",
-            "--tag",
-            "docs",
-            "--source",
-            "https://example.com/deploy",
-        ]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.source).toBe("https://example.com/deploy");
-    });
-    test("--source stores an asset ref", () => {
-        const { result } = runCli(["remember", "Deploy skill requires VPN", "--tag", "ops", "--source", "skill:deploy"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.source).toBe("skill:deploy");
-    });
-});
-describe("remember --expires", () => {
-    test("--expires 30d resolves to a future ISO date ~30 days from now", () => {
-        const before = new Date();
-        const { result } = runCli(["remember", "Temp access token valid 30 days", "--tag", "security", "--expires", "30d"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        const expires = parsed.data.expires;
-        expect(expires).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        // Should be approximately 30 days from now (within 1-day margin)
-        const expiresDate = new Date(expires);
-        const expectedMin = new Date(before.getTime() + 29 * 24 * 60 * 60 * 1000);
-        const expectedMax = new Date(before.getTime() + 31 * 24 * 60 * 60 * 1000);
-        expect(expiresDate >= expectedMin).toBe(true);
-        expect(expiresDate <= expectedMax).toBe(true);
-    });
-    test("--expires 12h resolves to a future ISO date ~12h from now", () => {
-        const { result } = runCli(["remember", "Short-lived credential", "--tag", "security", "--expires", "12h"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.expires).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    });
-    test("--expires 6m resolves to a future ISO date ~6 months from now", () => {
-        const { result } = runCli(["remember", "Long-term access", "--tag", "access", "--expires", "6m"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        const expires = parsed.data.expires;
-        expect(expires).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        const expiresDate = new Date(expires);
-        const expectedMin = new Date(Date.now() + 170 * 24 * 60 * 60 * 1000); // ~5.7 months
-        const expectedMax = new Date(Date.now() + 185 * 24 * 60 * 60 * 1000); // ~6.2 months
-        expect(expiresDate >= expectedMin).toBe(true);
-        expect(expiresDate <= expectedMax).toBe(true);
-    });
-    test("invalid --expires format produces an error", () => {
-        const { result } = runCli(["remember", "Some note", "--tag", "misc", "--expires", "invalid"]);
-        expect(result.status).toBe(2);
-        const json = JSON.parse(result.stderr);
-        expect(json.error).toContain("Invalid --expires format");
-    });
-});
-// ── Required-field rejection (before file write) ─────────────────────────────
-describe("required-field rejection", () => {
-    test("--source without --tag rejects with missing-fields error before writing", () => {
-        const { stashDir, result } = runCli(["remember", "Some note", "--source", "https://example.com"]);
-        expect(result.status).toBe(2);
-        const json = JSON.parse(result.stderr);
-        expect(json.error).toContain("tags");
-        expect(json.error).toContain("--tag");
-        // Confirm no file was written
-        const memoriesDir = path.join(stashDir, "memories");
-        const written = fs.existsSync(memoriesDir) && fs.readdirSync(memoriesDir).length > 0;
-        expect(written).toBe(false);
-    });
-    test("--expires without --tag rejects with missing-fields error before writing", () => {
-        const { stashDir, result } = runCli(["remember", "Some note", "--expires", "30d"]);
-        expect(result.status).toBe(2);
-        const json = JSON.parse(result.stderr);
-        expect(json.error).toContain("tags");
-        const memoriesDir = path.join(stashDir, "memories");
-        const written = fs.existsSync(memoriesDir) && fs.readdirSync(memoriesDir).length > 0;
-        expect(written).toBe(false);
-    });
-});
-// ── --auto heuristics (Mode 2) ───────────────────────────────────────────────
-describe("remember --auto", () => {
-    test("body with fenced code block gets tag 'code'", () => {
-        const body = "Remember this pattern:\n```ts\nconst x = 1;\n```";
-        const { result } = runCli(["remember", body, "--auto"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        const tags = parsed.data.tags;
-        expect(tags).toContain("code");
-    });
-    test("body with URL gets source set automatically", () => {
-        const body = "Found this resource https://example.com/guide useful for ops";
-        const { result } = runCli(["remember", body, "--auto", "--tag", "docs"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.source).toBe("https://example.com/guide");
-    });
-    test("body with first-person pronoun gets subjective: true", () => {
-        // Must supply --tag because heuristics add subjective but not tags for plain text.
-        const body = "I noticed that staging requires VPN every time";
-        const { result } = runCli(["remember", body, "--auto", "--tag", "ops"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.subjective).toBe(true);
-        expect(parsed.data.tags).toContain("ops");
-    });
-    test("body with ISO date gets observed_at set", () => {
-        const body = "The outage happened on 2026-01-15 and we fixed it quickly";
-        const { result } = runCli(["remember", body, "--auto"]);
-        // Will fail required-field check if no tags derived from the body
-        // Force a tag to ensure we get through
-        const { result: r2 } = runCli(["remember", body, "--auto", "--tag", "ops"]);
-        expect(r2.status).toBe(0);
-        const json = JSON.parse(r2.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.observed_at).toBe("2026-01-15");
-        void result; // suppress unused variable warning
-    });
-    test("--auto without any tags from heuristics or CLI still writes the memory", () => {
-        // Plain text body — no code block, no URL. Heuristics won't derive any tags.
-        const { result } = runCli(["remember", "Plain text note without any tags derivable", "--auto"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        expect(fs.existsSync(json.path)).toBe(true);
-    });
-    test("--auto + explicit --tag satisfies required-field check", () => {
-        const body = "No special content here";
-        const { result } = runCli(["remember", body, "--auto", "--tag", "misc"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        expect(parsed.data.tags).toContain("misc");
-    });
-    test("--source CLI arg takes priority over auto-detected URL", () => {
-        const body = "See https://example.com/docs for reference";
-        const { result } = runCli(["remember", body, "--auto", "--tag", "docs", "--source", "explicit:source"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        // CLI --source wins over auto-detected URL
-        expect(parsed.data.source).toBe("explicit:source");
-    });
-});
-// ── memoryMdRenderer.extractMetadata ─────────────────────────────────────────
-/** A static MatchResult for memory-md (avoids calling runMatchers and null assertions). */
-const MEMORY_MATCH = { type: "memory", specificity: 10, renderer: "memory-md" };
-describe("memoryMdRenderer.extractMetadata", () => {
-    const createdTmpDirs = [];
-    afterEach(() => {
-        for (const dir of createdTmpDirs.splice(0)) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    function writeTmpMemory(content) {
-        const stashRoot = fs.mkdtempSync(path.join(os.tmpdir(), "akm-mem-renderer-"));
-        createdTmpDirs.push(stashRoot);
-        const memoriesDir = path.join(stashRoot, "memories");
-        fs.mkdirSync(memoriesDir, { recursive: true });
-        const filePath = path.join(memoriesDir, "test-memory.md");
-        fs.writeFileSync(filePath, content, "utf8");
-        return { filePath, stashRoot };
-    }
-    test("populates tags from frontmatter", () => {
-        const { filePath, stashRoot } = writeTmpMemory("---\ntags: [ops, networking]\n---\nDeployment needs VPN access\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        memoryMdRenderer.extractMetadata?.(entry, renderCtx);
-        expect(entry.tags).toContain("ops");
-        expect(entry.tags).toContain("networking");
-    });
-    test("populates description from frontmatter", () => {
-        const { filePath, stashRoot } = writeTmpMemory("---\ndescription: VPN required for staging deploys\ntags: [ops]\n---\nBody content\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        memoryMdRenderer.extractMetadata?.(entry, renderCtx);
-        expect(entry.description).toBe("VPN required for staging deploys");
-    });
-    test("populates searchHints with source, observed_at, expires, subjective", () => {
-        const { filePath, stashRoot } = writeTmpMemory("---\ntags: [ops]\nsource: skill:deploy\nobserved_at: 2026-01-15\nexpires: 2026-04-15\nsubjective: true\n---\nVPN needed\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        memoryMdRenderer.extractMetadata?.(entry, renderCtx);
-        expect(entry.searchHints).toBeDefined();
-        expect(entry.searchHints).toContain("skill:deploy");
-        expect(entry.searchHints).toContain("observed_at:2026-01-15");
-        expect(entry.searchHints).toContain("expires:2026-04-15");
-        expect(entry.searchHints).toContain("subjective");
-    });
-    test("observed_at falls back to file mtime when not in frontmatter", () => {
-        const { filePath, stashRoot } = writeTmpMemory("---\ntags: [ops]\n---\nSome memory without observed_at\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        memoryMdRenderer.extractMetadata?.(entry, renderCtx);
-        // Should have an observed_at hint derived from mtime
-        const mtimeHint = (entry.searchHints ?? []).find((h) => h.startsWith("observed_at:"));
-        expect(mtimeHint).toBeDefined();
-        // The mtime-based date should be a valid ISO date
-        const dateStr = mtimeHint?.slice("observed_at:".length);
-        expect(dateStr).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    });
-    test("works for bare memory with no frontmatter (no crash)", () => {
-        const { filePath, stashRoot } = writeTmpMemory("Just a plain memory without any frontmatter.\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        // Should not throw
-        expect(() => memoryMdRenderer.extractMetadata?.(entry, renderCtx)).not.toThrow();
-        // mtime fallback should still fire
-        const mtimeHint = (entry.searchHints ?? []).find((h) => h.startsWith("observed_at:"));
-        expect(mtimeHint).toBeDefined();
-    });
-    test("block-sequence tags in frontmatter are parsed correctly", () => {
-        const { filePath, stashRoot } = writeTmpMemory("---\ntags:\n- ops\n- networking\n- deploy\n---\nVPN required\n");
-        const ctx = buildFileContext(stashRoot, filePath);
-        const entry = { name: "test-memory", type: "memory" };
-        const renderCtx = buildRenderContext(ctx, MEMORY_MATCH, [stashRoot]);
-        memoryMdRenderer.extractMetadata?.(entry, renderCtx);
-        expect(entry.tags).toContain("ops");
-        expect(entry.tags).toContain("networking");
-        expect(entry.tags).toContain("deploy");
-    });
-});
-// ── --enrich (Mode 3) — mocked ───────────────────────────────────────────────
-// These tests directly exercise the heuristic and enrichment helpers by calling
-// the CLI with a mock LLM config. Since we cannot easily intercept the dynamic
-// import inside the CLI process, we test the LLM enrichment path via integration
-// against a non-existent endpoint and verify the graceful-degradation behaviour.
-describe("remember --enrich graceful degradation", () => {
-    test("when no LLM is configured, --enrich emits warning but still fails if no tags", () => {
-        // No LLM configured in the temp config dir — should warn and return empty tags
-        const { result } = runCli(["remember", "Some note about ops", "--enrich"]);
-        // Will fail because enrichment produces no tags and no CLI tags given.
-        // stderr may contain a warning line followed by a multi-line JSON error block.
-        if (result.status !== 0) {
-            // Extract the JSON portion (from first '{' to end of stderr)
-            const jsonStart = result.stderr.indexOf("{");
-            expect(jsonStart).toBeGreaterThanOrEqual(0);
-            const jsonStr = result.stderr.slice(jsonStart);
-            const json = JSON.parse(jsonStr);
-            expect(json.error).toContain("tags");
-        }
-        // Either path is acceptable: rejection (no tags) or success (if enrichment happened to work)
-    });
-    test("--enrich with --tag satisfies required-field check even if LLM fails", () => {
-        // Providing --tag means we don't depend on LLM for the required field
-        const { result } = runCli(["remember", "Some note", "--enrich", "--tag", "misc"]);
-        expect(result.status).toBe(0);
-        const json = JSON.parse(result.stdout);
-        const content = fs.readFileSync(json.path, "utf8");
-        const parsed = parseFrontmatter(content);
-        // At minimum, the --tag value must be present
-        expect(parsed.data.tags).toContain("misc");
-    });
-});

package/dist/tests/remember-unit.test.js

@@ -1,123 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parse as yamlParse } from "yaml";
-import { buildMemoryFrontmatter, parseDuration, runAutoHeuristics } from "../src/commands/remember";
-describe("parseDuration", () => {
-    test("parses days", () => {
-        expect(parseDuration("30d")).toBe(30 * 24 * 60 * 60 * 1000);
-        expect(parseDuration("1d")).toBe(24 * 60 * 60 * 1000);
-    });
-    test("parses hours", () => {
-        expect(parseDuration("12h")).toBe(12 * 60 * 60 * 1000);
-    });
-    test("parses months as 30-day approximation", () => {
-        expect(parseDuration("6m")).toBe(6 * 30 * 24 * 60 * 60 * 1000);
-    });
-    test("rejects invalid format", () => {
-        expect(() => parseDuration("forever")).toThrow(/Invalid --expires/);
-        expect(() => parseDuration("30")).toThrow(/Invalid --expires/);
-        expect(() => parseDuration("d30")).toThrow(/Invalid --expires/);
-    });
-    test("trims whitespace and accepts uppercase units", () => {
-        expect(parseDuration(" 7D ")).toBe(7 * 24 * 60 * 60 * 1000);
-    });
-});
-describe("buildMemoryFrontmatter — YAML injection guard", () => {
-    test("emits a parseable, well-formed YAML block for a normal record", () => {
-        const out = buildMemoryFrontmatter({
-            description: "VPN required for staging deploys",
-            tags: ["ops", "networking"],
-            source: "skill:deploy",
-            observed_at: "2026-04-24",
-            expires: "2026-07-23",
-            subjective: false,
-        });
-        expect(out.startsWith("---\n")).toBe(true);
-        expect(out.endsWith("\n---")).toBe(true);
-        const inner = out.replace(/^---\n/, "").replace(/\n---$/, "");
-        const parsed = yamlParse(inner);
-        expect(parsed.description).toBe("VPN required for staging deploys");
-        expect(parsed.tags).toEqual(["ops", "networking"]);
-        expect(parsed.source).toBe("skill:deploy");
-        expect(parsed.observed_at).toBe("2026-04-24");
-        expect(parsed.expires).toBe("2026-07-23");
-        expect(parsed.subjective).toBeUndefined();
-    });
-    test("preserves subjective: true when set", () => {
-        const out = buildMemoryFrontmatter({ tags: ["x"], subjective: true });
-        const parsed = yamlParse(out.replace(/^---\n/, "").replace(/\n---$/, ""));
-        expect(parsed.subjective).toBe(true);
-    });
-    test("description containing newlines + forged tags cannot inject extra keys", () => {
-        // Pre-fix this string would have been emitted as:
-        //   description: nice
-        //   tags: [pwned]
-        // …producing two real frontmatter keys. With yaml.stringify it is
-        // safely quoted as a single string value.
-        const malicious = "nice\ntags: [pwned]";
-        const out = buildMemoryFrontmatter({ description: malicious, tags: ["expected"] });
-        const parsed = yamlParse(out.replace(/^---\n/, "").replace(/\n---$/, ""));
-        expect(parsed.tags).toEqual(["expected"]);
-        expect(parsed.description).toBe(malicious);
-        expect(parsed.pwned).toBeUndefined();
-    });
-    test("source containing YAML metacharacters round-trips intact", () => {
-        const tricky = "https://example.com/path?q=#anchor: { x: y }";
-        const out = buildMemoryFrontmatter({ tags: ["ops"], source: tricky });
-        const parsed = yamlParse(out.replace(/^---\n/, "").replace(/\n---$/, ""));
-        expect(parsed.source).toBe(tricky);
-    });
-    test("omits empty fields", () => {
-        const out = buildMemoryFrontmatter({ tags: [] });
-        expect(out).toBe("---\n---");
-    });
-    test("omits whitespace-only string fields", () => {
-        const out = buildMemoryFrontmatter({ description: "   ", tags: ["x"] });
-        const parsed = yamlParse(out.replace(/^---\n/, "").replace(/\n---$/, ""));
-        expect(parsed.description).toBeUndefined();
-        expect(parsed.tags).toEqual(["x"]);
-    });
-});
-describe("runAutoHeuristics", () => {
-    test("detects a fenced code block as the `code` tag", () => {
-        const result = runAutoHeuristics("Found this:\n```sh\necho hi\n```");
-        expect(result.tags).toContain("code");
-    });
-    test("does not add `code` tag when no fenced block present", () => {
-        const result = runAutoHeuristics("plain prose, no code");
-        expect(result.tags).not.toContain("code");
-    });
-    test("flags first-person pronouns as subjective (lowercase + capital I)", () => {
-        expect(runAutoHeuristics("I think we should ship").subjective).toBe(true);
-        expect(runAutoHeuristics("we shipped my favorite feature").subjective).toBe(true);
-        expect(runAutoHeuristics("our team agreed").subjective).toBe(true);
-    });
-    test("non-first-person prose is not flagged subjective", () => {
-        expect(runAutoHeuristics("The cluster restarted at 3am.").subjective).toBeUndefined();
-        // Capitalised My/Our at sentence start currently isn't matched —
-        // documented as case-sensitive. If we widen this in a future
-        // patch, update this test to reflect the new behaviour.
-        expect(runAutoHeuristics("My take is...").subjective).toBeUndefined();
-    });
-    test("captures the first URL as source", () => {
-        const result = runAutoHeuristics("see https://example.com/docs and also https://example.org");
-        expect(result.source).toBe("https://example.com/docs");
-    });
-    test("captures an explicit ISO date as observed_at", () => {
-        const result = runAutoHeuristics("Incident on 2026-04-24, resolved.");
-        expect(result.observed_at).toBe("2026-04-24");
-    });
-    test("interprets `today` as observed_at", () => {
-        const result = runAutoHeuristics("today the deploy failed");
-        expect(result.observed_at).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        // Should be today's date (loose check — no timezone drift assertions)
-        const today = new Date().toISOString().slice(0, 10);
-        expect(result.observed_at).toBe(today);
-    });
-    test("handles plain prose without any signals", () => {
-        const result = runAutoHeuristics("Just a regular note about something boring.");
-        expect(result.tags).toEqual([]);
-        expect(result.source).toBeUndefined();
-        expect(result.observed_at).toBeUndefined();
-        expect(result.subjective).toBeUndefined();
-    });
-});