@creativeintelligence/abbie 0.1.0

package/dist/lib/runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/runner.test.js

@@ -0,0 +1,234 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { spawn } from 'child_process';
+import { parseRunnerConfig } from './runner.js';
+describe('runner', () => {
+    describe('parseRunnerConfig', () => {
+        it('returns null when required env vars are missing', () => {
+            const config = parseRunnerConfig({});
+            expect(config).toBeNull();
+        });
+        it('parses valid config from environment', () => {
+            const config = parseRunnerConfig({
+                AGENTS_RUNNER_SESSION_ID: 'test-session-123',
+                AGENTS_RUNNER_SESSION_PATH: '/tmp/session.json',
+                AGENTS_RUNNER_PROMPT_PATH: '/tmp/prompt.md',
+                AGENTS_RUNNER_OUTPUT_PATH: '/tmp/output.json',
+                AGENTS_RUNNER_AGENT: 'claude',
+            });
+            expect(config).not.toBeNull();
+            expect(config.sessionId).toBe('test-session-123');
+            expect(config.agent).toBe('claude');
+            expect(config.outputPath).toBe('/tmp/output.json');
+        });
+        it('derives stdout/stderr paths from output path', () => {
+            const config = parseRunnerConfig({
+                AGENTS_RUNNER_SESSION_ID: 'test-session',
+                AGENTS_RUNNER_SESSION_PATH: '/tmp/session.json',
+                AGENTS_RUNNER_PROMPT_PATH: '/tmp/prompt.md',
+                AGENTS_RUNNER_OUTPUT_PATH: '/tmp/output.json',
+                AGENTS_RUNNER_AGENT: 'codex',
+            });
+            expect(config).not.toBeNull();
+            expect(config.stdoutPath).toBe('/tmp/output-stdout.log');
+            expect(config.stderrPath).toBe('/tmp/output-stderr.log');
+        });
+        it('uses explicit stdout/stderr paths when provided', () => {
+            const config = parseRunnerConfig({
+                AGENTS_RUNNER_SESSION_ID: 'test-session',
+                AGENTS_RUNNER_SESSION_PATH: '/tmp/session.json',
+                AGENTS_RUNNER_PROMPT_PATH: '/tmp/prompt.md',
+                AGENTS_RUNNER_OUTPUT_PATH: '/tmp/output.json',
+                AGENTS_RUNNER_STDOUT_PATH: '/tmp/custom-stdout.log',
+                AGENTS_RUNNER_STDERR_PATH: '/tmp/custom-stderr.log',
+                AGENTS_RUNNER_AGENT: 'copilot',
+            });
+            expect(config).not.toBeNull();
+            expect(config.stdoutPath).toBe('/tmp/custom-stdout.log');
+            expect(config.stderrPath).toBe('/tmp/custom-stderr.log');
+        });
+        it('includes model when provided', () => {
+            const config = parseRunnerConfig({
+                AGENTS_RUNNER_SESSION_ID: 'test-session',
+                AGENTS_RUNNER_SESSION_PATH: '/tmp/session.json',
+                AGENTS_RUNNER_PROMPT_PATH: '/tmp/prompt.md',
+                AGENTS_RUNNER_OUTPUT_PATH: '/tmp/output.json',
+                AGENTS_RUNNER_AGENT: 'gemini',
+                AGENTS_RUNNER_MODEL: 'gemini-3-flash',
+            });
+            expect(config).not.toBeNull();
+            expect(config.model).toBe('gemini-3-flash');
+        });
+    });
+    describe('spawn failure handling', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = mkdtempSync(join(tmpdir(), 'runner-test-'));
+        });
+        afterEach(() => {
+            rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('handles ENOENT when command does not exist', async () => {
+            // This tests the spawn error handling path
+            const child = spawn('/nonexistent/command', [], {
+                stdio: 'ignore',
+            });
+            const errorPromise = new Promise((resolve) => {
+                child.on('error', resolve);
+            });
+            const error = await errorPromise;
+            expect(error.message).toContain('ENOENT');
+        });
+        it('handles spawn with invalid cwd', async () => {
+            const child = spawn('echo', ['hello'], {
+                cwd: '/nonexistent/directory',
+                stdio: 'ignore',
+            });
+            const errorPromise = new Promise((resolve) => {
+                child.on('error', resolve);
+            });
+            const error = await errorPromise;
+            expect(error.message).toContain('ENOENT');
+        });
+    });
+    describe('signal forwarding', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = mkdtempSync(join(tmpdir(), 'runner-signal-test-'));
+        });
+        afterEach(() => {
+            rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('child process receives SIGTERM', async () => {
+            // Spawn a process that traps SIGTERM and writes to a file
+            const markerFile = join(tempDir, 'received-signal');
+            const child = spawn('bash', [
+                '-c',
+                `trap 'echo SIGTERM > ${markerFile}; exit 0' TERM; while true; do sleep 0.1; done`,
+            ], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            // Wait for process to start and trap to be installed
+            await new Promise((r) => setTimeout(r, 300));
+            // Send SIGTERM
+            process.kill(child.pid, 'SIGTERM');
+            // Wait for handler and exit (longer timeout for CI)
+            await new Promise((r) => setTimeout(r, 500));
+            // Check the marker file - if it exists, signal was received
+            if (existsSync(markerFile)) {
+                expect(readFileSync(markerFile, 'utf-8').trim()).toBe('SIGTERM');
+            }
+            else {
+                // Process may have been killed before trap installed - this is acceptable
+                // Just verify the process is no longer running
+                let isRunning = false;
+                try {
+                    process.kill(child.pid, 0);
+                    isRunning = true;
+                }
+                catch {
+                    isRunning = false;
+                }
+                expect(isRunning).toBe(false);
+            }
+        });
+        it('process group kill terminates child tree', async () => {
+            // Spawn a parent that spawns a child
+            const markerFile = join(tempDir, 'parent-pid');
+            const child = spawn('bash', [
+                '-c',
+                `echo $$ > ${markerFile}; sleep 10`,
+            ], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            // Wait for process to start
+            await new Promise((r) => setTimeout(r, 100));
+            const pid = child.pid;
+            // Kill the process group (negative PID)
+            try {
+                process.kill(-pid, 'SIGKILL');
+            }
+            catch {
+                // May already be dead or group not available on some platforms
+            }
+            // Wait for termination
+            await new Promise((r) => setTimeout(r, 100));
+            // Verify process is gone
+            let isRunning = false;
+            try {
+                process.kill(pid, 0); // Signal 0 checks if process exists
+                isRunning = true;
+            }
+            catch {
+                isRunning = false;
+            }
+            expect(isRunning).toBe(false);
+        });
+    });
+    describe('ExitInfo structure', () => {
+        it('captures exit code and signal correctly', () => {
+            const exitInfo = {
+                exitCode: 0,
+                signal: null,
+                endedAt: new Date().toISOString(),
+            };
+            expect(exitInfo.exitCode).toBe(0);
+            expect(exitInfo.signal).toBeNull();
+            expect(exitInfo.endedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+        it('captures signal when process is killed', () => {
+            const exitInfo = {
+                exitCode: null,
+                signal: 'SIGTERM',
+                endedAt: new Date().toISOString(),
+            };
+            expect(exitInfo.exitCode).toBeNull();
+            expect(exitInfo.signal).toBe('SIGTERM');
+        });
+    });
+    describe('output file handling', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = mkdtempSync(join(tmpdir(), 'runner-output-test-'));
+        });
+        afterEach(() => {
+            rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('captures stdout to output file', async () => {
+            const outputFile = join(tempDir, 'output.txt');
+            const child = spawn('echo', ['hello world'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const { createWriteStream } = await import('fs');
+            const stream = createWriteStream(outputFile);
+            child.stdout?.pipe(stream);
+            await new Promise((resolve) => {
+                child.on('close', () => {
+                    stream.end(() => resolve());
+                });
+            });
+            expect(existsSync(outputFile)).toBe(true);
+            expect(readFileSync(outputFile, 'utf-8').trim()).toBe('hello world');
+        });
+        it('captures stderr separately', async () => {
+            const stderrFile = join(tempDir, 'stderr.txt');
+            const child = spawn('bash', ['-c', 'echo error >&2'], {
+                stdio: ['ignore', 'ignore', 'pipe'],
+            });
+            const { createWriteStream } = await import('fs');
+            const stream = createWriteStream(stderrFile);
+            child.stderr?.pipe(stream);
+            await new Promise((resolve) => {
+                child.on('close', () => {
+                    stream.end(() => resolve());
+                });
+            });
+            expect(existsSync(stderrFile)).toBe(true);
+            expect(readFileSync(stderrFile, 'utf-8').trim()).toBe('error');
+        });
+    });
+});

package/dist/lib/session-artifacts.d.ts

@@ -0,0 +1,46 @@
+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;
+}
+export declare class SessionArtifactStore {
+    private basePath;
+    constructor(basePath?: string);
+    private artifactPath;
+    private write;
+    get(sessionId: string): SessionArtifact | undefined;
+    saveStart(opts: {
+        sessionId: string;
+        agent: string;
+        project: string;
+        status: SessionArtifactStatus;
+        startedAt: string;
+        issue?: string;
+        traceId?: string;
+        goal?: string;
+        promptPath?: string;
+        outputPath?: string;
+    }): void;
+    markComplete(sessionId: string, opts: {
+        status: SessionArtifactStatus;
+        endedAt?: string;
+        exitCode?: number;
+        outputPath?: string;
+    }): void;
+    buildReinjectionContext(sessionIds: string[], mode: ReinjectMode): string;
+}
+//# sourceMappingURL=session-artifacts.d.ts.map

package/dist/lib/session-artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-artifacts.d.ts","sourceRoot":"","sources":["../../src/lib/session-artifacts.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,CAAC;AACtD,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AA+BD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,CAAC,EAAE,MAAM;IAO7B,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,KAAK;IAKb,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAUnD,SAAS,CAAC,IAAI,EAAE;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,qBAAqB,CAAC;QAC9B,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,IAAI;IAkBR,YAAY,CACV,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE;QACJ,MAAM,EAAE,qBAAqB,CAAC;QAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GACA,IAAI;IA0BP,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM;CA8C1E"}

package/dist/lib/session-artifacts.js

@@ -0,0 +1,138 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+function readText(path) {
+    if (!path || !existsSync(path))
+        return undefined;
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function readExcerpt(path, maxChars) {
+    const text = readText(path);
+    if (!text)
+        return undefined;
+    return truncate(text.trim(), maxChars);
+}
+export class SessionArtifactStore {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath || join(homedir(), ".abbie", "session-artifacts");
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+    }
+    artifactPath(sessionId) {
+        return join(this.basePath, `${sessionId}.json`);
+    }
+    write(artifact) {
+        const path = this.artifactPath(artifact.sessionId);
+        writeFileSync(path, JSON.stringify(artifact, null, 2));
+    }
+    get(sessionId) {
+        const path = this.artifactPath(sessionId);
+        if (!existsSync(path))
+            return undefined;
+        try {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    saveStart(opts) {
+        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, opts) {
+        const existing = this.get(sessionId);
+        const now = new Date().toISOString();
+        const resolvedOutputPath = opts.outputPath ?? existing?.outputPath;
+        const artifact = {
+            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, mode) {
+        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 = [];
+        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/dist/lib/session-manager.d.ts

@@ -0,0 +1,24 @@
+export interface SessionMetadata {
+    project: string;
+    slug: string;
+    date: string;
+    path: string;
+    files: string[];
+}
+/**
+ * Get all planning sessions organized by project.
+ */
+export declare function getAllSessions(plansDir: string): Record<string, SessionMetadata[]>;
+/**
+ * Get a specific session.
+ */
+export declare function getSession(plansDir: string, project: string, slug: string): SessionMetadata | undefined;
+/**
+ * Create a new planning session.
+ */
+export declare function createSession(plansDir: string, project: string, slug: string): SessionMetadata;
+/**
+ * Generate a slug from a title.
+ */
+export declare function generateSlug(title: string): string;
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/lib/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../../src/lib/session-manager.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAkClF;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,eAAe,GAAG,SAAS,CAG7B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAwE9F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD"}

package/dist/lib/session-manager.js

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readdirSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Get all planning sessions organized by project.
+ */
+export function getAllSessions(plansDir) {
+    if (!existsSync(plansDir)) {
+        return {};
+    }
+    const result = {};
+    const projects = readdirSync(plansDir).filter((name) => {
+        const path = join(plansDir, name);
+        return statSync(path).isDirectory();
+    });
+    for (const project of projects) {
+        const projectDir = join(plansDir, project);
+        const sessions = readdirSync(projectDir)
+            .filter((name) => statSync(join(projectDir, name)).isDirectory())
+            .map((slug) => {
+            const sessionPath = join(projectDir, slug);
+            const files = existsSync(sessionPath) ? readdirSync(sessionPath) : [];
+            const date = slug.split("-").slice(0, 3).join("-"); // Extract YYYY-MM-DD
+            return {
+                project,
+                slug,
+                date,
+                path: sessionPath,
+                files,
+            };
+        })
+            .sort((a, b) => b.date.localeCompare(a.date)); // Most recent first
+        result[project] = sessions;
+    }
+    return result;
+}
+/**
+ * Get a specific session.
+ */
+export function getSession(plansDir, project, slug) {
+    const allSessions = getAllSessions(plansDir);
+    return allSessions[project]?.find((s) => s.slug === slug);
+}
+/**
+ * Create a new planning session.
+ */
+export function createSession(plansDir, project, slug) {
+    const projectDir = join(plansDir, project);
+    const sessionPath = join(projectDir, slug);
+    if (!existsSync(projectDir)) {
+        mkdirSync(projectDir, { recursive: true });
+    }
+    if (existsSync(sessionPath)) {
+        throw new Error(`Session already exists: ${sessionPath}`);
+    }
+    mkdirSync(sessionPath, { recursive: true });
+    // Create default files
+    const agentsMd = join(sessionPath, "AGENTS.md");
+    const claudeMd = join(sessionPath, "CLAUDE.md");
+    const planMd = join(sessionPath, "plan.md");
+    const agentsContent = `# ${project} - ${slug}
+
+## Context
+
+[Describe the problem/feature/task]
+
+## Background
+
+[Relevant context, constraints, decisions]
+
+## Goals
+
+[What we're trying to achieve]
+`;
+    writeFileSync(agentsMd, agentsContent);
+    writeFileSync(planMd, `# Implementation Plan
+
+## Overview
+
+[High-level approach]
+
+## Tasks
+
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Validation
+
+- [ ] Tests pass
+- [ ] Feature works as expected
+`);
+    // Canonical convention: CLAUDE.md is a symlink to AGENTS.md
+    try {
+        symlinkSync("AGENTS.md", claudeMd);
+    }
+    catch {
+        // Symlink might fail on some systems (e.g. Windows without symlink support).
+        // Fall back to a copy so older tooling still finds CLAUDE.md.
+        writeFileSync(claudeMd, agentsContent);
+    }
+    return {
+        project,
+        slug,
+        date: slug.split("-").slice(0, 3).join("-"),
+        path: sessionPath,
+        files: ["CLAUDE.md", "AGENTS.md", "plan.md"],
+    };
+}
+/**
+ * Generate a slug from a title.
+ */
+export function generateSlug(title) {
+    const date = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return `${date}-${slug}`;
+}

package/dist/lib/session-manager.test.d.ts

@@ -0,0 +1 @@
+export {};