codehere 0.7.1 → 1.0.1

package/dist/application/use-cases/rerun-tests.js

@@ -0,0 +1,226 @@
+/**
+ * Tier 1.1 (verdict-trust punch list, 2026-06-09) · RE-RUN the tests, don't
+ * trust the agent's stdout.
+ *
+ * The gap this closes: `artifacts.tests` was regex-scraped from the AGENT's own
+ * captured stdout (`parseTestSummary(textAccum)`) and never re-executed — so
+ * "18/18 passed" was verified against the agent's own claim. A skeptic waves
+ * that off instantly. We already check FILE claims against ground truth
+ * (`git diff`); this extends the same "observe reality, don't trust the
+ * narration" rule to tests: codehere independently runs the project's test
+ * command on the real on-disk state and reads the REAL exit code.
+ *
+ * The authoritative signal is the EXIT CODE (a test runner exits non-zero on
+ * failure), not the scraped count — counts are display-only. So a report that
+ * claims "all tests pass" while the re-run exits non-zero becomes a caught lie
+ * (verify-claim flags it `broken` once `failed > 0`).
+ *
+ * Safe by construction: async (never blocks the daemon), timeout-bounded,
+ * opt-out via CODEHERE_RERUN_TESTS=0, and only ever runs the repo's OWN test
+ * script — strictly inside the trust boundary codehere already crosses by
+ * spawning agents that execute code in this repo.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseTestSummary } from '../../infrastructure/orchestration/artifacts-extractor.js';
+const DEFAULT_TIMEOUT_MS = Number(process.env.CODEHERE_RERUN_TIMEOUT_MS ?? 120_000);
+/** True if `file` exists in `cwd` and its text contains `needle` (case-insensitive). */
+function fileMentions(cwd, file, needle) {
+    try {
+        const p = join(cwd, file);
+        return existsSync(p) && readFileSync(p, 'utf8').toLowerCase().includes(needle.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+/** True if `cwd` (top level, or a test/ or tests/ dir) holds a Node built-in
+ *  test file — `*.test.{mjs,cjs,js}`. Lets codehere observe reality in a plain
+ *  Node repo that uses `node --test` with no npm script or runner config (a
+ *  common setup that previously left the verifier blind — DISCOVERED via a real
+ *  V3 run, 2026-06-14). Bounded: top level + two conventional dirs, never a
+ *  recursive walk. */
+function hasNodeTestFiles(cwd) {
+    const isTest = (f) => /\.test\.(mjs|cjs|js)$/.test(f);
+    for (const dir of [cwd, join(cwd, 'test'), join(cwd, 'tests')]) {
+        try {
+            if (readdirSync(dir).some(isTest))
+                return true;
+        }
+        catch {
+            /* dir absent / unreadable → keep looking */
+        }
+    }
+    return false;
+}
+/**
+ * Detect a runnable test command in `cwd`, across ecosystems — so "codehere
+ * re-runs your tests and catches a lying report" holds for Python/Go/Rust repos,
+ * not only npm. Conservative: each branch keys off an UNAMBIGUOUS marker; we
+ * return null (never guess) when there's nothing known to run.
+ *
+ * Precedence: explicit override → Node (npm test) → Go → Rust → Python (pytest)
+ * → a JS runner config without an npm script. First match wins.
+ */
+export function detectTestCommand(cwd) {
+    // 0. Explicit per-repo override — the escape hatch for anything we can't infer
+    //    (monorepos, custom runners). e.g. CODEHERE_TEST_CMD="make test". Run via
+    //    execFile (no shell), so args are whitespace-split — a quoted arg with
+    //    spaces (CODEHERE_TEST_CMD='pytest -k "a b"') is NOT supported; use a
+    //    wrapper script for that case.
+    const override = process.env.CODEHERE_TEST_CMD?.trim();
+    if (override) {
+        const [cmd, ...args] = override.split(/\s+/);
+        return { cmd, args, display: override };
+    }
+    // 1. Node — the project's declared `npm test` (dominant case + this repo).
+    const pj = join(cwd, 'package.json');
+    if (existsSync(pj)) {
+        try {
+            const json = JSON.parse(readFileSync(pj, 'utf8'));
+            const test = json.scripts?.test;
+            // npm's default placeholder script is not a real suite — skip it.
+            if (typeof test === 'string' && test.trim() && !/no test specified/i.test(test)) {
+                return { cmd: 'npm', args: ['test', '--silent'], display: 'npm test' };
+            }
+        }
+        catch {
+            /* unreadable package.json → fall through to other ecosystems */
+        }
+    }
+    // 2. Go — go.mod present → the standard whole-module test run.
+    if (existsSync(join(cwd, 'go.mod'))) {
+        return { cmd: 'go', args: ['test', './...'], display: 'go test ./...' };
+    }
+    // 3. Rust — Cargo.toml → `cargo test`.
+    if (existsSync(join(cwd, 'Cargo.toml'))) {
+        return { cmd: 'cargo', args: ['test'], display: 'cargo test' };
+    }
+    // 4. Python — pytest is the dominant runner. Key off pytest-specific markers
+    //    (conftest.py / pytest.ini are unambiguous). For pyproject/setup.cfg, match
+    //    the actual pytest CONFIG SECTION header — not a bare "pytest" substring,
+    //    which would fire on a comment or an unrelated dependency string and run
+    //    pytest on a project that doesn't use it.
+    if (existsSync(join(cwd, 'pytest.ini')) ||
+        existsSync(join(cwd, 'conftest.py')) ||
+        fileMentions(cwd, 'pyproject.toml', '[tool.pytest') ||
+        fileMentions(cwd, 'setup.cfg', '[tool:pytest]')) {
+        return { cmd: 'pytest', args: ['-q'], display: 'pytest' };
+    }
+    // 5. A JS test runner with config but no npm `test` script.
+    //
+    // SECURITY (2026-08-08) · `--no-install` is load-bearing on THIS path above all
+    // others. Bare `npx vitest` falls back to the public registry when the runner
+    // is not installed locally, so codehere would DOWNLOAD a test runner and
+    // execute it against the user's repo — and then report the result as
+    // "verifier re-ran the suite", the strongest claim this product makes. The
+    // same fallback let `npx graphify-ts` fetch an unrelated stranger's package
+    // (fixed 86c7893); here the blast radius is the evidence itself.
+    //
+    // Refusing is also the semantically right answer: a runner the project does
+    // not have installed is not the project's test suite, so re-running with it
+    // proves nothing. When this returns nothing runnable, applyTestObservation
+    // records an honest `testsUnobserved` reason instead — which is exactly the
+    // abstention the eval harness scores 2/2 on.
+    if (existsSync(join(cwd, 'vitest.config.ts')) || existsSync(join(cwd, 'vitest.config.js'))) {
+        return { cmd: 'npx', args: ['--no-install', 'vitest', 'run'], display: 'npx vitest run' };
+    }
+    if (existsSync(join(cwd, 'jest.config.js')) || existsSync(join(cwd, 'jest.config.ts'))) {
+        return { cmd: 'npx', args: ['--no-install', 'jest'], display: 'npx jest' };
+    }
+    // 6. Node built-in test runner — `*.test.{mjs,cjs,js}` present but no npm
+    //    script or runner config above. `node --test` self-discovers them. This is
+    //    the plain-Node case that left codehere blind to test reality (the verifier
+    //    can't catch a "tests pass" lie it never observed). Lowest precedence so a
+    //    declared script/runner always wins.
+    if (hasNodeTestFiles(cwd)) {
+        return { cmd: 'node', args: ['--test'], display: 'node --test' };
+    }
+    return null;
+}
+/**
+ * Re-run the project's tests on the real on-disk state. Async + timeout-bounded.
+ * Resolves with `ran:false` + a reason when there's nothing to run or it's
+ * disabled — never throws.
+ */
+export function rerunTests(cwd) {
+    if (process.env.CODEHERE_RERUN_TESTS === '0') {
+        return Promise.resolve({ ran: false, skippedReason: 'disabled (CODEHERE_RERUN_TESTS=0)' });
+    }
+    const detected = detectTestCommand(cwd);
+    if (!detected) {
+        return Promise.resolve({ ran: false, skippedReason: 'no known test command in this project' });
+    }
+    return new Promise((resolve) => {
+        const start = Date.now();
+        let out = '';
+        let settled = false;
+        const done = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(r);
+        };
+        let child;
+        try {
+            child = spawn(detected.cmd, detected.args, {
+                cwd,
+                env: { ...process.env, CI: '1', FORCE_COLOR: '0' },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                // Own process group so a timeout can kill the whole TREE — `npm test`
+                // forks the real runner, and killing just the npm wrapper orphaned the
+                // grandchild, which kept running past the timeout (self-audit 2026-06-09).
+                detached: true,
+            });
+        }
+        catch (e) {
+            done({ ran: false, skippedReason: `could not spawn test command: ${String(e).slice(0, 80)}` });
+            return;
+        }
+        const timer = setTimeout(() => {
+            try {
+                // Negative pid = kill the whole process group (the detached tree), so the
+                // forked test runner dies too, not just the npm wrapper.
+                if (typeof child.pid === 'number')
+                    process.kill(-child.pid, 'SIGKILL');
+                else
+                    child.kill('SIGKILL');
+            }
+            catch {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            done({ ran: false, skippedReason: `test re-run timed out after ${Math.round(DEFAULT_TIMEOUT_MS / 1000)}s` });
+        }, DEFAULT_TIMEOUT_MS);
+        const cap = (chunk) => {
+            out += String(chunk);
+            // bound memory — keep only the tail the parser reads
+            if (out.length > 200_000)
+                out = out.slice(-100_000);
+        };
+        child.stdout?.on('data', cap);
+        child.stderr?.on('data', cap);
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            done({ ran: false, skippedReason: `test command errored: ${String(e.message).slice(0, 80)}` });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            const parsed = parseTestSummary(out);
+            done({
+                ran: true,
+                command: detected.display,
+                exitCode: code ?? -1,
+                passed: parsed?.passed,
+                failed: parsed?.failed,
+                durationMs: Date.now() - start,
+            });
+        });
+    });
+}
+//# sourceMappingURL=rerun-tests.js.map

package/dist/application/use-cases/search-sessions.js

@@ -0,0 +1,70 @@
+/**
+ * Provable session search — REQUEST_METHOD stage 7 (Learn), and the Luca-seeded
+ * differentiator (#19): codehere already keeps a signed, cost-attributed record
+ * of every past session. This makes it SEARCHABLE — so a request can recover a
+ * prior decision, failed attempt, or command instead of starting from zero.
+ *
+ * The wedge vs a plain history search (e.g. ctx): every hit carries PROVENANCE —
+ * which agent did it and whether the run succeeded — because codehere's record
+ * has it and a raw-transcript search doesn't. "Search history you can trust."
+ *
+ * Local-first: reads the on-disk project thread records; no server, no network.
+ */
+import { listProjects, readProjectThread, } from '../../infrastructure/storage/project-thread-reader.js';
+/** Pure ranking — score a task against query terms (prompt weighted 2x report). */
+export function scoreTask(task, terms) {
+    const prompt = String(task.prompt || '').toLowerCase();
+    const report = String(task.finalReport?.summary || '').toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+        if (prompt.includes(t))
+            score += 2;
+        if (report.includes(t))
+            score += 1;
+    }
+    let snippet = '';
+    const hay = report || prompt;
+    for (const t of terms) {
+        const i = hay.indexOf(t);
+        if (i >= 0) {
+            const start = Math.max(0, i - 30);
+            snippet = (start > 0 ? '…' : '') + hay.slice(start, start + 100).trim() + '…';
+            break;
+        }
+    }
+    return { score, snippet: snippet || String(task.prompt || '').slice(0, 90) };
+}
+/** Search past sessions across all projects. Ranked, top-N, with provenance. */
+export function searchSessions(query, opts) {
+    const terms = String(query || '')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length >= 2);
+    if (!terms.length)
+        return [];
+    const limit = opts?.limit ?? 10;
+    const hits = [];
+    for (const p of listProjects()) {
+        const thread = readProjectThread(p.slug);
+        if (!thread)
+            continue;
+        for (const task of thread.tasks) {
+            if (task.archived)
+                continue;
+            const { score, snippet } = scoreTask(task, terms);
+            if (score > 0) {
+                hits.push({
+                    sessionId: task.sessionId,
+                    agent: task.agent || '?',
+                    status: String(task.status || 'unknown'),
+                    project: p.remote || p.slug,
+                    prompt: task.prompt || '',
+                    snippet,
+                    score,
+                });
+            }
+        }
+    }
+    return hits.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+//# sourceMappingURL=search-sessions.js.map

package/dist/application/use-cases/should-auto-review.js

@@ -0,0 +1,71 @@
+/**
+ * Tier 2.1 · slice 1 — the pure decision: should a just-completed task get an
+ * AUTOMATIC cross-vendor adversarial review, and by which vendor?
+ *
+ * Today cross-vendor proof is opportunistic: it only fires if a human happened
+ * to run a second, different-vendor task that reviewed the first. 2.1 makes the
+ * differentiator automatic — on completion, codehere itself spawns a DIFFERENT
+ * vendor in refute-mode and folds its verdict into the composite (`SessionVerdict`).
+ *
+ * This module is ONLY the eligibility gate, kept pure so the policy is testable
+ * without a daemon, a spawn, or real spend (the spawn + verdict wiring are later
+ * slices). The honesty bar from assess-cross-vendor applies downstream: a real
+ * review with a real reviewer, never a laundered green.
+ *
+ * The three gates, in order:
+ *  1. cross-vendor possible — a DIFFERENT installed vendor exists to review with
+ *     (single-vendor incumbents structurally can't do this; it's the whole wedge).
+ *  2. worth reviewing — the task actually changed something (no-op tasks have
+ *     nothing to refute; reviewing them burns spend for a guaranteed-empty proof).
+ *  3. within budget — the review is a real spawn with real cost; never blow the
+ *     cost-bounded promise to produce a receipt.
+ */
+/** Reviewer preference order — strongest-at-review first, mirrors ROUTING_RULES'
+ *  review rule (claude-code leads, then codex). Any installed different-vendor
+ *  agent is acceptable; this only decides WHICH when several are available. */
+// Reviewer preference favors reliably-authed, cost-bounded vendors first: Claude +
+// Cursor (flat subscriptions, ~free marginal) before the metered/rate-limit-prone
+// ones (aider/opencode on the OpenAI key, codex on a ChatGPT plan, gemini needs a
+// key). A runnable reviewer on a subscription you've paid for beats a "better" one
+// that's out of quota.
+const REVIEWER_PREFERENCE = ['claude-code', 'cursor', 'aider', 'opencode', 'codex', 'gemini'];
+/** Pick the strongest available reviewer that is NOT the writer's vendor. */
+function pickReviewer(writerAgent, installed) {
+    const candidates = installed.filter((a) => a !== writerAgent && a !== 'conductor');
+    if (candidates.length === 0)
+        return undefined;
+    for (const pref of REVIEWER_PREFERENCE) {
+        if (candidates.includes(pref))
+            return pref;
+    }
+    return candidates[0];
+}
+/**
+ * Decide whether to auto-spawn a cross-vendor review. Pure; no I/O, no spend.
+ */
+export function shouldAutoReview(input, thresholds = {}) {
+    const minFiles = thresholds.minFilesChanged ?? 1;
+    const minBudget = thresholds.minBudgetUsd ?? 0.1;
+    const reviewerVendor = pickReviewer(input.writerAgent, input.installedAgents);
+    if (!reviewerVendor) {
+        return { eligible: false, reason: `No different vendor installed to review ${input.writerAgent}'s work.` };
+    }
+    if (input.filesChanged < minFiles) {
+        return {
+            eligible: false,
+            reason: `Nothing to review — the task changed ${input.filesChanged} file(s); a cross-vendor review needs real work to refute.`,
+        };
+    }
+    if (input.budgetRemainingUsd < minBudget) {
+        return {
+            eligible: false,
+            reason: `Skipped to stay cost-bounded — $${input.budgetRemainingUsd.toFixed(2)} left under the cap, below the $${minBudget.toFixed(2)} a review needs.`,
+        };
+    }
+    return {
+        eligible: true,
+        reviewerVendor,
+        reason: `${reviewerVendor} will independently review ${input.writerAgent}'s work in refute-mode.`,
+    };
+}
+//# sourceMappingURL=should-auto-review.js.map

package/dist/application/use-cases/thread-export.js

@@ -20,6 +20,8 @@
  * Pure logic. The CLI + HTTP routes wrap this and do I/O.
  */
 import { sign as cryptoSign, verify as cryptoVerify, generateKeyPairSync, createPrivateKey, createPublicKey, } from 'crypto';
+import { existsSync, readFileSync } from 'fs';
+import { computeEntryHash, AUDIT_FILE } from '../../infrastructure/hooks/claude-sdk-hook.js';
 /* ──────────────────────────────────────────────────────────────────────── */
 /* Canonicalization · deterministic JSON form so signatures match            */
 /* ──────────────────────────────────────────────────────────────────────── */
@@ -127,9 +129,97 @@ function isBundle(x) {
         return false;
     if (typeof b.session !== 'object' || b.session === null)
         return false;
+    // auditChain is optional, but if present it must be an array (the signature
+    // already protects its contents; this just guards the shape).
+    if (b.auditChain !== undefined && !Array.isArray(b.auditChain))
+        return false;
     return true;
 }
 /* ──────────────────────────────────────────────────────────────────────── */
+/* Audit chain · embed (export side) + re-verify (import side)               */
+/* ──────────────────────────────────────────────────────────────────────── */
+/**
+ * Collect the audit entries for one session from the on-disk chain, preserving
+ * each entry's original chain fields (seq/prevHash/entryHash). The export use-case
+ * puts these on ThreadBundleBody.auditChain so the recipient can re-verify the
+ * agent's actions. Best-effort: a missing/unreadable log yields [].
+ */
+export function collectAuditEntriesForSession(sessionId, filepath = AUDIT_FILE, alsoSessionIds = []) {
+    if (!existsSync(filepath))
+        return [];
+    let content;
+    try {
+        content = readFileSync(filepath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    // 1.3 (extended to audit reconciliation) · a conductor-routed task's tool
+    // calls are keyed by the SPECIALIST's runtime sid, not the conductor task id.
+    // Matching the delegate id too lets reconciliation see the real writes —
+    // without it Auto tasks reconcile 'no-writes' and never earn the observed
+    // signal, so the 2.2 composite grade stays dark for the default path.
+    const ids = new Set([sessionId, ...alsoSessionIds]);
+    const out = [];
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (ids.has(e.sessionId))
+                out.push(e);
+        }
+        catch {
+            /* skip unparseable line */
+        }
+    }
+    return out;
+}
+/**
+ * Re-verify an embedded audit chain's PER-ENTRY integrity: each chained entry's
+ * stored entryHash must equal its recomputed hash (computeEntryHash, the exact
+ * function the writer used). A mismatch means the entry's content was altered
+ * after it was written → the record of what the agent did is not trustworthy.
+ *
+ * This is deliberately a self-hash check, not a cross-link walk: a single-session
+ * export is a SUBSET of the global interleaved chain, so its entries' prevHash
+ * values point at other sessions' entries that aren't present. Per-entry self-hash
+ * + the bundle signature (signer vouches for the exact set) is the honest,
+ * verifiable team-proof; global completeness is not claimable from a subset. See
+ * ThreadBundleBody.auditChain for the FULL trust model (signer attestation, not
+ * independent provenance — a malicious signer can fabricate a valid chain).
+ *
+ * CALLER CONTRACT: `valid` means "no tampered entry was found" — it is `true`
+ * for an EMPTY or all-legacy set where NOTHING was cryptographically checked.
+ * Any "✓ verified" surface MUST gate on `verified > 0`, not bare `valid`, or it
+ * will claim verification that didn't happen.
+ */
+export function verifyEmbeddedAuditChain(entries) {
+    const check = { valid: true, total: 0, verified: 0, legacy: 0, tampered: [] };
+    for (const entry of entries) {
+        check.total++;
+        const hasChain = typeof entry.seq === 'number' && typeof entry.prevHash === 'string' && typeof entry.entryHash === 'string';
+        if (!hasChain) {
+            check.legacy++;
+            continue;
+        }
+        const recomputed = computeEntryHash(entry);
+        if (recomputed !== entry.entryHash) {
+            check.valid = false;
+            check.tampered.push({
+                seq: entry.seq,
+                sessionId: entry.sessionId,
+                toolName: entry.toolName,
+                reason: 'self_hash_mismatch',
+            });
+        }
+        else {
+            check.verified++;
+        }
+    }
+    return check;
+}
+/* ──────────────────────────────────────────────────────────────────────── */
 /* Key derivation helpers · PEM encoding for storage                          */
 /* ──────────────────────────────────────────────────────────────────────── */
 export function exportPrivatePem(key) {