codehere 1.0.1 → 1.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codehere",
-  "version": "1.0.1",
-  "description": "See what your AI coding agents cost, and prove what they actually did. Runs Claude Code, Codex, Aider, Gemini and OpenCode on your machine, records every action in a hash-chained log, and re-runs your tests instead of taking an agent's word for it.",
+  "version": "1.0.3",
+  "description": "Re-runs the tests an AI says passed, and tells you whether they did. Flags weakened tests and test files that do not exist.",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -25,8 +25,6 @@
     "prebuild": "rm -rf dist",
     "build": "tsc",
     "postbuild": "chmod +x dist/index.js",
-    "repomap": "node scripts/gen-repo-map.mjs",
-    "pattern-counts": "node scripts/print-pattern-counts.mjs",
     "prepublishOnly": "npm run build && find dist -name '*.map' -delete && find dist -name '*.d.ts' -delete && find dist -name '*.d.ts.map' -delete",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
@@ -35,34 +33,19 @@
     "lint": "eslint src/ --ext .ts",
     "knip": "knip",
     "knip:gate": "node scripts/knip-gate.mjs",
-    "lint:tokens": "node scripts/ui-token-gate.mjs",
-    "arch:gate": "tsc --noEmit && eslint src/ --ext .ts && node scripts/knip-gate.mjs && node scripts/ui-token-gate.mjs",
+    "arch:gate": "tsc --noEmit && eslint src/ --ext .ts && node scripts/knip-gate.mjs",
     "format": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
     "format:check": "prettier --check 'src/**/*.ts' 'test/**/*.ts'",
     "sbom": "npm sbom --sbom-format=spdx --omit=dev",
-    "pretag:check": "../scripts/pretag-npm-check.sh",
-    "cassette:record": "../scripts/capture-cassette.sh",
-    "e2e": "node test/e2e/run.mjs",
-    "e2e:live": "CODEHERE_E2E_LIVE=1 node test/e2e/run.mjs",
-    "degraded": "node scripts/degraded-matrix.mjs",
-    "inventory": "node scripts/inventory-drift.mjs"
+    "pretag:check": "../scripts/pretag-npm-check.sh"
   },
   "keywords": [
     "ai-coding-agents",
-    "verification",
-    "agent-audit",
-    "llm-cost",
-    "ai-cost-tracking",
-    "audit-trail",
-    "trust-scoring",
-    "ai-safety",
-    "ai-governance",
+    "test-verification",
+    "ci",
+    "github-action",
     "claude-code",
     "codex",
-    "aider",
-    "opencode",
-    "hook-system",
-    "sast",
     "cli-tool",
     "typescript"
   ],
@@ -75,13 +58,10 @@
   "bugs": {
     "url": "https://github.com/muhammadegaa/codehere/issues"
   },
-  "homepage": "https://codehere.uk",
+  "homepage": "https://github.com/muhammadegaa/codehere",
   "dependencies": {
     "chalk": "^5.3.0",
-    "cli-table3": "^0.6.5",
-    "commander": "^11.1.0",
-    "dotenv": "^16.3.1",
-    "yaml": "^2.8.4"
+    "commander": "^11.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -90,19 +70,10 @@
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.16.2",
     "knip": "^6.16.1",
-    "playwright": "^1.60.0",
     "prettier": "^3.8.3",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.58.2",
     "vitest": "^4.1.4"
-  },
-  "peerDependencies": {
-    "@mohammednagy/graphify-ts": "^0.22.3"
-  },
-  "peerDependenciesMeta": {
-    "@mohammednagy/graphify-ts": {
-      "optional": true
-    }
   }
 }

package/dist/application/services/verdict-service.js

@@ -1,154 +0,0 @@
-/**
- * VerdictService — the single owner of how a session's honesty verdict is
- * ASSESSED from its parts (R11 / ARCHITECTURE.md M2).
- *
- * Before this, every surface re-derived the verdict inputs inline: the HTTP
- * `/api/tasks` route did it twice (spawned + persisted records) and the
- * `codehere verify` CLI did it a third time, each independently mapping a session
- * to `verifyClaim({ summary, artifacts, steps })`. A change to what feeds the
- * verdict meant editing 3+ sites in 2 layers — the "verdict has no owner" finding.
- *
- * This is the one entry point. It COMPOSES the pure use-cases (today `verifyClaim`;
- * `reconcileAudit`, composed into the single `SessionVerdict`) — it does
- * NOT re-implement their logic. Surfaces render what this returns; they never
- * recompute a verdict rule.
- */
-import { verifyClaim } from '../use-cases/verify-claim.js';
-/**
- * Assess a session's claim-vs-reality verdict. The single owner of the
- * session → `verifyClaim` input mapping. Pure (delegates to the pure use-case).
- */
-export function assessSession(session) {
-    return verifyClaim({
-        summary: session.finalReport?.summary,
-        artifacts: session.artifacts,
-        steps: session.steps,
-    });
-}
-/** Compose the single verdict object every surface consumes. */
-export function composeVerdict(session, audit, crossVendor) {
-    const verdict = {
-        claim: assessSession(session),
-        ...(audit !== undefined ? { audit } : {}),
-        ...(crossVendor !== undefined ? { crossVendor } : {}),
-    };
-    // The one owner attaches the grade so no surface re-derives "is this green".
-    verdict.grade = gradeComposite(verdict);
-    return verdict;
-}
-/**
- * The one canonical verdict vocabulary. Every surface (web app + CLI) reads its
- * verdict word from here, so the same state reads the same word everywhere
- * instead of each surface re-deriving its own ("Proven" vs "Verified" vs
- * "verified" for the flagship cross-vendor case was a real three-way split).
- * Wording locked with Ega 2026-06-23, refined 2026-07-17: a green composite grade
- * reads "Verified" on EVERY surface — a single other-vendor review CORROBORATES,
- * it doesn't prove, so the seal expands it as "Corroborated by <vendor>" and no
- * headline says "Proven" for a lone reviewer. "Proven" stays in the vocab
- * (reserved) but is not rendered today. "Caught" = a contradicted claim.
- *
- * The first seven are the canonical headline words. `partial` is a residual the
- * web still emits for two narrow "couldn't fully verify" branches (not-a-git-repo
- * and the catch-all); it is kept here so nothing is silently dropped, pending a
- * decision to fold it into `unverified`.
- */
-export const VERDICT_WORDS = {
-    proven: 'Proven',
-    verified: 'Verified',
-    reported: 'Reported',
-    stopped: 'Stopped',
-    caught: 'Caught',
-    unverified: 'Unverified',
-    practice: 'Practice',
-    partial: 'Partial',
-};
-/**
- * The green-verdict corroboration clause, scoped to the ACTUAL independent
- * signal(s) that earned the green. A LONE cross-vendor pass is one reviewer's
- * corroboration — "corroborated by one other vendor" — never "independently
- * corroborated", which would overstate a single reviewer. Disk-observed writes
- * and multi-signal greens keep the "independently corroborated" wording. The
- * web mirrors this inline (app-script `indepClause`) so both surfaces name the
- * same signal for the same state.
- */
-export function corroborationClause(grade) {
-    const pass = grade.signals.filter((s) => s.provenance !== 'self-reported' && s.state === 'pass');
-    if (pass.length === 1 && pass[0].provenance === 'adversarial')
-        return 'corroborated by one other vendor.';
-    const hasDisk = pass.some((s) => s.provenance === 'observed');
-    return hasDisk ? 'independently corroborated · file writes confirmed on disk.' : 'independently corroborated.';
-}
-/**
- * Grade a composed `SessionVerdict` into the headline the surface may show.
- * Pure — no I/O. The single owner of "what is the ✓ allowed to say."
- */
-export function gradeComposite(verdict) {
-    const signals = [];
-    // 1 · self-reported — the claim vs its own artifacts.
-    const cs = verdict.claim.status;
-    const claimState = cs === 'verified' ? 'pass' : cs === 'broken' ? 'fail' : cs === 'no-report' ? 'absent' : 'neutral';
-    signals.push({
-        name: 'self-report',
-        provenance: 'self-reported',
-        state: claimState,
-        detail: `the agent's report ${cs === 'verified' ? 'matches' : cs === 'broken' ? 'contradicts' : 'makes no checkable claim against'} its own recorded work`,
-    });
-    // 2 · observed — the audit's declared writes vs the real git diff.
-    const av = verdict.audit?.verdict;
-    if (av !== undefined) {
-        const auditState = av === 'consistent' ? 'pass' : 'neutral'; // 'unconfirmed' is honest under-count, never a fail
-        signals.push({
-            name: 'audit-on-disk',
-            provenance: 'observed',
-            state: auditState,
-            detail: av === 'consistent'
-                ? 'declared file writes confirmed on disk'
-                : av === 'no-writes'
-                    ? 'no file writes to confirm'
-                    : av === 'unconfirmed'
-                        ? "couldn't confirm every declared write"
-                        : 'on-disk effect unobservable',
-        });
-    }
-    // 3 · adversarial — a different vendor independently reviewed it.
-    const cv = verdict.crossVendor;
-    if (cv !== undefined) {
-        const cvState = cv.proven ? 'pass' : 'neutral'; // not-proven ⇒ shown, never a fail (codehere doesn't adjudicate)
-        signals.push({
-            name: 'cross-vendor',
-            provenance: 'adversarial',
-            state: cvState,
-            detail: cv.proven
-                ? `${cv.reviewer.agent} independently reviewed ${cv.writer.agent}'s work, integrity-checked`
-                : cv.crossVendor
-                    ? `cross-vendor review ran but isn't a clean proof — ${cv.caveats[0] ?? 'see caveats'}`
-                    : 'not a cross-vendor review',
-        });
-    }
-    const independentPass = signals.some((s) => s.provenance !== 'self-reported' && s.state === 'pass');
-    const selfFailed = claimState === 'fail';
-    let headline;
-    if (cs === 'no-report')
-        headline = 'no-report';
-    else if (selfFailed)
-        headline = 'broken';
-    else if (cs === 'nothing-to-verify' && !independentPass)
-        headline = 'nothing-to-verify';
-    else if (independentPass)
-        headline = 'proven';
-    else
-        headline = 'reported';
-    const green = headline === 'proven';
-    const clause = corroborationClause({ signals });
-    const summary = headline === 'proven'
-        ? clause.charAt(0).toUpperCase() + clause.slice(1)
-        : headline === 'broken'
-            ? 'The report contradicts its own recorded work.'
-            : headline === 'reported'
-                ? 'Self-reported only — no independent signal has corroborated it yet.'
-                : headline === 'nothing-to-verify'
-                    ? 'No checkable claim to verify.'
-                    : 'No report to grade.';
-    return { headline, green, signals, summary };
-}
-//# sourceMappingURL=verdict-service.js.map

package/dist/application/use-cases/assess-cross-vendor.js

@@ -1,126 +0,0 @@
-/**
- * Cross-vendor verdict — the receipt a model lab structurally cannot sell.
- *
- * When one vendor wrote code and a DIFFERENT vendor reviewed it in the same
- * room, this produces the proof-of-process: who wrote, who reviewed, what the
- * audit chain attributes to each, and the combined cost. It is the output that
- * turns the wedge from "two sessions happened to share a room" into a stated,
- * checkable claim.
- *
- * HONESTY (the trap the wedge test already flagged, refuter-pinned):
- * codehere does NOT adjudicate whether the reviewer found a REAL bug — it can't
- * judge code correctness, and a generic "found a flaw" tripwire would read green
- * on a review that found nothing. So this proves the PROCESS (a different vendor
- * independently reviewed and recorded findings, integrity-checked) and surfaces
- * the reviewer's findings verbatim for the human to judge. `proven` is true ONLY
- * when it really is a cross-vendor review, the chain verifies, both vendors are
- * attributed in it, and the review actually produced output. Anything short of
- * that is stated plainly, never laundered into a green check.
- *
- * Wording stays "integrity-checked", never "tamper-evident" (domain/audit.ts:
- * the unkeyed SHA-256 chain detects naive edits, not a determined re-walk).
- */
-import { reconcileAudit } from './reconcile-audit.js';
-import { estimateCostUsd } from '../../infrastructure/cost/spend-aggregator.js';
-/** Read-ish tool names across adapters — used to report "reviewer read N files".
- *  Conservative: only names that are unambiguously a read. A reviewer SHOULD
- *  have only reads; any write is surfaced as a caveat, not hidden. */
-const READ_TOOLS = new Set(['read', 'glob', 'grep', 'ls', 'cat', 'view', 'search_file', 'list_files'].map((t) => t.toLowerCase()));
-/** Same WRITE_TOOLS spirit as reconcile-audit, kept local + minimal: we only
- *  need "did the reviewer mutate anything" (it shouldn't). */
-const WRITE_TOOLS = new Set([
-    'write',
-    'edit',
-    'multiedit',
-    'notebookedit',
-    'delete',
-    'write_file',
-    'edit_file',
-    'create_file',
-    'str_replace',
-    'apply_patch',
-].map((t) => t.toLowerCase()));
-function countTools(entries, set) {
-    return entries.filter((e) => set.has((e.toolName || '').toLowerCase())).length;
-}
-function fmtUsd(n) {
-    return n === 0 ? '$0' : `$${n.toFixed(2)}`;
-}
-export function assessCrossVendor(input) {
-    const { writer, reviewer, entries, chain } = input;
-    const crossVendor = writer.agent !== reviewer.agent;
-    // Attribute by the sessionId the tool-call entries carry. For a direct run
-    // that's the run's own sessionId; for a conductor-routed run the audit hook
-    // keyed the entries by the SPECIALIST's runtime id (delegateSessionId), not
-    // the conductor task's id — so match EITHER (1.3). Without the delegate leg,
-    // every Auto-routed task reads "couldn't attribute" though its writes are in
-    // the chain. pre_prompt scans use a separate scan id and carry no write/read
-    // tool, so they never inflate counts; sessionId scoping stays precise and
-    // immune to mixing other rooms' same-vendor sessions.
-    const matchesRun = (e, run) => e.sessionId === run.sessionId || (run.delegateSessionId !== undefined && e.sessionId === run.delegateSessionId);
-    const writerEntries = entries.filter((e) => matchesRun(e, writer));
-    const reviewerEntries = entries.filter((e) => matchesRun(e, reviewer));
-    const writerRecon = reconcileAudit(writerEntries, writer.artifacts);
-    const reviewerRead = countTools(reviewerEntries, READ_TOOLS);
-    const reviewerWrote = countTools(reviewerEntries, WRITE_TOOLS);
-    const reviewHasFindings = !!(reviewer.reviewText && reviewer.reviewText.trim().length > 0);
-    const writerAttributed = writerEntries.length > 0;
-    const reviewerAttributed = reviewerEntries.length > 0;
-    const totalCostUsd = estimateCostUsd(writer.agent, writer.artifacts?.usage) + estimateCostUsd(reviewer.agent, reviewer.artifacts?.usage);
-    const caveats = [];
-    if (!crossVendor)
-        caveats.push(`Same vendor on both sides (${writer.agent}) — not a cross-vendor proof.`);
-    if (!chain.valid)
-        caveats.push("Audit chain didn't verify — the proof is withheld until it does.");
-    if (crossVendor && !writerAttributed)
-        caveats.push(`Couldn't attribute ${writer.agent}'s work in the audit chain.`);
-    if (crossVendor && !reviewerAttributed)
-        caveats.push(`Couldn't attribute ${reviewer.agent}'s review in the audit chain.`);
-    if (reviewerWrote > 0)
-        caveats.push(`${reviewer.agent} also changed ${reviewerWrote} file(s) — this wasn't a read-only review.`);
-    if (!reviewHasFindings)
-        caveats.push(`${reviewer.agent}'s review recorded no findings text.`);
-    // A clean cross-vendor REVIEW proof is read-only — if the reviewer also wrote,
-    // the receipt can't honestly say "changed nothing", so it isn't `proven`
-    // (the reviewerWrote caveat above explains why). Refuter 2026-06-13.
-    const proven = crossVendor && chain.valid && writerAttributed && reviewerAttributed && reviewHasFindings && reviewerWrote === 0;
-    const summary = proven
-        ? `${reviewer.agent} reviewed ${writer.agent}'s work in this room. ` +
-            `${writer.agent} ${writerRecon.verdict === 'consistent' ? `wrote ${writerRecon.filesObserved} file(s), confirmed on disk` : `recorded ${writerRecon.writeToolCalls} write(s)`}; ` +
-            `${reviewer.agent} read ${reviewerRead}, changed nothing. ` +
-            `Audit chain: ${chain.chainedEntries}/${chain.totalEntries} integrity-checked, both vendors attributed. ` +
-            `Combined cost: ${fmtUsd(totalCostUsd)}.`
-        : crossVendor
-            ? `${reviewer.agent} reviewed ${writer.agent}'s work, but this isn't a clean cross-vendor proof yet — ${caveats[0]}`
-            : caveats[0];
-    return {
-        crossVendor,
-        proven,
-        writer: {
-            agent: writer.agent,
-            sessionId: writer.sessionId,
-            wrote: writerRecon.writeToolCalls,
-            reconciliation: writerRecon.verdict,
-            reconNote: writerRecon.note,
-        },
-        reviewer: {
-            agent: reviewer.agent,
-            sessionId: reviewer.sessionId,
-            read: reviewerRead,
-            wrote: reviewerWrote,
-            hasFindings: reviewHasFindings,
-        },
-        chain: {
-            totalEntries: chain.totalEntries,
-            chainedEntries: chain.chainedEntries,
-            valid: chain.valid,
-            writerAttributed,
-            reviewerAttributed,
-        },
-        totalCostUsd,
-        summary,
-        caveats,
-        reviewText: reviewer.reviewText,
-    };
-}
-//# sourceMappingURL=assess-cross-vendor.js.map

package/dist/application/use-cases/build-cross-vendor-verdict.js

@@ -1,118 +0,0 @@
-/**
- * Gather the live data a cross-vendor verdict needs (room sessions, audit
- * entries, chain facts) and run the pure `assessCrossVendor`. Shared by the CLI
- * (`codehere verify`) and the daemon (GET /api/task/:id/cross-vendor) so both
- * surfaces compute the receipt the same way — one path, no drift.
- *
- * The pure judgment lives in assess-cross-vendor.ts; this is the (disk-reading)
- * glue around it.
- *
- * PAIRING is OBSERVED, not inferred: a reviewer records the writer it reviewed
- * (parentSessionId, stamped at spawn). Older / manual reviews that predate that
- * ground truth fall back to a STRICT inference — a candidate is only treated as
- * a reviewer if it changed NO files (a read-only review). A session that wrote
- * files is a writer, never a reviewer; inferring otherwise mispaired in a
- * multi-run room (a later writer read as a reviewer of an earlier one).
- */
-import { existsSync, readFileSync } from 'fs';
-import { loadRecent, loadSessionById, } from '../../infrastructure/orchestration/session-persistence.js';
-import { AUDIT_FILE, verifyAuditChain } from '../../infrastructure/hooks/claude-sdk-hook.js';
-import { assessCrossVendor } from './assess-cross-vendor.js';
-/** Assemble the verdict for a KNOWN writer↔reviewer pair (the role decision is
- *  the caller's; this just reads the chain + runs the pure assessment). */
-function assembleVerdict(writer, reviewer) {
-    let entries = [];
-    if (existsSync(AUDIT_FILE)) {
-        entries = readFileSync(AUDIT_FILE, 'utf-8')
-            .split('\n')
-            .filter(Boolean)
-            .map((l) => {
-            try {
-                return JSON.parse(l);
-            }
-            catch {
-                return undefined;
-            }
-        })
-            .filter((e) => !!e);
-    }
-    const chain = verifyAuditChain(AUDIT_FILE);
-    const reviewText = reviewer.finalReport?.summary?.trim() ||
-        (reviewer.steps ?? [])
-            .filter((s) => s.kind === 'say')
-            .map((s) => s.label)
-            .join('\n')
-            .trim() ||
-        undefined;
-    return assessCrossVendor({
-        writer: {
-            agent: writer.agent,
-            sessionId: writer.sessionId,
-            delegateSessionId: writer.delegateSessionId,
-            artifacts: writer.artifacts,
-        },
-        reviewer: {
-            agent: reviewer.agent,
-            sessionId: reviewer.sessionId,
-            delegateSessionId: reviewer.delegateSessionId,
-            artifacts: reviewer.artifacts,
-            reviewText,
-        },
-        entries,
-        chain: { totalEntries: chain.totalEntries, chainedEntries: chain.chainedEntries, valid: chain.valid },
-    });
-}
-/** Build the cross-vendor verdict for a session that REVIEWED an earlier writer
- *  in the same room. Returns undefined when there's no such pair (the session
- *  isn't a cross-vendor review). */
-export function buildCrossVendorVerdict(reviewer) {
-    if (!reviewer.cwd)
-        return undefined;
-    // OBSERVED link: an auto-review records the exact writer it reviewed. Gate on
-    // isReview, NOT parentSessionId alone — parentSessionId is overloaded (the room
-    // composer also sets it when a goal is HANDED OFF to a different vendor to
-    // CONTINUE the work, which is not a review). Only isReview means "this session
-    // reviewed its parent." Without this gate a continuation would be falsely
-    // labeled "X reviewed Y's work."
-    if (reviewer.isReview && reviewer.parentSessionId) {
-        const writer = loadSessionById(reviewer.parentSessionId);
-        if (!writer || writer.agent === reviewer.agent)
-            return undefined;
-        return assembleVerdict(writer, reviewer);
-    }
-    // LEGACY / manual: no recorded link. Only a READ-ONLY session (changed no
-    // files) can be a reviewer — a session that wrote files is a writer. This is
-    // the guard that stops a later writer being mispaired as a reviewer.
-    if ((reviewer.artifacts?.files?.length ?? 0) > 0)
-        return undefined;
-    const writer = loadRecent(50)
-        .filter((s) => s.cwd === reviewer.cwd &&
-        s.sessionId !== reviewer.sessionId &&
-        s.startedAt < reviewer.startedAt &&
-        s.agent !== reviewer.agent &&
-        (s.artifacts?.files?.length ?? 0) > 0)
-        .sort((a, b) => b.startedAt - a.startedAt)[0];
-    if (!writer)
-        return undefined;
-    return assembleVerdict(writer, reviewer);
-}
-/** Convenience for the daemon route: load the session by id, then build. */
-export function buildCrossVendorVerdictById(sessionId) {
-    const reviewer = loadSessionById(sessionId);
-    return reviewer ? buildCrossVendorVerdict(reviewer) : undefined;
-}
-/** The WRITER-keyed mirror: given a writer, find the reviewer that reviewed IT
- *  and build the verdict. A user opens the WRITER's run and wants to see "a
- *  different vendor reviewed this"; the reviewer recorded the link, so we read
- *  it directly (parentSessionId === this writer + isReview) — no inference, no
- *  mispairing. Returns undefined when no review of this writer exists. */
-export function buildCrossVendorVerdictForWriter(writerId) {
-    const writer = loadSessionById(writerId);
-    if (!writer || !writer.cwd)
-        return undefined;
-    const reviewer = loadRecent(50).find((s) => s.isReview === true && s.parentSessionId === writerId);
-    if (!reviewer || reviewer.agent === writer.agent)
-        return undefined;
-    return assembleVerdict(writer, reviewer);
-}
-//# sourceMappingURL=build-cross-vendor-verdict.js.map

package/dist/application/use-cases/domain-trust.js

@@ -1,110 +0,0 @@
-/**
- * Per-domain trust grade for W-PASS write targets · v0.9 must-ship.
- *
- * Demo v12 + locked v1 tier scope: "linear.app A · *.atlassian.net B ·
- * unknown F · first-write confirmation per domain."
- *
- * Two pieces of state:
- *   1. WELL_KNOWN_GRADES · hardcoded · the platforms we've vetted ourselves
- *      ship with grade A. Subdomain wildcards get B. Everything else
- *      defaults to F (forces explicit user confirmation on first write).
- *   2. USER_TRUSTED_DOMAINS · ~/.codehere/keys/trusted-domains.json ·
- *      domains the user has explicitly trusted after a first-write prompt.
- *      Domains here promote from F → B.
- *
- * Pure logic. CLI + HTTP wrap it.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import { dirname, join } from 'path';
-const WELL_KNOWN_GRADES = [
-    // Grade A · platforms codehere has shipped+tested adapters for
-    { pattern: /^api\.linear\.app$/i, grade: 'A', reason: 'official Linear API · codehere ships a vetted adapter' },
-    { pattern: /^api\.github\.com$/i, grade: 'A', reason: 'official GitHub API · codehere ships a vetted adapter' },
-    { pattern: /^api\.figma\.com$/i, grade: 'A', reason: 'official Figma API · codehere ships a vetted adapter' },
-    // Grade B · same vendor, surrounding subdomains
-    { pattern: /^[a-z0-9-]+\.linear\.app$/i, grade: 'B', reason: 'Linear subdomain · adjacent to the vetted API' },
-    { pattern: /^[a-z0-9-]+\.github\.com$/i, grade: 'B', reason: 'GitHub subdomain · adjacent to the vetted API' },
-    { pattern: /^[a-z0-9-]+\.figma\.com$/i, grade: 'B', reason: 'Figma subdomain · adjacent to the vetted API' },
-    {
-        pattern: /^[a-z0-9-]+\.atlassian\.net$/i,
-        grade: 'B',
-        reason: 'Atlassian-hosted instance · vendor known but instance not vetted',
-    },
-    // Grade C · public hosts known to be commonly used
-    { pattern: /^raw\.githubusercontent\.com$/i, grade: 'C', reason: 'GitHub-hosted raw content · static, read-mostly' },
-];
-function trustedDomainsPath() {
-    const home = process.env.CODEHERE_HOME || homedir();
-    return join(home, '.codehere', 'keys', 'trusted-domains.json');
-}
-export function loadTrustedDomains() {
-    const path = trustedDomainsPath();
-    if (!existsSync(path))
-        return { schema: 1, domains: {} };
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf-8'));
-        if (raw && raw.schema === 1 && typeof raw.domains === 'object')
-            return raw;
-    }
-    catch {
-        /* fall through · empty trust store */
-    }
-    return { schema: 1, domains: {} };
-}
-export function trustDomain(host, note) {
-    const file = loadTrustedDomains();
-    file.domains[host.toLowerCase()] = { addedAt: Date.now(), note };
-    mkdirSync(dirname(trustedDomainsPath()), { recursive: true });
-    writeFileSync(trustedDomainsPath(), JSON.stringify(file, null, 2) + '\n', 'utf-8');
-}
-export function untrustDomain(host) {
-    const file = loadTrustedDomains();
-    const key = host.toLowerCase();
-    if (!file.domains[key])
-        return false;
-    delete file.domains[key];
-    writeFileSync(trustedDomainsPath(), JSON.stringify(file, null, 2) + '\n', 'utf-8');
-    return true;
-}
-export function gradeDomain(host) {
-    const userFile = loadTrustedDomains();
-    const userTrusted = !!userFile.domains[host.toLowerCase()];
-    for (const rule of WELL_KNOWN_GRADES) {
-        if (rule.pattern.test(host)) {
-            return {
-                host,
-                grade: rule.grade,
-                reason: rule.reason,
-                userTrusted,
-                requiresFirstWriteConfirmation: false,
-            };
-        }
-    }
-    if (userTrusted) {
-        return {
-            host,
-            grade: 'B',
-            reason: 'previously trusted by you · stored in trusted-domains.json',
-            userTrusted: true,
-            requiresFirstWriteConfirmation: false,
-        };
-    }
-    return {
-        host,
-        grade: 'F',
-        reason: 'unknown domain · not in well-known list · not previously trusted',
-        userTrusted: false,
-        requiresFirstWriteConfirmation: true,
-    };
-}
-/** Extract the host from a fully-resolved HTTPS URL. */
-export function hostOf(url) {
-    try {
-        return new URL(url).host;
-    }
-    catch {
-        return '';
-    }
-}
-//# sourceMappingURL=domain-trust.js.map