@creativeintelligence/abbie 0.1.4 → 0.1.6

package/src/lib/session-artifacts.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SessionArtifactStore } from "./session-artifacts.js";
-
-describe("SessionArtifactStore", () => {
-  it("persists start artifacts and reads them back", () => {
-    const dir = mkdtempSync(join(tmpdir(), "abbie-artifacts-"));
-
-    try {
-      const promptPath = join(dir, "prompt.md");
-      writeFileSync(promptPath, "Implement feature X", "utf-8");
-
-      const store = new SessionArtifactStore(dir);
-      store.saveStart({
-        sessionId: "sess_1",
-        agent: "codex",
-        project: "abbie",
-        status: "running",
-        startedAt: "2026-02-06T00:00:00.000Z",
-        goal: "Ship ABBIE-58",
-        promptPath,
-      });
-
-      const artifact = store.get("sess_1");
-      expect(artifact).toBeDefined();
-      expect(artifact?.agent).toBe("codex");
-      expect(artifact?.project).toBe("abbie");
-      expect(artifact?.promptExcerpt).toContain("Implement feature X");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("marks completion and captures output excerpts", () => {
-    const dir = mkdtempSync(join(tmpdir(), "abbie-artifacts-"));
-
-    try {
-      const outputPath = join(dir, "output.json");
-      writeFileSync(outputPath, '{"status":"success","summary":"done"}', "utf-8");
-
-      const store = new SessionArtifactStore(dir);
-      store.saveStart({
-        sessionId: "sess_2",
-        agent: "claude",
-        project: "abbie",
-        status: "running",
-        startedAt: "2026-02-06T00:00:00.000Z",
-      });
-      store.markComplete("sess_2", {
-        status: "completed",
-        endedAt: "2026-02-06T00:05:00.000Z",
-        exitCode: 0,
-        outputPath,
-      });
-
-      const artifact = store.get("sess_2");
-      expect(artifact?.status).toBe("completed");
-      expect(artifact?.exitCode).toBe(0);
-      expect(artifact?.outputExcerpt).toContain('"status":"success"');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("builds controlled reinjection context", () => {
-    const dir = mkdtempSync(join(tmpdir(), "abbie-artifacts-"));
-
-    try {
-      const promptPath = join(dir, "prompt.md");
-      const outputPath = join(dir, "output.json");
-      writeFileSync(promptPath, "Prior prompt", "utf-8");
-      writeFileSync(outputPath, '{"summary":"Prior output"}', "utf-8");
-
-      const store = new SessionArtifactStore(dir);
-      store.saveStart({
-        sessionId: "sess_3",
-        agent: "codex",
-        project: "abbie",
-        status: "running",
-        startedAt: "2026-02-06T00:00:00.000Z",
-        goal: "Prior goal",
-        promptPath,
-        outputPath,
-      });
-      store.markComplete("sess_3", {
-        status: "completed",
-        outputPath,
-      });
-
-      const summary = store.buildReinjectionContext(["sess_3"], "summary");
-      expect(summary).toContain("<prior_session_artifacts");
-      expect(summary).toContain('<session id="sess_3"');
-      expect(summary).toContain("<output_excerpt>");
-
-      const full = store.buildReinjectionContext(["sess_3"], "full");
-      expect(full).toContain("Prior prompt");
-      expect(full).toContain("Prior output");
-
-      const off = store.buildReinjectionContext(["sess_3"], "off");
-      expect(off).toBe("");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/lib/session-artifacts.ts

@@ -1,193 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export type ReinjectMode = "off" | "summary" | "full";
-export type SessionArtifactStatus = "running" | "completed" | "failed" | "stopped";
-
-export interface SessionArtifact {
-  sessionId: string;
-  agent: string;
-  project: string;
-  status: SessionArtifactStatus;
-  startedAt: string;
-  endedAt?: string;
-  issue?: string;
-  traceId?: string;
-  goal?: string;
-  promptPath?: string;
-  outputPath?: string;
-  promptExcerpt?: string;
-  outputExcerpt?: string;
-  exitCode?: number;
-  updatedAt: string;
-}
-
-function escapeXml(value: string): string {
-  return value
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&apos;");
-}
-
-function truncate(value: string, max: number): string {
-  if (value.length <= max) return value;
-  return `${value.slice(0, Math.max(0, max - 1))}…`;
-}
-
-function readText(path: string | undefined): string | undefined {
-  if (!path || !existsSync(path)) return undefined;
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return undefined;
-  }
-}
-
-function readExcerpt(path: string | undefined, maxChars: number): string | undefined {
-  const text = readText(path);
-  if (!text) return undefined;
-  return truncate(text.trim(), maxChars);
-}
-
-export class SessionArtifactStore {
-  private basePath: string;
-
-  constructor(basePath?: string) {
-    this.basePath = basePath || join(homedir(), ".abbie", "session-artifacts");
-    if (!existsSync(this.basePath)) {
-      mkdirSync(this.basePath, { recursive: true });
-    }
-  }
-
-  private artifactPath(sessionId: string): string {
-    return join(this.basePath, `${sessionId}.json`);
-  }
-
-  private write(artifact: SessionArtifact): void {
-    const path = this.artifactPath(artifact.sessionId);
-    writeFileSync(path, JSON.stringify(artifact, null, 2));
-  }
-
-  get(sessionId: string): SessionArtifact | undefined {
-    const path = this.artifactPath(sessionId);
-    if (!existsSync(path)) return undefined;
-    try {
-      return JSON.parse(readFileSync(path, "utf-8")) as SessionArtifact;
-    } catch {
-      return undefined;
-    }
-  }
-
-  saveStart(opts: {
-    sessionId: string;
-    agent: string;
-    project: string;
-    status: SessionArtifactStatus;
-    startedAt: string;
-    issue?: string;
-    traceId?: string;
-    goal?: string;
-    promptPath?: string;
-    outputPath?: string;
-  }): void {
-    const now = new Date().toISOString();
-    this.write({
-      sessionId: opts.sessionId,
-      agent: opts.agent,
-      project: opts.project,
-      status: opts.status,
-      startedAt: opts.startedAt,
-      issue: opts.issue,
-      traceId: opts.traceId,
-      goal: opts.goal,
-      promptPath: opts.promptPath,
-      outputPath: opts.outputPath,
-      promptExcerpt: readExcerpt(opts.promptPath, 1200),
-      updatedAt: now,
-    });
-  }
-
-  markComplete(
-    sessionId: string,
-    opts: {
-      status: SessionArtifactStatus;
-      endedAt?: string;
-      exitCode?: number;
-      outputPath?: string;
-    },
-  ): void {
-    const existing = this.get(sessionId);
-    const now = new Date().toISOString();
-    const resolvedOutputPath = opts.outputPath ?? existing?.outputPath;
-
-    const artifact: SessionArtifact = {
-      sessionId,
-      agent: existing?.agent ?? "unknown",
-      project: existing?.project ?? "unknown",
-      status: opts.status,
-      startedAt: existing?.startedAt ?? now,
-      endedAt: opts.endedAt ?? now,
-      issue: existing?.issue,
-      traceId: existing?.traceId,
-      goal: existing?.goal,
-      promptPath: existing?.promptPath,
-      outputPath: resolvedOutputPath,
-      promptExcerpt: existing?.promptExcerpt,
-      outputExcerpt: readExcerpt(resolvedOutputPath, 4000),
-      exitCode: opts.exitCode ?? existing?.exitCode,
-      updatedAt: now,
-    };
-
-    this.write(artifact);
-  }
-
-  buildReinjectionContext(sessionIds: string[], mode: ReinjectMode): string {
-    if (mode === "off" || sessionIds.length === 0) return "";
-
-    const unique = [...new Set(sessionIds.map((id) => id.trim()).filter((id) => id.length > 0))];
-    if (unique.length === 0) return "";
-
-    const blocks: string[] = [];
-
-    for (const sessionId of unique) {
-      const artifact = this.get(sessionId);
-      if (!artifact) continue;
-
-      const promptContent =
-        mode === "full"
-          ? readExcerpt(artifact.promptPath, 5000)
-          : artifact.promptExcerpt || readExcerpt(artifact.promptPath, 800);
-      const outputContent =
-        mode === "full"
-          ? readExcerpt(artifact.outputPath, 5000)
-          : artifact.outputExcerpt || readExcerpt(artifact.outputPath, 1400);
-
-      blocks.push(
-        `  <session id="${escapeXml(artifact.sessionId)}" agent="${escapeXml(artifact.agent)}" project="${escapeXml(artifact.project)}" status="${escapeXml(artifact.status)}">`,
-      );
-      if (artifact.goal) {
-        blocks.push(`    <goal>${escapeXml(truncate(artifact.goal, 600))}</goal>`);
-      }
-      if (promptContent) {
-        blocks.push(`    <prompt_excerpt>${escapeXml(promptContent)}</prompt_excerpt>`);
-      }
-      if (outputContent) {
-        blocks.push(`    <output_excerpt>${escapeXml(outputContent)}</output_excerpt>`);
-      }
-      blocks.push("  </session>");
-    }
-
-    if (blocks.length === 0) return "";
-
-    return [
-      `<prior_session_artifacts mode="${mode}">`,
-      ...blocks,
-      "</prior_session_artifacts>",
-      "",
-      "",
-    ].join("\n");
-  }
-}

package/src/lib/session-manager.test.ts

@@ -1,402 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readlinkSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createSession, generateSlug, getAllSessions, getSession } from "./session-manager";
-
-describe("session-manager", () => {
-  describe("generateSlug", () => {
-    it("generates slug with date and title", () => {
-      const slug = generateSlug("Test Session");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-test-session$/);
-    });
-
-    it("handles special characters", () => {
-      const slug = generateSlug("Test & Special! Characters?");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-test-special-characters$/);
-    });
-
-    it("handles multiple spaces", () => {
-      const slug = generateSlug("Multiple    Spaces");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-multiple-spaces$/);
-    });
-
-    it("handles leading/trailing dashes", () => {
-      const slug = generateSlug("--test--");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-test$/);
-    });
-
-    it("converts to lowercase", () => {
-      const slug = generateSlug("UPPERCASE TITLE");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-uppercase-title$/);
-    });
-
-    it("preserves digits in the slug", () => {
-      const slug = generateSlug("Release 2.0 Plan");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-release-2-0-plan$/);
-    });
-
-    it("replaces underscores with dashes", () => {
-      const slug = generateSlug("Feature_Test_Case");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-feature-test-case$/);
-    });
-
-    it("trims punctuation from the ends", () => {
-      const slug = generateSlug("!!!Hello!!!");
-      expect(slug).toMatch(/^\d{4}-\d{2}-\d{2}-hello$/);
-    });
-  });
-
-  describe("getAllSessions", () => {
-    let tempDir: string;
-
-    beforeEach(() => {
-      tempDir = mkdtempSync(join(tmpdir(), "agents-test-"));
-    });
-
-    afterEach(() => {
-      if (existsSync(tempDir)) {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    it("returns empty object if directory does not exist", () => {
-      const nonExistentDir = join(tempDir, "does-not-exist");
-      const result = getAllSessions(nonExistentDir);
-      expect(result).toEqual({});
-    });
-
-    it("returns empty object if no projects", () => {
-      const result = getAllSessions(tempDir);
-      expect(result).toEqual({});
-    });
-
-    it("ignores non-directory entries in the plans directory", () => {
-      const filePath = join(tempDir, "notes.txt");
-      writeFileSync(filePath, "hello");
-      const result = getAllSessions(tempDir);
-      expect(result).toEqual({});
-    });
-
-    it("single project with one session", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const result = getAllSessions(tempDir);
-
-      expect(result).toHaveProperty("arbor");
-      expect(result.arbor).toHaveLength(1);
-      expect(result.arbor[0]).toMatchObject({
-        project: "arbor",
-        slug: "2025-12-01-test-session",
-        date: "2025-12-01",
-        path: session.path,
-      });
-      expect(result.arbor[0].files).toContain("CLAUDE.md");
-      expect(result.arbor[0].files).toContain("plan.md");
-    });
-
-    it("single project with multiple sessions sorted by date desc", () => {
-      createSession(tempDir, "koto", "2025-12-01-newer-session");
-      createSession(tempDir, "koto", "2025-11-15-older-session");
-      createSession(tempDir, "koto", "2025-12-05-middle-session");
-
-      const result = getAllSessions(tempDir);
-
-      expect(result).toHaveProperty("koto");
-      expect(result.koto).toHaveLength(3);
-      // Sorted by date descending (most recent first)
-      expect(result.koto[0].slug).toBe("2025-12-05-middle-session");
-      expect(result.koto[1].slug).toBe("2025-12-01-newer-session");
-      expect(result.koto[2].slug).toBe("2025-11-15-older-session");
-    });
-
-    it("multiple projects with sessions", () => {
-      createSession(tempDir, "arbor", "2025-12-01-arbor-session");
-      createSession(tempDir, "koto", "2025-12-01-koto-session");
-      createSession(tempDir, "kumori", "2025-12-01-kumori-session");
-
-      const result = getAllSessions(tempDir);
-
-      expect(Object.keys(result).sort()).toEqual(["arbor", "koto", "kumori"]);
-      expect(result.arbor).toHaveLength(1);
-      expect(result.koto).toHaveLength(1);
-      expect(result.kumori).toHaveLength(1);
-      expect(result.arbor[0].slug).toBe("2025-12-01-arbor-session");
-      expect(result.koto[0].slug).toBe("2025-12-01-koto-session");
-      expect(result.kumori[0].slug).toBe("2025-12-01-kumori-session");
-    });
-
-    it("extracts date from slug format YYYY-MM-DD", () => {
-      createSession(tempDir, "test", "2025-03-15-feature-name");
-      const result = getAllSessions(tempDir);
-
-      expect(result.test[0].date).toBe("2025-03-15");
-    });
-
-    it("handles slug with many hyphens", () => {
-      createSession(tempDir, "test", "2025-01-30-this-is-a-long-feature-name");
-      const result = getAllSessions(tempDir);
-
-      expect(result.test[0].date).toBe("2025-01-30");
-      expect(result.test[0].slug).toBe("2025-01-30-this-is-a-long-feature-name");
-    });
-
-    it("ignores non-directory entries in a project directory", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const filePath = join(tempDir, "arbor", "notes.txt");
-      writeFileSync(filePath, "hello");
-
-      const result = getAllSessions(tempDir);
-      expect(result.arbor).toHaveLength(1);
-      expect(result.arbor[0].slug).toBe("2025-12-01-test-session");
-    });
-
-    it("includes extra files found in session directory", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const extraPath = join(session.path, "notes.md");
-      writeFileSync(extraPath, "extra");
-
-      const result = getAllSessions(tempDir);
-      expect(result.arbor[0].files).toContain("notes.md");
-    });
-
-    it("returns empty array for projects with no sessions", () => {
-      const projectDir = join(tempDir, "empty-project");
-      mkdirSync(projectDir, { recursive: true });
-
-      const result = getAllSessions(tempDir);
-      expect(result["empty-project"]).toEqual([]);
-    });
-
-    it("handles slugs without date prefixes", () => {
-      const projectDir = join(tempDir, "misc");
-      const sessionDir = join(projectDir, "custom-slug");
-      mkdirSync(sessionDir, { recursive: true });
-
-      const result = getAllSessions(tempDir);
-      expect(result.misc[0].date).toBe("custom-slug");
-      expect(result.misc[0].slug).toBe("custom-slug");
-    });
-  });
-
-  describe("getSession", () => {
-    let tempDir: string;
-
-    beforeEach(() => {
-      tempDir = mkdtempSync(join(tmpdir(), "agents-test-"));
-    });
-
-    afterEach(() => {
-      if (existsSync(tempDir)) {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    it("returns correct SessionMetadata for existing session", () => {
-      const created = createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const session = getSession(tempDir, "arbor", "2025-12-01-test-session");
-
-      expect(session).toBeDefined();
-      expect(session).toMatchObject({
-        project: "arbor",
-        slug: "2025-12-01-test-session",
-        date: "2025-12-01",
-        path: created.path,
-      });
-      expect(session!.files).toContain("CLAUDE.md");
-      expect(session!.files).toContain("plan.md");
-    });
-
-    it("returns undefined for non-existent project", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const session = getSession(tempDir, "koto", "2025-12-01-test-session");
-
-      expect(session).toBeUndefined();
-    });
-
-    it("returns undefined when plans directory is missing", () => {
-      const missingDir = join(tempDir, "missing");
-      const session = getSession(missingDir, "arbor", "2025-12-01-test-session");
-      expect(session).toBeUndefined();
-    });
-
-    it("returns undefined for non-existent slug", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const session = getSession(tempDir, "arbor", "2025-12-01-different-session");
-
-      expect(session).toBeUndefined();
-    });
-
-    it("case-sensitive matching for project", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const session = getSession(tempDir, "Arbor", "2025-12-01-test-session");
-
-      expect(session).toBeUndefined();
-    });
-
-    it("case-sensitive matching for slug", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test-session");
-      const session = getSession(tempDir, "arbor", "2025-12-01-Test-Session");
-
-      expect(session).toBeUndefined();
-    });
-
-    it("returns session from correct project when multiple projects exist", () => {
-      createSession(tempDir, "arbor", "2025-12-01-arbor-feature");
-      createSession(tempDir, "koto", "2025-12-01-koto-feature");
-
-      const arborSession = getSession(tempDir, "arbor", "2025-12-01-arbor-feature");
-      const kotoSession = getSession(tempDir, "koto", "2025-12-01-koto-feature");
-
-      expect(arborSession?.project).toBe("arbor");
-      expect(kotoSession?.project).toBe("koto");
-    });
-
-    it("returns session with extra files in metadata", () => {
-      const created = createSession(tempDir, "arbor", "2025-12-01-test-session");
-      writeFileSync(join(created.path, "notes.md"), "extra");
-
-      const session = getSession(tempDir, "arbor", "2025-12-01-test-session");
-      expect(session?.files).toContain("notes.md");
-    });
-  });
-
-  describe("createSession", () => {
-    let tempDir: string;
-
-    beforeEach(() => {
-      tempDir = mkdtempSync(join(tmpdir(), "agents-test-"));
-    });
-
-    afterEach(() => {
-      if (existsSync(tempDir)) {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    it("creates project directory if needed", () => {
-      const session = createSession(tempDir, "new-project", "2025-12-01-test");
-      const projectDir = join(tempDir, "new-project");
-
-      expect(existsSync(projectDir)).toBe(true);
-      expect(existsSync(session.path)).toBe(true);
-    });
-
-    it("creates session directory with slug", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-feature-name");
-      const expectedPath = join(tempDir, "arbor", "2025-12-01-feature-name");
-
-      expect(session.path).toBe(expectedPath);
-      expect(existsSync(expectedPath)).toBe(true);
-    });
-
-    it("creates CLAUDE.md with template", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-      const claudePath = join(session.path, "CLAUDE.md");
-
-      expect(existsSync(claudePath)).toBe(true);
-
-      const content = readFileSync(claudePath, "utf-8");
-      expect(content).toContain("# arbor - 2025-12-01-test");
-      expect(content).toContain("## Context");
-      expect(content).toContain("## Background");
-      expect(content).toContain("## Goals");
-    });
-
-    it("creates plan.md with template", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-      const planPath = join(session.path, "plan.md");
-
-      expect(existsSync(planPath)).toBe(true);
-
-      const content = readFileSync(planPath, "utf-8");
-      expect(content).toContain("# Implementation Plan");
-      expect(content).toContain("## Overview");
-      expect(content).toContain("## Tasks");
-      expect(content).toContain("## Validation");
-    });
-
-    it("includes task checklist in plan template", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-      const planPath = join(session.path, "plan.md");
-      const content = readFileSync(planPath, "utf-8");
-      expect(content).toContain("- [ ] Task 1");
-    });
-
-    it("includes validation checklist in plan template", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-      const planPath = join(session.path, "plan.md");
-      const content = readFileSync(planPath, "utf-8");
-      expect(content).toContain("- [ ] Feature works as expected");
-    });
-
-    it("creates CLAUDE.md as symlink to AGENTS.md (or copy fallback)", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-      const agentsPath = join(session.path, "AGENTS.md");
-      const claudePath = join(session.path, "CLAUDE.md");
-
-      expect(existsSync(agentsPath)).toBe(true);
-      expect(existsSync(claudePath)).toBe(true);
-
-      // AGENTS.md should be the canonical file
-      const agentsStats = lstatSync(agentsPath);
-      expect(agentsStats.isSymbolicLink()).toBe(false);
-
-      // CLAUDE.md should link to (or match) AGENTS.md
-      const claudeStats = lstatSync(claudePath);
-      if (claudeStats.isSymbolicLink()) {
-        expect(readlinkSync(claudePath)).toBe("AGENTS.md");
-      }
-      expect(readFileSync(claudePath, "utf-8")).toBe(readFileSync(agentsPath, "utf-8"));
-    });
-
-    it("returns SessionMetadata with correct files array", () => {
-      const session = createSession(tempDir, "arbor", "2025-12-01-test");
-
-      expect(session.files).toEqual(["CLAUDE.md", "AGENTS.md", "plan.md"]);
-      expect(session.project).toBe("arbor");
-      expect(session.slug).toBe("2025-12-01-test");
-      expect(session.date).toBe("2025-12-01");
-    });
-
-    it("throws error if session already exists", () => {
-      createSession(tempDir, "arbor", "2025-12-01-test");
-
-      expect(() => {
-        createSession(tempDir, "arbor", "2025-12-01-test");
-      }).toThrow("Session already exists");
-    });
-
-    it("can create multiple sessions in same project", () => {
-      const session1 = createSession(tempDir, "arbor", "2025-12-01-feature-a");
-      const session2 = createSession(tempDir, "arbor", "2025-12-02-feature-b");
-
-      expect(existsSync(session1.path)).toBe(true);
-      expect(existsSync(session2.path)).toBe(true);
-
-      const sessions = getAllSessions(tempDir);
-      expect(sessions.arbor).toHaveLength(2);
-    });
-
-    it("extracts date from slug in returned metadata", () => {
-      const session = createSession(tempDir, "test", "2024-01-15-feature");
-
-      expect(session.date).toBe("2024-01-15");
-    });
-
-    it("handles nested project names with hyphens", () => {
-      const session = createSession(tempDir, "my-project-name", "2025-12-01-test");
-
-      expect(existsSync(session.path)).toBe(true);
-      expect(session.project).toBe("my-project-name");
-    });
-  });
-});