codehere 0.5.0-alpha.3 → 0.5.0-alpha.4

package/dist/index.js

@@ -14,6 +14,7 @@ import { Command } from 'commander';
 import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { homedir } from 'os';
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeInitCommand } from './presentation/cli/commands/init-command.js';
 import { executeMemoryCommand } from './presentation/cli/commands/memory-command.js';
@@ -428,6 +429,25 @@ program
         }
     };
     try {
+        // v0.6.0 M1+M7 — migrate sessions.jsonl → ~/.codehere/projects/<slug>/thread.jsonl
+        // on daemon start. Idempotent: skips projects whose thread.jsonl already exists,
+        // so this is safe to run on every boot. Opt-out via CODEHERE_DISABLE_THREAD_MIGRATION=1.
+        // Failures are non-blocking — back-compat to v0.5 sessions.jsonl is preserved.
+        if (process.env.CODEHERE_DISABLE_THREAD_MIGRATION !== '1') {
+            try {
+                const { migrate } = await import('./infrastructure/storage/project-thread-migration.js');
+                const result = migrate({
+                    sourceJsonl: join(homedir(), '.codehere/sessions.jsonl'),
+                    targetDir: join(homedir(), '.codehere/projects'),
+                });
+                if (result.threadsWritten > 0) {
+                    console.log(colors.dim(`  v0.6 migration: created ${result.threadsWritten} project thread(s) from ${result.sessionsProcessed} sessions (${result.durationMs}ms)`));
+                }
+            }
+            catch (err) {
+                console.warn(colors.dim(`  v0.6 migration skipped: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
         const server = startMCPServer({ port, host });
         // Wait for the server to either start listening or fail. The default
@@ -597,6 +617,41 @@ program
         r.end();
     });
 });
+// ── migrate-threads — v0.6.0 schema migration sessions.jsonl → projects/<slug>/thread.jsonl
+program
+    .command('migrate-threads', { hidden: true }) // hidden from --help (v0.6.0 internal — auto-runs on daemon start once wired)
+    .description('Migrate sessions.jsonl into per-project thread.jsonl files (v0.6.0 schema)')
+    .option('--source <path>', 'Source sessions.jsonl', `${homedir()}/.codehere/sessions.jsonl`)
+    .option('--target <dir>', 'Target projects dir', `${homedir()}/.codehere/projects`)
+    .option('--dry-run', 'Report what migrate WOULD do, write nothing', false)
+    .option('--rollback', 'Remove the projects dir; sessions.jsonl untouched', false)
+    .option('--keep-temp-dirs', 'Include /tmp + /var/folders cwds (default skips them)', false)
+    .action(async (options) => {
+    const { migrate, dryRun, rollback } = await import('./infrastructure/storage/project-thread-migration.js');
+    if (options.rollback) {
+        const r = rollback(options.target);
+        console.log(`Rollback: removed ${r.removedDirs} project dir(s) from ${options.target}`);
+        console.log(`Source ${options.source} untouched.`);
+        return;
+    }
+    const fn = options.dryRun ? dryRun : migrate;
+    const label = options.dryRun ? 'DRY RUN' : 'MIGRATION';
+    const result = fn({
+        sourceJsonl: options.source,
+        targetDir: options.target,
+        skipTempDirs: !options.keepTempDirs,
+    });
+    console.log(`=== ${label} ===`);
+    console.log(`  source:                  ${options.source}`);
+    console.log(`  target:                  ${options.target}`);
+    console.log(`  sessions processed:      ${result.sessionsProcessed}`);
+    console.log(`  threads ${options.dryRun ? 'would write' : 'written'}:   ${result.threadsWritten}`);
+    console.log(`  threads skipped (exist): ${result.threadsSkippedExisting}`);
+    console.log(`  unknown-cwd sessions:    ${result.unknownCwdSessions}`);
+    console.log(`  abandoned sessions:      ${result.abandonedSessions}`);
+    console.log(`  temp-dir sessions skipped: ${result.tempDirSessionsSkipped}`);
+    console.log(`  duration:                ${result.durationMs}ms`);
+});
 // ── scan-tool (called by Claude Code hooks system, not users directly) ───────
 program
     .command('scan-tool', { hidden: true }) // hidden from --help (May 2 cut: internal hook handler, called by Claude Code via stdin)

package/dist/infrastructure/orchestration/claude-code-adapter.js

@@ -221,6 +221,12 @@ export function spawnClaudeCode(prompt, options = {}) {
     }
     // ── stdout: newline-delimited JSON from `--output-format stream-json` ────────
     let stdoutBuf = '';
+    // Iter 13 — capture the claude-internal session_id from the init event so
+    // appendMessage can use `--resume <session-id>` (reliable) instead of `-c`
+    // (which picks "most recent in cwd" and can collide with other concurrent
+    // claude sessions OR with conversations containing thinking blocks the
+    // headless API can't replay).
+    let claudeSessionId;
     child.stdout?.on('data', (chunk) => {
         stdoutBuf += chunk.toString('utf-8');
         let idx;
@@ -231,6 +237,12 @@ export function spawnClaudeCode(prompt, options = {}) {
                 continue;
             try {
                 const data = JSON.parse(line);
+                if (claudeSessionId === undefined &&
+                    data.type === 'system' &&
+                    data.subtype === 'init' &&
+                    typeof data.session_id === 'string') {
+                    claudeSessionId = data.session_id;
+                }
                 emit({ type: data.type ?? 'message', timestamp: Date.now(), data });
             }
             catch {
@@ -319,20 +331,31 @@ export function spawnClaudeCode(prompt, options = {}) {
             }, 3000);
         },
         /**
-         * Iter 12 — follow-up message to a completed session. Spawns a fresh
-         * `claude -p "<text>" -c` in the same cwd, which uses Claude Code's
-         * native -c flag to continue the most recent conversation in that dir.
+         * Iter 12 (with iter-13 fix) — follow-up message to a completed session.
+         *
+         * Iter 12 used `claude -p "<text>" -c` which picks "most recent
+         * conversation in current directory". Iter 13 dogfood proved this
+         * fragile: in a cwd with multiple concurrent claude sessions OR with
+         * conversations containing thinking blocks, -c either picks the wrong
+         * session or hits an API-replay error ("Invalid signature in thinking
+         * block"). Fix: capture the claude session_id from this session's init
+         * event (above) and use `--resume <session-id>` for follow-ups —
+         * unambiguous and replay-safe.
          *
-         * Scope: one-shot Q&A. No streaming, no event piping into the parent
-         * emitter. Returns the assistant's response text. Iter 13 may upgrade
-         * to a true thread-streaming model if the dogfood signal warrants.
+         * Scope: still one-shot Q&A. No streaming. Returns assistant's response
+         * text. If we never captured a session_id (init event never fired —
+         * shouldn't happen in healthy claude runs), reject explicitly.
          */
         appendMessage(text) {
             const startedAt = Date.now();
             return new Promise((resolve, reject) => {
+                if (!claudeSessionId) {
+                    reject(new Error('Cannot reply: original claude session_id was never captured (init event missed)'));
+                    return;
+                }
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('claude', ['-p', text, '-c', ...HEADLESS_FLAGS], {
+                const followup = spawn('claude', ['-p', text, '--resume', claudeSessionId, ...HEADLESS_FLAGS], {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -538,6 +538,11 @@ export function startMCPServer(options = {}) {
                             startedAt: session.startedAt,
                             status: session.status,
                             agent: session.agent,
+                            // Iter 13 — include canAppendMessage so the freshly-attached
+                            // session card can correctly enable/disable reply input on the
+                            // first render. Without this, ALL just-spawned sessions render
+                            // with reply disabled even when the adapter supports it.
+                            canAppendMessage: session.canAppendMessage === true,
                         }));
                     }
                     catch (e) {

package/dist/infrastructure/protocols/ui-page.js

@@ -1212,7 +1212,7 @@ ${SHARED_STYLES}
       </div>
     </div>
   </div>
-  <button class="pane-add" type="button" id="new-project-btn" title="Set a new working folder for the next task">+ New project</button>
+  <!-- intentionally empty: multi-project sidebar arrives in v0.6.x -->
 </aside>
 
 <section class="thread-pane">
@@ -1569,22 +1569,10 @@ ${SHARED_STYLES}
     localStorage.setItem('codehere:cwd', cwdInput.value.trim());
   });
 
-  // Iter 12 — "+ New project" button now wired. Previously dead chrome with
-  // title="Coming soon". Multi-project sidebar is iter 13+; for now the button
-  // does the simplest useful thing: clear the cwd input + scroll-and-focus
-  // so the user can type a new folder path. The intake form's existing Assign
-  // flow handles spawning the task in that path.
-  const newProjectBtn = document.getElementById('new-project-btn');
-  if (newProjectBtn) {
-    newProjectBtn.addEventListener('click', () => {
-      cwdInput.value = '';
-      localStorage.removeItem('codehere:cwd');
-      // Smooth-scroll the intake form into view (project sidebar is on the left,
-      // intake is on the right; on narrow screens the user might be scrolled).
-      try { cwdInput.scrollIntoView({ behavior: 'smooth', block: 'center' }); } catch { /* old browsers */ }
-      cwdInput.focus();
-    });
-  }
+  // Iter 13 — sidebar 'add project' button + handler removed (was iter 12 work).
+  // The handler cleared cwd input + scrolled + focused, but the label promised
+  // a new sidebar entry that we do not ship until v0.6.x multi-project work.
+  // Mismatch caused real founder confusion in iter-13 tasting. Removed cleanly.
 
   // Gate A1: starter-prompt chips prefill the textarea + focus it so the user
   // can edit or hit ⌘-Enter immediately. No scroll-jumping, no redirect.
@@ -2230,7 +2218,7 @@ ${SHARED_STYLES}
       });
       const data = await res.json();
       if (!res.ok) { alert('Failed: ' + (data.error || res.status)); return; }
-      attachSession({ sessionId: data.sessionId, prompt, startedAt: data.startedAt, status: data.status, agent: data.agent || agent || 'conductor' });
+      attachSession({ sessionId: data.sessionId, prompt, startedAt: data.startedAt, status: data.status, agent: data.agent || agent || 'conductor', canAppendMessage: data.canAppendMessage === true });
       promptEl.value = '';
     } catch (e) {
       alert('Network error: ' + (e && e.message ? e.message : e));

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.5.0-alpha.3",
+  "version": "0.5.0-alpha.4",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, OpenCode, Gemini, and any user-configured CLI agent from one local web UI — every AI action traced, every file scored, every spawn warmed with project memory.",
   "main": "dist/index.js",
   "type": "module",