codehere 0.5.0-alpha.3 → 0.5.0-alpha.5

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

@@ -0,0 +1,251 @@
+/**
+ * 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 = null;
+            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

@@ -0,0 +1,232 @@
+/**
+ * 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;
+    let 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;
+    let 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

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

@@ -0,0 +1,159 @@
+/**
+ * Project thread forward-mirror — writes new sessions to per-project
+ * thread.jsonl alongside sessions.jsonl during normal daemon operation.
+ *
+ * v0.6.0 M1+M7 — companion to project-thread-migration.ts:
+ *   - Migration handles HISTORICAL data (sessions.jsonl → projects/<slug>/thread.jsonl)
+ *   - This handles NEW data (every spawn + completion writes to BOTH)
+ *
+ * Without this, the project threads created by migration are a one-time
+ * snapshot. With this, every new session lands in both formats and the
+ * project thread stays current as users work. UI restructure (next milestone)
+ * then renders thread.jsonl as the primary view.
+ *
+ * Write pattern matches session-persistence.ts:
+ *   - Append-only (no rewrites; lock-free single writer)
+ *   - Best-effort (failures don't break the spawn path)
+ *   - Each session writes TWO entries over its lifetime:
+ *     1. On spawn:    { type: 'task', sessionId, agent, prompt, cwd, startedAt, status: 'running' }
+ *     2. On complete: { type: 'task', sessionId, status, durationMs, completedAt, steps, artifacts }
+ *   - Reader reconstructs by sessionId (later entry overrides earlier) — same
+ *     shape as project-thread-migration.ts output.
+ *
+ * Filtering matches migration defaults:
+ *   - Temp dirs (/tmp, /var/folders, /private/var/folders, /private/tmp) skipped
+ *   - NULL cwd → 'unknown' bucket
+ *
+ * Iter 13 — built after v0.5.0-alpha.4 ship. Previously the only way new
+ * sessions reached thread.jsonl was to re-run migration; this closes the gap.
+ */
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { createHash } from 'crypto';
+const PROJECTS_DIR = join(homedir(), '.codehere', 'projects');
+/** Match migration module's defaults. Same regex set kept in sync. */
+const TEMP_DIR_PATTERNS = [
+    /^\/tmp\//,
+    /^\/var\/folders\//,
+    /^\/private\/var\/folders\//,
+    /^\/private\/tmp\//,
+];
+function isTempDir(cwd) {
+    if (!cwd)
+        return false;
+    return TEMP_DIR_PATTERNS.some((re) => re.test(cwd));
+}
+function slugForCwd(cwd) {
+    if (!cwd)
+        return 'unknown';
+    return createHash('sha1').update(cwd).digest('hex').slice(0, 12);
+}
+function ensureProjectDir(slug) {
+    const dir = join(PROJECTS_DIR, slug);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function appendThreadEntry(slug, entry) {
+    // Returns true if this write SEEDED the file (first time creation), false otherwise.
+    // Caller (mirrorSpawnedToThread) uses this signal to fire the hidden Title agent.
+    try {
+        const dir = ensureProjectDir(slug);
+        const file = join(dir, 'thread.jsonl');
+        let seeded = false;
+        if (!existsSync(file)) {
+            const meta = JSON.stringify({
+                _meta: 'project',
+                slug,
+                cwd: null, // populated by migration; forward-mirror writes the cwd in each task entry
+                sessionCount: 0,
+                title: null, // populated by hidden Title agent (v0.6.0 M9) on first task entry
+                migratedFrom: 'forward-mirror',
+                migratedAt: Date.now(),
+            });
+            appendFileSync(file, meta + '\n', 'utf-8');
+            seeded = true;
+        }
+        appendFileSync(file, JSON.stringify(entry) + '\n', 'utf-8');
+        return seeded;
+    }
+    catch {
+        // Best-effort. Mirror failures must never break the spawn or completion
+        // path — sessions.jsonl is the canonical store; thread.jsonl is derived.
+        return false;
+    }
+}
+/** Append a project-meta update line (used by Title agent to set the title). */
+function appendMetaUpdate(slug, partial) {
+    try {
+        const dir = ensureProjectDir(slug);
+        const file = join(dir, 'thread.jsonl');
+        if (!existsSync(file))
+            return; // can't update what doesn't exist
+        appendFileSync(file, JSON.stringify({ _meta: 'project-update', slug, ...partial, updatedAt: Date.now() }) + '\n', 'utf-8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Mirror a spawn event to the project thread. Skips temp-dir cwds (matches
+ * migration defaults) so test-artifact dirs don't pollute the project list.
+ *
+ * If this spawn is the FIRST task in a brand-new project (i.e., thread.jsonl
+ * just got seeded), fire the hidden Title agent (v0.6.0 M9) in the background
+ * to generate a 4-6 word title from the first user prompt. The title appears
+ * in the project-meta as a 'project-update' record; readers take the latest
+ * value. Title generation is best-effort and silent on failure.
+ */
+export function mirrorSpawnedToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    const seeded = appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.sessionId,
+        agent: rec.agent,
+        prompt: rec.prompt,
+        cwd: rec.cwd,
+        startedAt: rec.startedAt,
+        status: 'running',
+    });
+    if (seeded && process.env.CODEHERE_DISABLE_TITLE_AGENT !== '1') {
+        // Fire Title agent in background; do not block the spawn path. Lazy-import
+        // to avoid loading the LLM module on every spawn when not needed.
+        void (async () => {
+            try {
+                const { generateThreadTitle } = await import('../../application/use-cases/generate-thread-title.js');
+                const title = await generateThreadTitle(rec.prompt, rec.cwd);
+                if (title) {
+                    appendMetaUpdate(slug, { title, cwd: rec.cwd });
+                }
+            }
+            catch {
+                // best-effort
+            }
+        })();
+    }
+}
+/**
+ * Mirror a completion event to the project thread. Same skip rules as spawn.
+ * Reader reconstructs by sessionId — this entry's fields override the spawn
+ * entry's where they overlap (status flips from 'running' to actual final).
+ */
+export function mirrorCompletedToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.sessionId,
+        status: rec.status,
+        durationMs: rec.durationMs,
+        completedAt: rec.completedAt,
+        steps: rec.steps,
+        artifacts: rec.artifacts,
+    });
+}
+//# sourceMappingURL=project-thread-mirror.js.map