codehere 1.0.1 → 1.0.2

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

@@ -1,70 +0,0 @@
-/**
- * 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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,245 +0,0 @@
-/**
- * Thread export · v0.8 S4 · signed-payload "GitHub for agent sessions"
- *
- * Produces a self-contained, Ed25519-signed bundle of one PersistedSession
- * that a colleague can verify and replay locally. Local-first by design:
- * never relayed through codehere's infrastructure · the user shares the
- * file (or signed URL) by their preferred channel (Slack, email, PR
- * description) and the recipient runs `codehere thread import <file>`.
- *
- * The signature covers a CANONICAL JSON form of the bundle body so two
- * machines that re-serialize the same data get the same hash. Verification
- * recomputes the canonical form, re-derives the hash, checks the signature
- * against the included public key, and returns one of:
- *   - 'valid'         · signature matches · safe to replay
- *   - 'tampered'      · signature does NOT match · refuse
- *   - 'malformed'     · bundle is structurally wrong · refuse
- *   - 'unknown_key'   · signature valid but public key not in user's trust
- *                       store · prompt user to trust+continue or refuse
- *
- * 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            */
-/* ──────────────────────────────────────────────────────────────────────── */
-/**
- * Stable JSON: object keys sorted, no whitespace, primitives preserved.
- * Two machines that build the same body MUST produce the same bytes for
- * the signature to verify. We deliberately don't use JSON.stringify with
- * a replacer because Node's serializer doesn't guarantee key order across
- * versions/realms.
- */
-export function canonicalize(value) {
-    if (value === null)
-        return 'null';
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new Error(`cannot canonicalize non-finite number: ${value}`);
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'string' || typeof value === 'boolean')
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(canonicalize).join(',') + ']';
-    }
-    if (typeof value === 'object') {
-        const obj = value;
-        const keys = Object.keys(obj).sort();
-        const parts = keys
-            .filter((k) => obj[k] !== undefined) // undefined → drop the key (JSON convention)
-            .map((k) => JSON.stringify(k) + ':' + canonicalize(obj[k]));
-        return '{' + parts.join(',') + '}';
-    }
-    if (value === undefined)
-        return 'null';
-    throw new Error(`cannot canonicalize type: ${typeof value}`);
-}
-/** Generate a fresh Ed25519 keypair · used for first-time setup. */
-export function generateKeypair() {
-    const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-    return { publicKey, privateKey };
-}
-/** Sign a bundle body and produce the full ThreadBundle.
- *  Ed25519 is NOT a hash-then-sign scheme · pass the message directly to
- *  crypto.sign(null, msg, key) · the algorithm is implied by the key. */
-export function signBundle(body, keys) {
-    const canonical = canonicalize(body);
-    const sig = cryptoSign(null, Buffer.from(canonical, 'utf-8'), keys.privateKey);
-    const pubRaw = keys.publicKey.export({ format: 'der', type: 'spki' });
-    return {
-        body,
-        signature: sig.toString('base64'),
-        publicKey: pubRaw.toString('base64'),
-        alg: 'ed25519',
-    };
-}
-/**
- * Verify a bundle. Returns one of:
- *   - valid        · signature matches AND the publicKey is in trustedKeys
- *   - valid-untrusted · signature matches but the key isn't in trustedKeys
- *                        (returned with status='valid' but trusted=false)
- *   - tampered     · signature doesn't match the recomputed body bytes
- *   - malformed    · bundle structure broken
- */
-export function verifyBundle(bundle, trustedKeys = new Set()) {
-    if (!isBundle(bundle))
-        return { status: 'malformed', reason: 'bundle shape is invalid' };
-    if (bundle.alg !== 'ed25519')
-        return { status: 'malformed', reason: `unsupported alg: ${bundle.alg}` };
-    try {
-        const canonical = canonicalize(bundle.body);
-        const pubBuf = Buffer.from(bundle.publicKey, 'base64');
-        const sigBuf = Buffer.from(bundle.signature, 'base64');
-        const pubKey = createPublicKey({ key: pubBuf, format: 'der', type: 'spki' });
-        const ok = cryptoVerify(null, Buffer.from(canonical, 'utf-8'), pubKey, sigBuf);
-        if (!ok)
-            return { status: 'tampered', reason: 'signature does not match body' };
-        const trusted = trustedKeys.has(bundle.publicKey);
-        if (!trusted) {
-            return { status: 'unknown_key', bundle, publicKey: bundle.publicKey };
-        }
-        return { status: 'valid', bundle, trusted: true };
-    }
-    catch (err) {
-        return { status: 'malformed', reason: err instanceof Error ? err.message : String(err) };
-    }
-}
-function isBundle(x) {
-    if (typeof x !== 'object' || x === null)
-        return false;
-    const obj = x;
-    if (typeof obj.signature !== 'string')
-        return false;
-    if (typeof obj.publicKey !== 'string')
-        return false;
-    if (typeof obj.alg !== 'string')
-        return false;
-    const body = obj.body;
-    if (typeof body !== 'object' || body === null)
-        return false;
-    const b = body;
-    if (b.schema !== 1)
-        return false;
-    if (b.kind !== 'thread')
-        return false;
-    if (typeof b.sessionId !== 'string')
-        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) {
-    return key.export({ format: 'pem', type: 'pkcs8' }).toString();
-}
-export function exportPublicPem(key) {
-    return key.export({ format: 'pem', type: 'spki' }).toString();
-}
-export function importPrivatePem(pem) {
-    return createPrivateKey({ key: pem, format: 'pem', type: 'pkcs8' });
-}
-export function importPublicPem(pem) {
-    return createPublicKey({ key: pem, format: 'pem', type: 'spki' });
-}
-/** Compute the base64 publicKey string for a KeyObject · same encoding as in bundles. */
-export function publicKeyToBase64(key) {
-    return key.export({ format: 'der', type: 'spki' }).toString('base64');
-}
-/** Short fingerprint used in human-readable output. */
-export function shortFingerprint(publicKeyB64) {
-    return publicKeyB64.slice(0, 8) + '...' + publicKeyB64.slice(-4);
-}
-//# sourceMappingURL=thread-export.js.map