codehere 1.0.1 → 1.0.2

package/dist/infrastructure/security/vibe-checks.js

@@ -1,99 +0,0 @@
-/**
- * Vibe-coder-specific danger checks — the high-consequence things gitleaks + semgrep DON'T catch by
- * default but that the research named as the #1 ways AI-built apps get owned. Deterministic, zero
- * model tokens. Pattern-based on the source files. See docs/PRODUCT_10X.md (step 1 of the plan).
- */
-import { readdirSync, readFileSync } from 'node:fs';
-import { join, extname, relative } from 'node:path';
-const SRC_EXT = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.vue', '.svelte', '.html', '.astro']);
-const SKIP_DIR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'out', 'vendor', 'coverage', '.turbo']);
-function walk(dir, files, depth = 0) {
-    if (depth > 8)
-        return;
-    let ents;
-    try {
-        ents = readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const e of ents) {
-        if (SKIP_DIR.has(e.name))
-            continue;
-        const p = join(dir, e.name);
-        if (e.isDirectory())
-            walk(p, files, depth + 1);
-        else if (SRC_EXT.has(extname(e.name)))
-            files.push(p);
-    }
-}
-const CHECKS = [
-    {
-        // The real escalation danger: a PRIVILEGE flag in browser storage (not a token, which is standard).
-        id: 'privilege-flag-in-browser-storage',
-        re: /(localStorage|sessionStorage)\s*\.\s*setItem\s*\(\s*['"`](role|is_?admin|admin|is_?staff|is_?paid|paid|premium|pro|plan|tier|permission|access_?level|can_|entitlement)/i,
-        tier: 'critical',
-        what: (f) => `A permission flag (admin/role/plan) is stored in the browser in ${f}. A user can open dev-tools, change it, and give themselves admin or paid access — your app trusts a value the user controls. Decide permissions on the server, never from localStorage.`,
-    },
-    {
-        id: 'supabase-service-role-key',
-        re: /service_role|SUPABASE_SERVICE_ROLE/i,
-        tier: 'critical',
-        what: (f) => `A Supabase service_role key is referenced in ${f}. That key bypasses ALL your database rules — if it reaches the browser, anyone can read and write your entire database. It must live only on your server, never in client code.`,
-    },
-    {
-        // User input string-built into a SQL query — concat ("...WHERE id="+x) or interpolation (`...${x}`).
-        // Parameterized queries ($1 / ? placeholders) don't match, so this stays low-noise.
-        id: 'sql-injection-string-building',
-        re: /\b(SELECT\b[^;\n'"`]*\bFROM\b|INSERT\b[^;\n'"`]*\bINTO\b|UPDATE\b[^;\n'"`]*\bSET\b|DELETE\b[^;\n'"`]*\bFROM\b)[^;\n]*?(\$\{|['"`]\s*\+\s*\w)/i,
-        tier: 'critical',
-        what: (f) => `User input is being string-built into a SQL query in ${f}. An attacker can put SQL inside that input and read, change, or wipe your entire database. Use parameterized queries (placeholders like $1 or ?), never glue the query together with + or \${}.`,
-    },
-    {
-        id: 'unsafe-html-injection',
-        re: /dangerouslySetInnerHTML|v-html\s*=|\.innerHTML\s*=\s*[^'"`;\s]/,
-        tier: 'high',
-        what: (f) => `Raw HTML is written into the page in ${f}. If any of it comes from a user, an attacker can run scripts in your visitors' browsers — steal their logins, deface the page, or act as them.`,
-    },
-    {
-        id: 'auth-disabled-or-todo',
-        re: /\/\/\s*(TODO|FIXME).*(auth|login|permission|secur)|auth\s*[:=]\s*false|requireAuth\s*[:=]\s*false|skipAuth\s*[:=]\s*true/i,
-        tier: 'high',
-        what: (f) => `Authentication looks turned off or left as a TODO in ${f}. AI agents often stub auth out to "make it work" and never finish it — anyone could reach pages or data meant to be protected.`,
-    },
-];
-/** Scan the source files in `dir` for vibe-coder-specific dangers. One hit per check per file. */
-export function vibeChecks(dir) {
-    const files = [];
-    walk(dir, files);
-    const out = [];
-    for (const f of files) {
-        let txt;
-        try {
-            txt = readFileSync(f, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        if (txt.length > 500_000)
-            continue; // skip huge/minified files
-        const lines = txt.split('\n');
-        for (const c of CHECKS) {
-            for (let i = 0; i < lines.length; i++) {
-                if (c.re.test(lines[i])) {
-                    out.push({
-                        tool: 'codehere',
-                        ruleId: c.id,
-                        file: relative(dir, f),
-                        line: i + 1,
-                        tier: c.tier,
-                        what: c.what(relative(dir, f)),
-                    });
-                    break;
-                }
-            }
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=vibe-checks.js.map

package/dist/infrastructure/storage/atomic-write.js

@@ -1,86 +0,0 @@
-/**
- * Write a file so a reader never sees it half-written.
- *
- * Why (measured 2026-08-08, not assumed): `writeFileSync` is open(O_TRUNC) then
- * write. SIGKILL landing between the two leaves a truncated, unparseable file.
- * Induced deliberately — 40 attempts at a ~290KB payload, **15 came back torn**.
- * The window shrinks with file size but never closes, and codehere's state files
- * only grow.
- *
- * The failure this prevents is not "the write was lost" — losing the write is
- * survivable, the caller can write again. It is "the file that survived is
- * garbage": a corrupt permissions list, an unreadable budget ceiling, an OAuth
- * store that no longer parses. `rename(2)` is atomic on POSIX, so a reader sees
- * either the whole old file or the whole new one, never a splice of both.
- *
- * NOT what this gives you: durability across power loss. That needs fsync on the
- * file AND its directory, which costs a real syscall on every write. The failure
- * mode there is different and much less bad — you lose the write, you do not get
- * a corrupt file — so it is deliberately not paid for here. Say so rather than
- * implying this makes writes crash-proof.
- *
- * Appends are NOT routed through this and do not need to be. `appendFileSync`
- * opens O_APPEND, and each write is atomic with respect to the file offset:
- * measured with 6 concurrent writers × 300 records, and again at 90KB records,
- * with zero interleaving or loss both times. The JSONL chain and session logs
- * were never at risk from this, and an earlier audit that counted appends
- * alongside whole-file writes overstated the problem.
- */
-import { writeFileSync, renameSync, unlinkSync, readdirSync, statSync } from 'node:fs';
-import { dirname, basename, join } from 'node:path';
-/** A temp older than this was orphaned by a crash, not left by a live write. */
-const STALE_TEMP_MS = 60_000;
-/**
- * Sweep temps this file's own writes orphaned. SIGKILL cannot run a catch block,
- * so a hard crash mid-write always leaves one behind — measured at 16 after 40
- * kills. Without this, trading a corrupt file for permanent litter in the user's
- * state dir just moves the problem: a stray `.tmp` next to `permissions.yaml`
- * reads as corruption to anyone opening the directory.
- *
- * Scoped to the target's own basename so it can never touch another file's
- * in-flight temp, and age-gated so it can never race a concurrent writer.
- */
-function sweepStaleTemps(path) {
-    const dir = dirname(path);
-    const prefix = `${basename(path)}.`;
-    try {
-        for (const name of readdirSync(dir)) {
-            if (!name.startsWith(prefix) || !name.endsWith('.tmp'))
-                continue;
-            const p = join(dir, name);
-            try {
-                if (Date.now() - statSync(p).mtimeMs > STALE_TEMP_MS)
-                    unlinkSync(p);
-            }
-            catch {
-                /* vanished under us, or not ours to remove — either way, leave it */
-            }
-        }
-    }
-    catch {
-        /* unreadable dir · sweeping is hygiene, never a reason to fail the write */
-    }
-}
-export function writeFileAtomic(path, data, opts) {
-    // pid + time keeps two concurrent writers of the SAME path from clobbering
-    // each other's temp file; the rename still decides who wins, and either whole
-    // file is valid.
-    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        writeFileSync(tmp, data, opts?.mode !== undefined ? { mode: opts.mode } : undefined);
-        renameSync(tmp, path);
-        sweepStaleTemps(path);
-    }
-    catch (err) {
-        // Never leave the temp behind on a failed write — it would accumulate in the
-        // user's state dir forever and look like corruption to anyone reading it.
-        try {
-            unlinkSync(tmp);
-        }
-        catch {
-            /* the temp never existed, or is already gone */
-        }
-        throw err;
-    }
-}
-//# sourceMappingURL=atomic-write.js.map

package/dist/infrastructure/storage/cross-tool-agents.js

@@ -1,268 +0,0 @@
-/**
- * Cross-tool agent definition reader — v0.6.0 M8.
- *
- * Reads agent definitions written for OTHER tools (OpenCode, Claude Code) and
- * normalizes them into codehere's internal shape so they appear in the agents
- * pane alongside codehere's built-in adapters.
- *
- * Built from Spike-4 prototype (agent/spike/v0.6.0-cross-tool-parser.mjs);
- * production version uses the `yaml` lib for proper 2-level nesting + multi-
- * line scalars + quoted-string handling, recurses subdirectories per the
- * AGENTS.md hierarchical convention, skips files without frontmatter, and
- * surfaces unknown frontmatter keys as warnings (not silent drops).
- *
- * Sources read in precedence order (later overrides earlier on name conflict):
- *   1. ~/.claude/agents/                  (global Claude Code subagents)
- *   2. ~/.opencode/agents/                (global OpenCode agents)
- *   3. ~/.codehere/agents/                (global codehere agents)
- *   4. <cwd>/.claude/agents/              (project Claude Code)
- *   5. <cwd>/.opencode/agents/            (project OpenCode)
- *   6. <cwd>/.codehere/agents/            (project codehere)
- *
- * Format normalization handles divergences:
- *   - Claude `name` field vs OpenCode (filename = name)
- *   - Claude `tools: "A, B, C"` (string) vs OpenCode `tools: {a: true, b: false}` (object)
- *   - Claude no `mode` (subagent implicit) vs OpenCode `mode: primary|subagent|all`
- *   - OpenCode `permission` block vs Claude (no permission block)
- *
- * NOT in scope of this module:
- *   - Permission ENFORCEMENT (this just READS them for display + future M5)
- *   - Template variable substitution ({{PROJECT_NAME}} stays as raw text)
- *   - Authoring (`codehere agent create` is C6, deferred)
- */
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import YAML from 'yaml';
-/**
- * Pre-process Claude Code-style frontmatter that contains unquoted colons in
- * description/prompt values (e.g. "description: ... Examples:\n<example>\nContext: ...").
- * Strict YAML parsers reject these; Claude Code itself uses a more permissive
- * reader. We force-quote affected values before parsing.
- *
- * Heuristic: any top-level `description:` or `prompt:` line whose value
- * contains a `: ` (colon-space) AND isn't already quoted/block-scalar gets
- * single-quoted with internal single quotes doubled (YAML escape).
- */
-function preprocessFrontmatter(fmText) {
-    return fmText
-        .split('\n')
-        .map((line) => {
-        const m = line.match(/^(description|prompt):\s*(.+)$/);
-        if (!m)
-            return line;
-        const [, key, value] = m;
-        const trimmed = value.trim();
-        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-            (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
-            trimmed.startsWith('|') ||
-            trimmed.startsWith('>')) {
-            return line; // already a safe scalar form
-        }
-        if (!/:\s/.test(trimmed))
-            return line; // no problematic embedded colons
-        const escaped = trimmed.replace(/'/g, "''");
-        return `${key}: '${escaped}'`;
-    })
-        .join('\n');
-}
-/** Recursively walk a dir, return all .md files (sorted for determinism). */
-function listMdFilesRecursive(dir) {
-    if (!existsSync(dir))
-        return [];
-    let stat;
-    try {
-        stat = statSync(dir);
-    }
-    catch {
-        return [];
-    }
-    if (!stat.isDirectory())
-        return [];
-    const out = [];
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    for (const entry of entries.sort()) {
-        if (entry.startsWith('.'))
-            continue;
-        const p = join(dir, entry);
-        let s;
-        try {
-            s = statSync(p);
-        }
-        catch {
-            continue;
-        }
-        if (s.isDirectory()) {
-            out.push(...listMdFilesRecursive(p));
-        }
-        else if (s.isFile() && entry.endsWith('.md') && entry !== 'README.md') {
-            out.push(p);
-        }
-    }
-    return out;
-}
-/** Parse a single agent file. Returns null if no frontmatter or parse fails. */
-export function parseAgentFile(filePath, defaultFormat = 'unknown') {
-    let text;
-    try {
-        text = readFileSync(filePath, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-    if (!text.startsWith('---'))
-        return null; // no frontmatter, not an agent file
-    const closeIdx = text.indexOf('\n---', 4);
-    if (closeIdx === -1)
-        return null;
-    const fmText = text.slice(4, closeIdx).trim();
-    const body = text.slice(closeIdx + 4).trim();
-    let fm;
-    try {
-        fm = YAML.parse(preprocessFrontmatter(fmText));
-        if (!fm || typeof fm !== 'object')
-            return null;
-    }
-    catch {
-        return null;
-    }
-    // Source format inference: presence of mode/permission/object-tools = OpenCode;
-    // presence of name + string-tools = Claude. Fall back to default by location.
-    const hasObjectTools = typeof fm.tools === 'object' && fm.tools !== null && !Array.isArray(fm.tools);
-    const sourceFormat = fm.mode || fm.permission || hasObjectTools
-        ? 'opencode'
-        : fm.name || typeof fm.tools === 'string'
-            ? 'claude'
-            : defaultFormat;
-    // Tools normalization
-    let tools = null;
-    if (typeof fm.tools === 'string') {
-        tools = fm.tools
-            .split(',')
-            .map((t) => t.trim().toLowerCase())
-            .filter(Boolean);
-    }
-    else if (hasObjectTools) {
-        tools = [];
-        for (const [k, v] of Object.entries(fm.tools)) {
-            if (v === true)
-                tools.push(k.toLowerCase());
-        }
-    }
-    // Filename without .md = fallback name
-    const filenameName = filePath.split('/').pop()?.replace(/\.md$/, '') ?? 'unnamed';
-    // Mode normalization
-    const modeRaw = typeof fm.mode === 'string' ? fm.mode : null;
-    const mode = modeRaw === 'primary' || modeRaw === 'subagent' || modeRaw === 'all'
-        ? modeRaw
-        : sourceFormat === 'claude'
-            ? 'subagent'
-            : 'all';
-    // Track unknown frontmatter keys (everything outside our normalized set)
-    const knownKeys = new Set([
-        'name',
-        'description',
-        'mode',
-        'model',
-        'temperature',
-        'tools',
-        'permission',
-        'color',
-        'hidden',
-        'top_p',
-        'steps',
-        'prompt',
-        'disable',
-    ]);
-    const unknownKeys = Object.keys(fm).filter((k) => !knownKeys.has(k));
-    return {
-        name: typeof fm.name === 'string' ? fm.name : filenameName,
-        description: typeof fm.description === 'string' ? fm.description : '(no description)',
-        sourceFormat,
-        sourcePath: filePath,
-        mode,
-        model: typeof fm.model === 'string' ? fm.model : null,
-        temperature: typeof fm.temperature === 'number' ? fm.temperature : null,
-        tools,
-        permission: typeof fm.permission === 'object' && fm.permission !== null ? fm.permission : null,
-        color: typeof fm.color === 'string' ? fm.color : null,
-        hidden: fm.hidden === true,
-        body,
-        unknownKeys,
-    };
-}
-/** All locations to scan, in precedence order (later overrides earlier on name conflict).
- *  Dedupes the dir list — when cwd == homeDir, project + global paths collapse and we
- *  shouldn't double-count files. Test isolation also relies on this (homeDir override
- *  to a project root). */
-function agentDirsToScan(cwd, homeOverride) {
-    const home = homeOverride ?? homedir();
-    const dirs = [
-        { dir: join(home, '.claude/agents'), defaultFormat: 'claude' },
-        { dir: join(home, '.opencode/agents'), defaultFormat: 'opencode' },
-        { dir: join(home, '.codehere/agents'), defaultFormat: 'codehere' },
-    ];
-    if (cwd) {
-        dirs.push({ dir: join(cwd, '.claude/agents'), defaultFormat: 'claude' });
-        dirs.push({ dir: join(cwd, '.opencode/agents'), defaultFormat: 'opencode' });
-        dirs.push({ dir: join(cwd, '.codehere/agents'), defaultFormat: 'codehere' });
-    }
-    // Dedupe by dir path (preserves order — first occurrence wins)
-    const seen = new Set();
-    return dirs.filter((d) => {
-        if (seen.has(d.dir))
-            return false;
-        seen.add(d.dir);
-        return true;
-    });
-}
-/** Read all cross-tool agent definitions from global + project dirs.  Idempotent + cheap (~10ms for ~20 files); safe to call on every readiness query.
- *
- * @param cwd Project working directory whose .claude/.opencode/.codehere agents subdirs to scan
- * @param options.homeDir Override home directory (testing only — production uses homedir())
- */
-export function readCrossToolAgents(cwd, options) {
-    const byName = new Map();
-    let filesParsed = 0;
-    let filesSkippedNoFrontmatter = 0;
-    let filesSkippedParseError = 0;
-    let nameCollisions = 0;
-    const dirs = agentDirsToScan(cwd, options?.homeDir);
-    for (const { dir, defaultFormat } of dirs) {
-        for (const filePath of listMdFilesRecursive(dir)) {
-            let agent;
-            try {
-                agent = parseAgentFile(filePath, defaultFormat);
-            }
-            catch {
-                filesSkippedParseError++;
-                continue;
-            }
-            if (!agent) {
-                filesSkippedNoFrontmatter++;
-                continue;
-            }
-            filesParsed++;
-            if (byName.has(agent.name))
-                nameCollisions++;
-            byName.set(agent.name, agent); // later wins
-        }
-    }
-    return {
-        agents: [...byName.values()].sort((a, b) => a.name.localeCompare(b.name)),
-        diagnostics: {
-            sourcesScanned: dirs.length,
-            filesParsed,
-            filesSkippedNoFrontmatter,
-            filesSkippedParseError,
-            nameCollisions,
-        },
-    };
-}
-//# sourceMappingURL=cross-tool-agents.js.map

package/dist/infrastructure/storage/project-thread-migration.js

@@ -1,237 +0,0 @@
-/**
- * Project thread migration — sessions.jsonl → projects/<slug>/thread.jsonl.
- *
- * v0.6.0 M1+M7 foundation. The new schema groups sessions by their cwd
- * (project) so the persistent project thread shape (one continuous chat per
- * project) has a place to live. The original sessions.jsonl is preserved
- * for one release as back-compat.
- *
- * Built from Spike-1 prototype (agent/spike/v0.6.0-migrate-sessions-to-threads.mjs).
- * Spike validated lossless + reversible on 612 real sessions in 5ms.
- *
- * Production additions over the spike:
- *   - Atomic per-project writes (.tmp + rename) so partial failures don't
- *     leave half-written thread.jsonl files
- *   - Idempotent: skips writing if target thread.jsonl already exists
- *     (re-run on daemon start is safe)
- *   - Temp-dir filter: skips /tmp/, /var/folders/, /private/var/folders/ by
- *     default (configurable) — these are test artifacts, not real projects
- *   - Abandoned-session marker: sessions with no completed event get
- *     status='abandoned' instead of silent null
- *   - Configurable input/output paths so tests can use temp fixtures
- *
- * NOT in scope for this module (handled by callers):
- *   - CLI interface (codehere migrate-threads — TBD subcommand)
- *   - Auto-run on daemon start
- *   - Forward-mirroring (writing to thread.jsonl alongside sessions.jsonl
- *     during normal daemon operation)
- *
- * See docs/research/v0.6.0-spike-1-migration.md for the validation history.
- */
-import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync, readdirSync, renameSync } from 'fs';
-import { join } from 'path';
-import { createHash } from 'crypto';
-/** Path patterns considered ephemeral and skipped from project list. */
-const DEFAULT_TEMP_DIR_PATTERNS = [/^\/tmp\//, /^\/var\/folders\//, /^\/private\/var\/folders\//, /^\/private\/tmp\//];
-/** sha1(cwd)[:12] — stable, short, filesystem-safe. */
-function slugForCwd(cwd, unknownLabel) {
-    if (!cwd)
-        return unknownLabel;
-    return createHash('sha1').update(cwd).digest('hex').slice(0, 12);
-}
-function isTempDir(cwd) {
-    if (!cwd)
-        return false;
-    return DEFAULT_TEMP_DIR_PATTERNS.some((re) => re.test(cwd));
-}
-/** Read JSONL events; tolerate malformed lines (count + skip). */
-function readEvents(path) {
-    if (!existsSync(path))
-        return { events: [], malformed: 0 };
-    const text = readFileSync(path, 'utf-8');
-    const lines = text.split('\n').filter((l) => l.trim());
-    const events = [];
-    let malformed = 0;
-    for (const line of lines) {
-        try {
-            events.push(JSON.parse(line));
-        }
-        catch {
-            malformed++;
-        }
-    }
-    return { events, malformed };
-}
-/** Roll up event-log entries into one record per session. */
-function rollupSessions(events) {
-    const byId = new Map();
-    const completedIds = new Set();
-    for (const e of events) {
-        const id = (e.id ?? e.sessionId);
-        if (!id)
-            continue;
-        if (e.t === 'completed' || e.completedAt !== undefined)
-            completedIds.add(id);
-        const existing = byId.get(id) ?? { id, abandoned: true };
-        const existingAny = existing;
-        for (const k of [
-            'agent',
-            'prompt',
-            'cwd',
-            'startedAt',
-            'status',
-            'durationMs',
-            'completedAt',
-            'steps',
-            'artifacts',
-        ]) {
-            if (e[k] !== undefined && existingAny[k] === undefined) {
-                existingAny[k] = e[k];
-            }
-        }
-        byId.set(id, existing);
-    }
-    // Mark abandoned (sessions with no completed event)
-    for (const s of byId.values()) {
-        s.abandoned = !completedIds.has(s.id);
-        if (s.abandoned && !s.status)
-            s.status = 'abandoned';
-    }
-    return [...byId.values()];
-}
-function groupByCwd(sessions, unknownLabel) {
-    const groups = new Map();
-    for (const s of sessions) {
-        const cwd = s.cwd ?? null;
-        const slug = slugForCwd(cwd, unknownLabel);
-        const group = groups.get(slug) ?? { slug, cwd, sessions: [] };
-        group.sessions.push(s);
-        groups.set(slug, group);
-    }
-    return [...groups.values()];
-}
-/** Atomic write: write to .tmp then rename. Caller ensures dir exists. */
-function atomicWriteFile(path, content) {
-    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
-    writeFileSync(tmp, content);
-    renameSync(tmp, path);
-}
-function buildThreadJsonl(group) {
-    const lines = [];
-    lines.push(JSON.stringify({
-        _meta: 'project',
-        slug: group.slug,
-        cwd: group.cwd,
-        sessionCount: group.sessions.length,
-        migratedFrom: 'sessions.jsonl',
-        migratedAt: Date.now(),
-    }));
-    const sorted = [...group.sessions].sort((a, b) => (a.startedAt ?? 0) - (b.startedAt ?? 0));
-    for (const s of sorted) {
-        lines.push(JSON.stringify({
-            type: 'task',
-            sessionId: s.id,
-            agent: s.agent,
-            prompt: s.prompt,
-            cwd: s.cwd,
-            startedAt: s.startedAt,
-            status: s.status,
-            durationMs: s.durationMs,
-            completedAt: s.completedAt,
-            steps: s.steps,
-            artifacts: s.artifacts,
-        }));
-    }
-    return lines.join('\n') + '\n';
-}
-/**
- * Run the migration. Idempotent: skips projects whose thread.jsonl already
- * exists (so daemon-startup auto-runs are safe).
- */
-export function migrate(options) {
-    const startedAt = Date.now();
-    const skipTempDirs = options.skipTempDirs ?? true;
-    const unknownLabel = options.unknownCwdLabel ?? 'unknown';
-    const { events } = readEvents(options.sourceJsonl);
-    const sessions = rollupSessions(events);
-    const groups = groupByCwd(sessions, unknownLabel);
-    let threadsWritten = 0;
-    let threadsSkippedExisting = 0;
-    let unknownCwdSessions = 0;
-    const abandonedSessions = sessions.filter((s) => s.abandoned).length;
-    let tempDirSessionsSkipped = 0;
-    for (const group of groups) {
-        if (skipTempDirs && isTempDir(group.cwd)) {
-            tempDirSessionsSkipped += group.sessions.length;
-            continue;
-        }
-        if (group.cwd === null)
-            unknownCwdSessions += group.sessions.length;
-        const dir = join(options.targetDir, group.slug);
-        const threadFile = join(dir, 'thread.jsonl');
-        if (existsSync(threadFile)) {
-            threadsSkippedExisting++;
-            continue;
-        }
-        mkdirSync(dir, { recursive: true });
-        atomicWriteFile(threadFile, buildThreadJsonl(group));
-        threadsWritten++;
-    }
-    return {
-        sessionsProcessed: sessions.length,
-        threadsWritten,
-        threadsSkippedExisting,
-        unknownCwdSessions,
-        abandonedSessions,
-        tempDirSessionsSkipped,
-        durationMs: Date.now() - startedAt,
-    };
-}
-/** Dry-run: same as migrate but writes nothing. Returns what WOULD happen. */
-export function dryRun(options) {
-    const startedAt = Date.now();
-    const skipTempDirs = options.skipTempDirs ?? true;
-    const unknownLabel = options.unknownCwdLabel ?? 'unknown';
-    const { events } = readEvents(options.sourceJsonl);
-    const sessions = rollupSessions(events);
-    const groups = groupByCwd(sessions, unknownLabel);
-    let threadsWritten = 0;
-    let threadsSkippedExisting = 0;
-    let unknownCwdSessions = 0;
-    const abandonedSessions = sessions.filter((s) => s.abandoned).length;
-    let tempDirSessionsSkipped = 0;
-    for (const group of groups) {
-        if (skipTempDirs && isTempDir(group.cwd)) {
-            tempDirSessionsSkipped += group.sessions.length;
-            continue;
-        }
-        if (group.cwd === null)
-            unknownCwdSessions += group.sessions.length;
-        const threadFile = join(options.targetDir, group.slug, 'thread.jsonl');
-        if (existsSync(threadFile))
-            threadsSkippedExisting++;
-        else
-            threadsWritten++;
-    }
-    return {
-        sessionsProcessed: sessions.length,
-        threadsWritten,
-        threadsSkippedExisting,
-        unknownCwdSessions,
-        abandonedSessions,
-        tempDirSessionsSkipped,
-        durationMs: Date.now() - startedAt,
-    };
-}
-/**
- * Rollback: removes the projects directory. Source sessions.jsonl is never
- * touched. Returns the count of removed project subdirectories.
- */
-export function rollback(targetDir) {
-    if (!existsSync(targetDir))
-        return { removedDirs: 0 };
-    const subdirs = readdirSync(targetDir);
-    rmSync(targetDir, { recursive: true });
-    return { removedDirs: subdirs.length };
-}
-//# sourceMappingURL=project-thread-migration.js.map