codehere 0.8.0 → 1.0.1

package/dist/infrastructure/orchestration/session-persistence.js

@@ -27,15 +27,48 @@ function sessionsFile() {
     // so a scratch home isolates sessions for dogfooding / the mock harness.
     return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
 }
-function ensureDir() {
-    const dir = dirname(sessionsFile());
+/**
+ * A session's records must all land in the SAME file: the one resolved when it
+ * was spawned. sessionsFile() reads env per-call, so a write that fires after
+ * the environment moved on (async exit handlers; test suites that swap
+ * CODEHERE_HOME per test) would otherwise scatter a session across homes —
+ * the failover-skip flake forensics caught exactly this shape (a slow
+ * real-claude exit record from another test's home, spawned-record absent —
+ * full record in commit message). Spawn binds the
+ * path; completed/finalReport reuse it. FIFO-capped — eviction only means a
+ * later write falls back to the env-resolved path (prod-identical: the
+ * daemon's home never changes mid-run).
+ */
+const sessionFileById = new Map();
+const SESSION_FILE_CAP = 500;
+function bindSessionFile(id) {
+    const file = sessionsFile();
+    if (sessionFileById.size >= SESSION_FILE_CAP) {
+        const oldest = sessionFileById.keys().next().value;
+        if (oldest !== undefined)
+            sessionFileById.delete(oldest);
+    }
+    sessionFileById.set(id, file);
+    return file;
+}
+function fileForSession(id) {
+    return sessionFileById.get(id) ?? sessionsFile();
+}
+function ensureDirFor(file) {
+    const dir = dirname(file);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
 }
 export function appendSpawned(rec) {
     try {
-        ensureDir();
-        appendFileSync(sessionsFile(), JSON.stringify({ t: 'spawned', ...rec }) + '\n', 'utf-8');
+        const file = bindSessionFile(rec.id);
+        ensureDirFor(file);
+        // S18 · practice is a property of the RUN, stamped once on the durable
+        // record at spawn — never re-derived from a later daemon's env. Seeded
+        // demo-* showcases keep their FEATURED meaning even if seeded under mock.
+        const mockDaemon = process.env.CODEHERE_MOCK === '1' || process.env.CODEHERE_MOCK === 'true';
+        const mockRun = mockDaemon && !rec.id.startsWith('demo-');
+        appendFileSync(file, JSON.stringify({ t: 'spawned', ...rec, mockRun }) + '\n', 'utf-8');
     }
     catch {
         /* persistence is best-effort; never break the spawn path */
@@ -43,8 +76,9 @@ export function appendSpawned(rec) {
 }
 export function appendCompleted(rec) {
     try {
-        ensureDir();
-        appendFileSync(sessionsFile(), JSON.stringify({ t: 'completed', ...rec }) + '\n', 'utf-8');
+        const file = fileForSession(rec.id);
+        ensureDirFor(file);
+        appendFileSync(file, JSON.stringify({ t: 'completed', ...rec }) + '\n', 'utf-8');
     }
     catch {
         /* best-effort */
@@ -62,10 +96,35 @@ export function appendCompleted(rec) {
  * Append-only: Final Report fires AFTER the CompletedRecord (generateFinalReport
  * is async post-exit), so it gets its own record type. Reader merges by id.
  */
+/** S3 · persist the human's "mark resolved" ack so it sticks across reload.
+ *  Append-only like every other record; reader merges by id (last wins). */
+export function appendResolved(rec) {
+    try {
+        const file = fileForSession(rec.id);
+        ensureDirFor(file);
+        appendFileSync(file, JSON.stringify({ t: 'resolved', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* best-effort */
+    }
+}
 export function appendFinalReport(rec) {
     try {
-        ensureDir();
-        appendFileSync(sessionsFile(), JSON.stringify({ t: 'finalReport', ...rec }) + '\n', 'utf-8');
+        const file = fileForSession(rec.id);
+        ensureDirFor(file);
+        appendFileSync(file, JSON.stringify({ t: 'finalReport', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Tier 2.2 · persist the audit↔disk reconciliation so the OBSERVED signal
+ *  survives a daemon restart (mirrors appendFinalReport's async-post-exit shape). */
+export function appendAuditRecon(id, recon) {
+    try {
+        const file = fileForSession(id);
+        ensureDirFor(file);
+        appendFileSync(file, JSON.stringify({ t: 'audit-recon', id, recon }) + '\n', 'utf-8');
     }
     catch {
         /* best-effort */
@@ -95,6 +154,27 @@ export function appendFinalReport(rec) {
  * the CLI · git's `--abbrev-commit` collisions are very rare in practice
  * for our id space.
  */
+/** S18 · classification for the joined record. The run-time stamp wins. For
+ *  LEGACY records written before the stamp existed, the mock adapter leaves
+ *  two durable on-record signals, and either proves the run was practice:
+ *  (1) it mints its own resume tokens "mock-…" (mock-agent-repl.ts) — a real
+ *  vendor CLI never does; (2) its ONLY edit artifact is the hardcoded,
+ *  gitignored `codehere-mock-change.md` (MOCK_EDIT_FILE) — conductor practice
+ *  runs carry no resume token but their steps touched it. Classified on read
+ *  so pre-stamp practice never renders as the founder's real work. demo-*
+ *  showcases keep their FEATURED meaning. Records with neither stamp nor
+ *  signal stay undefined (the reader's env fallback — genuinely no signal). */
+function recordedMockRun(s, c) {
+    if (s.mockRun !== undefined)
+        return s.mockRun;
+    if (s.id.startsWith('demo-'))
+        return undefined;
+    if (c.nativeSessionId?.startsWith('mock-'))
+        return true;
+    if (c.steps?.some((st) => st.label?.includes('codehere-mock-change.md')))
+        return true;
+    return undefined;
+}
 export function loadSessionById(idOrPrefix) {
     const file = sessionsFile();
     if (!existsSync(file))
@@ -109,6 +189,8 @@ export function loadSessionById(idOrPrefix) {
     const spawned = new Map();
     const completed = [];
     const finalReports = new Map();
+    const resolved = new Map();
+    const auditRecons = new Map();
     for (const line of content.split('\n')) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -126,6 +208,10 @@ export function loadSessionById(idOrPrefix) {
             completed.push(rec);
         else if (rec.t === 'finalReport')
             finalReports.set(rec.id, rec);
+        else if (rec.t === 'resolved')
+            resolved.set(rec.id, rec.resolvedAt);
+        else if (rec.t === 'audit-recon')
+            auditRecons.set(rec.id, rec.recon);
     }
     // Newest-first to break prefix-collision ties toward the most recent
     for (let i = completed.length - 1; i >= 0; i--) {
@@ -136,6 +222,7 @@ export function loadSessionById(idOrPrefix) {
         if (!s)
             continue;
         const fr = finalReports.get(c.id);
+        const mockRun = recordedMockRun(s, c);
         const failoverFrom = c.failoverFrom ?? s.failoverFrom;
         const failoverTo = c.failoverTo ?? s.failoverTo;
         const failoverReason = c.failoverReason ?? s.failoverReason;
@@ -151,12 +238,32 @@ export function loadSessionById(idOrPrefix) {
             steps: c.steps,
             artifacts: c.artifacts,
             ...(c.turns ? { turns: c.turns } : {}),
-            ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs, source: fr.source } } : {}),
+            ...(fr
+                ? {
+                    finalReport: {
+                        summary: fr.summary,
+                        generatedAt: fr.generatedAt,
+                        durationMs: fr.durationMs,
+                        source: fr.source,
+                    },
+                }
+                : {}),
             ...(failoverFrom ? { failoverFrom } : {}),
             ...(failoverTo ? { failoverTo } : {}),
             ...(failoverReason ? { failoverReason } : {}),
             ...(s.failoverAt ? { failoverAt: s.failoverAt } : {}),
             ...(c.stalledReason ? { stalledReason: c.stalledReason } : {}),
+            ...(s.batchId ? { batchId: s.batchId } : {}),
+            ...(c.delegatedTo ? { delegatedTo: c.delegatedTo } : {}),
+            ...(c.nativeSessionId ? { nativeSessionId: c.nativeSessionId } : {}),
+            ...(c.delegateSessionId ? { delegateSessionId: c.delegateSessionId } : {}),
+            ...(auditRecons.get(c.id) ? { auditRecon: auditRecons.get(c.id) } : {}),
+            ...(s.importedFrom ? { importedFrom: s.importedFrom } : {}),
+            ...(s.importAudit ? { importAudit: s.importAudit } : {}),
+            ...(s.parentSessionId ? { parentSessionId: s.parentSessionId } : {}),
+            ...(s.isReview ? { isReview: true } : {}),
+            ...(resolved.has(c.id) ? { resolvedAt: resolved.get(c.id) } : {}),
+            ...(mockRun !== undefined ? { mockRun } : {}),
             provenance: 'persisted',
         };
     }
@@ -178,6 +285,8 @@ export function loadRecent(limit = 20) {
     /** v0.6.x — Final Reports keyed by sessionId. Last write wins
      *  (rare in practice; reports fire once per session). */
     const finalReports = new Map();
+    const resolved = new Map();
+    const auditRecons = new Map();
     for (const line of content.split('\n')) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -195,41 +304,68 @@ export function loadRecent(limit = 20) {
             completed.push(rec);
         else if (rec.t === 'finalReport')
             finalReports.set(rec.id, rec);
+        else if (rec.t === 'resolved')
+            resolved.set(rec.id, rec.resolvedAt);
+        else if (rec.t === 'audit-recon')
+            auditRecons.set(rec.id, rec.recon);
     }
     const merged = [];
     const includedIds = new Set();
-    const build = (c, s, fr) => ({
-        sessionId: s.id,
-        agent: s.agent,
-        prompt: s.prompt,
-        cwd: s.cwd,
-        startedAt: s.startedAt,
-        // BUG 2 (May 1 2026) — defensive normalization for zombie records.
-        // Pre-fix sessions persisted before commit <THIS> were written with
-        // status='running' even when their completed-record carried real
-        // durationMs/completedAt — the conductor adapter mirrored its status
-        // AFTER emitting the exit event. The fix at the source (conductor-
-        // adapter.ts) prevents new zombies; this normalization repairs old
-        // records on read so the UI doesn't show a "running" badge on a
-        // session that obviously finished. We have no ground truth on what
-        // the actual exit code WAS for these old records, so 'completed' is
-        // the safest default — they'd been displayed as completed in the UI
-        // had this been a session-manager.ts bug. Mark explicitly via a
-        // synthetic note so debug viewers can tell normalization happened.
-        status: c.status === 'running' && c.completedAt > 0 ? 'completed' : c.status,
-        durationMs: c.durationMs,
-        completedAt: c.completedAt,
-        steps: c.steps,
-        artifacts: c.artifacts,
-        ...(c.turns ? { turns: c.turns } : {}),
-        ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs, source: fr.source } } : {}),
-        ...((c.failoverFrom ?? s.failoverFrom) ? { failoverFrom: c.failoverFrom ?? s.failoverFrom } : {}),
-        ...((c.failoverTo ?? s.failoverTo) ? { failoverTo: c.failoverTo ?? s.failoverTo } : {}),
-        ...((c.failoverReason ?? s.failoverReason) ? { failoverReason: c.failoverReason ?? s.failoverReason } : {}),
-        ...(s.failoverAt ? { failoverAt: s.failoverAt } : {}),
-        ...(c.stalledReason ? { stalledReason: c.stalledReason } : {}),
-        provenance: 'persisted',
-    });
+    const build = (c, s, fr) => {
+        const mockRun = recordedMockRun(s, c);
+        return {
+            sessionId: s.id,
+            agent: s.agent,
+            prompt: s.prompt,
+            cwd: s.cwd,
+            startedAt: s.startedAt,
+            // BUG 2 (May 1 2026) — defensive normalization for zombie records.
+            // Pre-fix sessions persisted before commit <THIS> were written with
+            // status='running' even when their completed-record carried real
+            // durationMs/completedAt — the conductor adapter mirrored its status
+            // AFTER emitting the exit event. The fix at the source (conductor-
+            // adapter.ts) prevents new zombies; this normalization repairs old
+            // records on read so the UI doesn't show a "running" badge on a
+            // session that obviously finished. We have no ground truth on what
+            // the actual exit code WAS for these old records, so 'completed' is
+            // the safest default — they'd been displayed as completed in the UI
+            // had this been a session-manager.ts bug. Mark explicitly via a
+            // synthetic note so debug viewers can tell normalization happened.
+            status: c.status === 'running' && c.completedAt > 0 ? 'completed' : c.status,
+            durationMs: c.durationMs,
+            completedAt: c.completedAt,
+            steps: c.steps,
+            artifacts: c.artifacts,
+            ...(c.turns ? { turns: c.turns } : {}),
+            ...(fr
+                ? {
+                    finalReport: {
+                        summary: fr.summary,
+                        generatedAt: fr.generatedAt,
+                        durationMs: fr.durationMs,
+                        source: fr.source,
+                    },
+                }
+                : {}),
+            ...((c.failoverFrom ?? s.failoverFrom) ? { failoverFrom: c.failoverFrom ?? s.failoverFrom } : {}),
+            ...((c.failoverTo ?? s.failoverTo) ? { failoverTo: c.failoverTo ?? s.failoverTo } : {}),
+            ...((c.failoverReason ?? s.failoverReason) ? { failoverReason: c.failoverReason ?? s.failoverReason } : {}),
+            ...(s.failoverAt ? { failoverAt: s.failoverAt } : {}),
+            ...(c.stalledReason ? { stalledReason: c.stalledReason } : {}),
+            ...(s.batchId ? { batchId: s.batchId } : {}),
+            ...(c.delegatedTo ? { delegatedTo: c.delegatedTo } : {}),
+            ...(c.nativeSessionId ? { nativeSessionId: c.nativeSessionId } : {}),
+            ...(c.delegateSessionId ? { delegateSessionId: c.delegateSessionId } : {}),
+            ...(auditRecons.get(c.id) ? { auditRecon: auditRecons.get(c.id) } : {}),
+            ...(s.importedFrom ? { importedFrom: s.importedFrom } : {}),
+            ...(s.importAudit ? { importAudit: s.importAudit } : {}),
+            ...(s.parentSessionId ? { parentSessionId: s.parentSessionId } : {}),
+            ...(s.isReview ? { isReview: true } : {}),
+            ...(resolved.has(c.id) ? { resolvedAt: resolved.get(c.id) } : {}),
+            ...(mockRun !== undefined ? { mockRun } : {}),
+            provenance: 'persisted',
+        };
+    };
     // Walk completed in reverse so we return newest-first, up to `limit`.
     for (let i = completed.length - 1; i >= 0 && merged.length < limit; i--) {
         const c = completed[i];

package/dist/infrastructure/orchestration/thread-key-store.js

@@ -18,7 +18,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'f
 import { homedir } from 'os';
 import { join } from 'path';
 import { generateKeypair, exportPrivatePem, exportPublicPem, importPrivatePem, importPublicPem, publicKeyToBase64, } from '../../application/use-cases/thread-export.js';
-function keysDir() {
+export function keysDir() {
     const home = process.env.CODEHERE_HOME || homedir();
     return join(home, '.codehere', 'keys');
 }

package/dist/infrastructure/orchestration/write-pass-store.js

@@ -35,12 +35,4 @@ export function listForSession(sessionId) {
         .filter((s) => s.intent.sessionId === sessionId)
         .sort((a, b) => a.intent.emittedAt - b.intent.emittedAt);
 }
-/** Drop a pass · for tests + the "discard" admin action. */
-export function discard(passId) {
-    return store.delete(passId);
-}
-/** Test-only · clear the store between cases. */
-export function _resetForTests() {
-    store.clear();
-}
 //# sourceMappingURL=write-pass-store.js.map

package/dist/infrastructure/protocols/mcp-helpers.js

@@ -21,5 +21,5 @@ export function collectFilesForMCP(target) {
 }
 // ── Scoring ──────────────────────────────────────────────────────────────────
 // Re-export score function using the shared scorer
-export { scoreFile as scoreFileForMCP } from '../security/trust-scorer.js';
+export { scoreFile as scoreFileForMCP, aggregateTrust } from '../security/trust-scorer.js';
 //# sourceMappingURL=mcp-helpers.js.map