codehere 1.0.1 → 1.0.3

package/README.md

@@ -1,223 +1,65 @@
 # codehere
 
-> **One owned, signed record of what your AI coding agents did, and what they cost.**
-> For a team running more than one coding agent: an independent, cross-vendor record on your own machine. One `npm install`, no account.
+> **Re-runs the tests an AI says passed, and tells you whether they did.**
+> `codehere check` on your machine, or the GitHub Action on every pull request. No account.
 
-[![npm](https://img.shields.io/npm/v/codehere)](https://www.npmjs.com/package/codehere)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow)](../LICENSE)
-[![Internal tests](https://img.shields.io/badge/internal_tests-1371%2F1371-brightgreen)]()
-[![Honest status](https://img.shields.io/badge/honest--status-PRODUCT__STATE-blue)](../docs/PRODUCT_STATE.md)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow)](https://github.com/muhammadegaa/codehere/blob/main/LICENSE)
 
-**Codehere is the vendor-neutral layer between you and the coding agents you already use** — Claude Code, Codex, Aider, Gemini, OpenCode. One `npm install`. Local-first, OSS, no account, no IAM, no compliance prereqs. Switch agent, keep your memory. End the day with one Final Report covering what they did.
+`codehere check` re-runs your project's tests itself and reports the real result, so you do not have to take an agent's "all tests pass" on trust. It detects `npm test`, `node --test`, `pytest`, `go test`, `cargo test` and vitest or jest configs.
 
-All 5 adapters (Claude Code, Codex, Aider, Gemini, OpenCode) ship adapter code for session-tracing, Final Reports, and trust scoring. Claude Code additionally gets full pre-execution safety-hook enforcement on every tool call via the Claude Agent SDK. The *memory*, *audit log*, *failover*, and *Final Report* surfaces are wired across all 5 adapters today.
+## Install
 
-> **Honest status** — 1371 internal tests verify codehere's code against codehere's own assumptions about what each adapter emits, plus an end-to-end suite (`npm run e2e`) that drives the real product in a browser. The current verified / planned / blocked state of every surface lives in [`docs/PRODUCT_STATE.md`](../docs/PRODUCT_STATE.md) and the capability scoreboard [`docs/CAPABILITIES.md`](../docs/CAPABILITIES.md).
-
-The enterprise tier is owned by [OpenAI Frontier](https://openai.com/index/introducing-openai-frontier/) (8-14 weeks of deploy prereqs, sales-team gated) and [Anthropic Cowork](https://www.anthropic.com/product/claude-cowork) (paid Claude subscription, single-vendor). Codehere fills the gap they structurally can't reach: **the individual / small-team / no-IT-department tier, vendor-neutral**.
-
-> See [`docs/STRATEGIC_VISION.md`](../docs/STRATEGIC_VISION.md) Appendix C and [`docs/figures/positioning-matrix.svg`](../docs/figures/positioning-matrix.svg) for the full positioning chart.
-
-5 vendors supported, 2 proven on a real billed run. Your record, your machine, nobody's vendor.
-
----
-
-## Recipe — setup to first audit in 30 minutes
-
-> One folder convention, one prompt formula, four ready-to-use prompts.
-
-### Setup (once)
-
-| | | |
-|---|---|---|
-| 1 | **Install** | `npm install -g codehere` (Node 20+) — v0.8.0 is the current published stable (`@latest`) |
-| 2 | **Detect environment** | `codehere setup` — checks API key, finds your repo |
-| 3 | **Install the safety hook** | `codehere hook install` — every Claude Code tool call now audited |
-| 4 | **Install at least one specialist** | Claude Code: `npm i -g @anthropic-ai/claude-code` (Codex / Aider / OpenCode / Gemini also supported · see [docs/integrations/](../docs/integrations/) for Cursor MCP setup) |
-| 5 | **Scaffold this repo** | `cd /your/repo && codehere init` — creates `.codehere/` with the F3 memory tree (working / episodic / semantic / personal / candidates) plus `AGENTS.md` (project briefing) and `skills/` (prompt templates) |
-| 6 | **Fill in AGENTS.md** | 5 minutes. The agent will follow what's written there. |
-| 7 | **Build the symbol map (optional)** | `codehere memory repo-map` — JSON map of every top-level export in your repo, ranked by reference count. Spawned agents read it on entry instead of cold-grepping. |
-
-You're done. `codehere start` opens the web UI at `:3773`; you delegate from there.
-
-### The prompt formula
-
-```
-Context  +  End State  +  Constraints
 ```
-
-- **Context** — *"Read .codehere/CONTEXT.md"* + any specific files
-- **End State** — the user-visible change, the test that passes, the file that exists
-- **Constraints** — files not to touch, dependencies not to add, patterns not to use
-
-### Folder convention (what `codehere init` writes)
-
-The v0.6 layout — F3 project memory:
-
-| Path | Purpose | Committed? |
-|---|---|---|
-| `.codehere/AGENTS.md` *(or legacy `CONTEXT.md`)* | What this repo is. Conventions. Style. Constraints. | yes |
-| `.codehere/memory/working/session.md` *(or legacy `HANDOVER.md`)* | What's in flight in the current session. | **no** |
-| `.codehere/memory/episodic/AGENT_LEARNINGS.jsonl` | Symlink to your full session history at `~/.codehere/sessions.jsonl`. | (symlink) |
-| `.codehere/memory/episodic/repo_map.json` | Ranked symbol map. Built by `codehere memory repo-map`. | yes |
-| `.codehere/memory/semantic/lessons.jsonl` | Project-specific lessons promoted from episodic patterns. | yes |
-| `.codehere/memory/personal/preferences.json` | Per-developer prefs. | **no** |
-| `.codehere/skills/<name>/SKILL.md` *(or legacy flat `PROMPTS.md`)* | Prompt templates — one folder per skill. | yes |
-| `.codehere/protocols/permissions.md` + `hook_patterns.json` | Safety policy for the PreToolUse hook. | yes |
-
-Upgrading from v0.4.1? Run `codehere memory init` once — it migrates `CONTEXT/HANDOVER/PROMPTS` into the new layout and leaves symlinks at the old paths so back-compat holds. `--dry-run` shows what would move first.
-
----
-
-## What you see when you delegate a task
-
-`codehere start` opens `http://127.0.0.1:3773`. Pick an agent, type a task, hit **Assign**. codehere:
-
-1. Spawns the agent with the right headless flags
-2. Streams the steps back as readable progress · *"Read src/auth.ts · Edit src/auth.ts · Run npm test"*
-3. For Claude Code tasks: routes every tool call through the codehere safety hook — you see *"🛡 5 safe · 0 blocked"* grow live. For Codex / Aider / OpenCode / Gemini tasks: emits the agent's native event stream (no per-tool blocking yet)
-4. On completion, hands you a **Final report**: files changed with `+/-` lines, trust score per file, test pass/fail, token usage
-
-Claude Code tool calls are logged to `~/.codehere/audit/hook-events.jsonl`; spawned-task lifecycle (any adapter) is logged to `~/.codehere/sessions.jsonl`. Open-source MIT. Node 20+.
-
-### Just the safety hook (no agents required)
-
-If you only want the audit-and-block layer for AI tools you already use:
-
-```bash
-codehere hook install   # activates the PreToolUse hook in your global ~/.claude/settings.json
-codehere trust .        # static trust scan of the current directory
-codehere report         # generates a shareable markdown audit report
-codehere status         # quick dashboard · sessions, blocks, trust trends
+npx codehere check
 ```
 
-The hook intercepts every `Bash`, `Edit`, `Write`, `MultiEdit`, and `NotebookEdit` call from any Claude Code session running on your machine, runs it through the trust-scorer pattern bank in under 5 ms, blocks anything matching the destructive / credential / injection patterns, and appends every decision to an append-only JSONL audit log at `~/.codehere/audit/`. Codex, Aider, OpenCode, and Gemini adapters spawn through their native CLIs and emit to `~/.codehere/sessions.jsonl` with per-tool tracing via the cross-vendor mirror hook.
-
-## Memory · F3 (v0.6)
-
-Once you've run `codehere init` in a project, every spawned agent — Claude Code, Codex, Aider, OpenCode, or Gemini — automatically reads the project's memory on entry. The agent starts warm with the briefing, recent lessons, and the most-referenced symbols in your codebase, instead of cold-grepping every session.
-
-**What gets injected, in priority order:**
-1. **`.codehere/AGENTS.md`** — your project briefing (conventions, style, constraints)
-2. **`.codehere/memory/working/session.md`** — what's in flight right now (per-machine, gitignored)
-3. **`.codehere/memory/semantic/lessons.jsonl`** — graduated project-wide lessons
-4. **`.codehere/memory/episodic/repo_map.json`** — top-N most-referenced symbols (run `codehere memory repo-map` to build / refresh)
-
-The injection is token-budget-aware (default ~3000 tokens, drops lower-priority sections first to fit; AGENTS.md is never dropped). Pass `--no-memory-prefix` if you want the bare prompt for a one-off task.
+## The four commands
 
-**Inspect what would inject** before spawning anything:
-```bash
-codehere memory show injection
 ```
-
-**Add a lesson** so future spawns learn from it:
-```bash
-codehere memory graduate --add "auth tests live alongside source files"
-```
-
-**See everything codehere has accumulated:**
-```bash
-codehere memory show              # one-line summary per layer
-codehere memory show semantic     # numbered lesson list
-codehere memory show episodic     # session count + top symbols
-codehere memory show protocols    # safety patterns by category
+codehere check                                    # re-run the tests here
+codehere check --base origin/main                 # also read everything this branch changed
+codehere check --claim "<the agent's summary>"    # flag test files it named that do not exist
+codehere check --proof                            # a receipt you can paste into a pull request
 ```
 
-**Other memory commands:**
-- `codehere memory init` — migrate the v0.4.1 layout (`CONTEXT.md` / `HANDOVER.md` / `PROMPTS.md`) into the F3 layout (one shot, leaves back-compat symlinks; `--dry-run` previews)
-- `codehere memory repo-map [--rebuild]` — build the symbol map; currently TS-native MVP
-- `codehere protocols export [--rebuild]` — write the trust-scorer pattern bank to `.codehere/protocols/hook_patterns.json` for inspection / cross-tool ingestion
+`codehere help check` lists the options. `--json` adds a `verdict` (`pass`, `fail`, `unverified` or `skipped`) and the receipt text.
 
-## Going deeper
+Exit codes:
 
-For technical readers — the living documents that describe codehere as a system, not just a CLI:
+- **0**: the tests ran and passed, no test was weakened, no named test file is missing, and the weakened-test scan finished.
+- **1**: the tests failed; the runner reported no test that ran (0 tests, or every test skipped); the change made a test check nothing (an assertion swapped for `assert True` or `assert.ok(true)`, a skip marker, an assertion commented out, or a `return` above it); or a test file named in `--claim` is not in the repository. Usage errors (an unknown `--base`, a missing folder, an unknown option) also exit 1, with the message on stderr and nothing on stdout, and so does an internal error. Pass the claim as `--claim=<text>`: in `--claim --json` the claim is the text `--json`.
+- **2**: nothing could be verified: the run timed out, no test command was recognized, the runner is not installed, the re-run was turned off, or the weakened-test scan could not run (git is not installed, git could not read the repository, or the diff could not be read).
 
-| Doc | What it is |
-|---|---|
-| [`docs/BLUEPRINT.md`](../docs/BLUEPRINT.md) | The HOW — system overview, module map, data flow, adapter contracts, audit chain, failover, F3 memory, cost-bounded execution |
-| [`docs/THREAT_MODEL.md`](../docs/THREAT_MODEL.md) | Every attack surface, current mitigation, residual risk, planned hardening — npm supply chain, hook bypass, symlink redirect, audit log tampering, MCP server, prompt injection |
-| [`docs/CAPABILITIES.md`](../docs/CAPABILITIES.md) | Honest matrix of what each adapter can and cannot do today — Claude Code, Codex, Aider, OpenCode, Gemini, Generic CLI — across spawn, stream, per-tool block, audit, F3 memory, auth |
-| [`agent/REPO_MAP.md`](./REPO_MAP.md) | One-line-per-file index of the 54 source files with their top-level exports — generated, regenerated via `npm run repomap` after renames |
+Settings, as environment variables: `CODEHERE_TEST_CMD` replaces the detected test command (split on whitespace, no shell); `CODEHERE_RERUN_TIMEOUT_MS` sets the time limit in whole milliseconds (default 120000, two minutes, also used for a value that is not a whole number from 1 to 2147483647); `CODEHERE_RERUN_TESTS=0` turns the re-run off. Detection covers `npm test` (a `test` script in `package.json`), `go test ./...`, `cargo test`, `pytest` (with `pytest.ini`, `conftest.py` or a pytest section in `pyproject.toml` or `setup.cfg`), `vitest.config.ts`/`.js`, `jest.config.js`/`.ts`, and `node --test` for `*.test.js` files.
 
-## Commands
+"No test ran" is read from the runner's own summary for node:test, pytest, jest, vitest and Go's `[no test files]`. A Go package with test files but no tests (`[no tests to run]`), `cargo test` with 0 tests, jest with `--passWithNoTests`, mocha, and a test script that only prints "No tests found" read as a pass. A test script that leaves a background process holding its output open is reported as timed out, even when the tests passed.
 
-```
-codehere start              · launch the task intake web UI at :3773
-codehere task <prompt>      · spawn a task from the CLI (requires `start` running)
-codehere kill <sessionId>   · kill a running task
-codehere serve              · start as MCP server for Claude Desktop, Cursor, etc.
-codehere status             · dashboard · sessions, blocked calls, audit trends
-codehere trust [path]       · static trust scan · score 0-100, grade A-F
-codehere report             · generate a shareable markdown audit report
-codehere hook               · install/uninstall/inspect the PreToolUse safety hook
-codehere permission         · manage this folder's allow-list (skip false-positive blocks)
-codehere budget             · daily-spend ceiling · `set <usd>` blocks paid spawns at the cap
-codehere narrator           · customize the PM narrator prompt (~/.codehere/narrator-prompt.md)
-codehere setup              · interactive first-run setup wizard
-codehere config             · manage configuration and preferences
-codehere health             · system health check
-codehere help               · show help (use --all for hidden commands)
-codehere completion <shell> · generate bash/zsh/fish completion script
-codehere scan-tool          · internal · used by the hook system, not by users
-```
+## GitHub Action
 
-`codehere --help` for full options on each. `codehere status --weekly` produces a shareable 7-day agent-activity recap. `codehere status --export jsonl > audit.jsonl` exports the raw audit feed.
+A GitHub Action that posts the receipt on each pull request is in [`action/`](https://github.com/muhammadegaa/codehere/tree/main/action). It runs `npx codehere@<version> check --json --base origin/<base> --claim=<PR body>`. Its default version is 1.0.2. The 120-second default time limit applies, and the Action has no input to change it. With the default `fail-on-unverified: false`, a pull request that makes the suite unrunnable (removes the test script, breaks the runner) gets `unverified` and a green job with a warning, and a `skipped` verdict (the re-run turned off in the workflow) gets a green job with no warning. Set `fail-on-unverified: true` to fail the job on `unverified`. It is not published to the marketplace.
 
-## What it catches
+## What it does not catch
 
-The trust scorer + safety hook detect ~36 patterns across:
+- **Weakened tests.** The detector reads Python (`test_*.py`, `*_test.py`), JavaScript and TypeScript (`*.test.*`, `*.spec.*`), Go (`*_test.go`) and PHP (`*Test.php`) test files, and files under `test`, `tests` or `__tests__`. It flags an assertion replaced by an always-true one (`assert True`, `assert.ok(true)`, `assertTrue(True)`, a value compared with itself), a skip marker (including `skipif(True)`, `it.only(`, `test.only(` or `describe.only(` outside strings and `//` comments (including `test.describe.only(`), and in JavaScript, TypeScript and Vue files `fit(` or `fdescribe(` at the start of a statement, after `=>`, or after `await`, `return` or `void`; variants such as `test.only.each` are not flagged, a JavaScript helper or method named `fit` at the start of a statement is flagged, and `.vue` files are read only under `test`, `tests` or `__tests__`), a commented-out assertion and an early `return`. It does not flag a deleted assertion, a deleted test or test file, a loosened expectation, an always-true check written another way, or an edited test script. A very small test file that is renamed and changed in the same commit can read to git as a new file, and a new file is not scanned. Without `--base` it sees only uncommitted changes, so a weakened test that is already committed passes; with `--base <ref>` it sees everything since the branch left that ref. Only test files are diffed; if their diff cannot be read (over 64 MB), the run is reported as unverified. In a folder with no git repository and no `--base`, or before the first commit, the scan is skipped and the output says so. When git is missing or fails on a repository that is there, or `--base` is given outside a repository, the run is reported as unverified.
+- **`--claim`** finds test files named in the summary in plain text, in quotes or backticks, in markdown bold or italics, in brackets, in `path::test` form and with a `:line` suffix. It ignores absolute paths, Windows backslash paths and Java `*Test.java` names. A file counts as present when any file with the same name exists in the checkout (outside `node_modules`, `dist`, `build`, `vendor`, `target` and virtual environments), so a file in the wrong folder is not reported. The search goes 8 folders deep and stops after 50,000 entries, so a named file deeper than that, or in a larger checkout, is reported as missing.
+- **A passing suite with a broken build, and code the tests do not cover.** A receipt says what the test suite showed, not that the software is correct.
+- **Who controls the tests.** `check` runs the project's own test command, so whoever controls that command controls the result, and whoever controls the environment can point the weakened-test scan at another tree (`GIT_DIR`, `GIT_WORK_TREE`). For a pull request from someone you do not trust, a receipt is not evidence. In the Action, use the `pull_request` trigger, not `pull_request_target`.
 
-- SQL injection · XSS · command injection · path traversal
-- Hardcoded secrets · API keys · weak crypto · JWT bypass
-- Eval injection · prompt injection · credential theft
-- Destructive shell operations · supply-chain patterns
+## What has been measured
 
-Every blocked call is logged with the reason; every allowed call is logged with the trust score. Pattern bank lives in `agent/src/infrastructure/security/trust-scorer.ts`.
+- **False-done eval, 22 cases.** 14 false "tests pass" or "all green" claims (6 reconstructed from public posts, 8 planted) and 8 true ones. `codehere check` caught 12 of the 14 false claims, missed 2 (a green suite with a broken build, and green tests with a broken production job), and raised 0 false alarms on the 8 true ones. Result: [`agent/eval/false-done-result.json`](https://github.com/muhammadegaa/codehere/blob/main/agent/eval/false-done-result.json), produced by `node eval/false-done.mjs`. The cases were written to fit the detectors, so this is a small set and not a general rate.
+- **How often agent pull requests carry a failing claim: not measured.** A pre-registered study (S11) had two models label 299 public agent pull requests. They disagreed (Cohen's kappa 0.092), so the study reports no rate. The report, with the method and its limits: [`agent/eval/promise-verification/studies/S11-demand/REPORT.md`](https://github.com/muhammadegaa/codehere/blob/main/agent/eval/promise-verification/studies/S11-demand/REPORT.md).
 
-## MCP server
+## Development
 
-```bash
-codehere serve
 ```
-
-Exposes 6 read-only tools to any MCP client (Claude Desktop, Cursor, Zed, Continue, Cline, etc.):
-
-- `codehere_trust` · score a file or code snippet
-- `codehere_scan` · scan text for injection / threat patterns
-- `codehere_review` · scan a directory and return riskiest files
-- `codehere_audit` · read the local hook audit log
-- `codehere_spend` · today's estimated spend by agent and project, vs your budget
-- `codehere_team` · the team's merged cost and record across machines
-
-Connect it to **Claude Code** in one command (the daemon must be running):
-
+cd agent
+npm ci
+npm test            # build, then vitest
+npm run lint
+node eval/false-done.mjs
 ```
-claude mcp add --transport http codehere http://127.0.0.1:3773/mcp
-```
-
-Then from inside a Claude Code session you can ask things like "what did we spend today?" or "what did each agent do on this repo?" and it answers inline, no switching to the browser. Remove with `claude mcp remove codehere`.
-
-`codehere serve --show-config` prints the JSON block to paste into Claude Desktop's MCP settings.
-
-## Architecture, story, and contribution
-
-For depth beyond this README:
-
-- **[docs/STRATEGIC_VISION.md](../docs/STRATEGIC_VISION.md)** · 20-year invariants + v4 positioning (individual-tier vendor-neutral) · figures in `docs/figures/`
-- **[docs/PRD.md](../docs/PRD.md)** · master decision document · features, architecture, roadmap
-- **[docs/THREAT_MODEL.md](../docs/THREAT_MODEL.md)** · security posture · OWASP Top 10 + STRIDE · trust boundaries · hook-bypass analysis
-- **[docs/STRATEGY.md](../docs/STRATEGY.md)** · current strategy · competitive analysis (Conductor / Whim / Hermes), positioning, the wedge
-- **[CONTRIBUTING.md](../CONTRIBUTING.md)** · how to contribute · setup, commit discipline, testing philosophy
-- **[SECURITY.md](../SECURITY.md)** · responsible disclosure · `security@codehere.uk`
-- **[CODE_OF_CONDUCT.md](../CODE_OF_CONDUCT.md)** · community standards
-- **[CHANGELOG.md](../CHANGELOG.md)** · per-version release notes
-
-## Requirements
-
-- **Node.js 20+** (pinned in `.nvmrc` and `engines.node`)
-- **macOS or Linux** · Windows via WSL works for development
-- **Optional but recommended:** at least one supported agent (Claude Code, Codex, Aider, OpenCode, or Gemini) installed before running `codehere start`
 
 ## License
 
-MIT · see [LICENSE](../LICENSE).
+MIT. See [`LICENSE`](https://github.com/muhammadegaa/codehere/blob/main/LICENSE).

package/dist/application/use-cases/check-claimed-tests.js

@@ -0,0 +1,81 @@
+/**
+ * Did the agent name a test file that is not in the repo?
+ *
+ * "The webhook tests passed" while the file never existed is a lie a green re-run cannot see:
+ * the suite passes because it never contained the test. Given the agent's own words, this lists
+ * the test files it named that exist nowhere in the checkout. A file counts as present when any
+ * file with the same name exists (so a wrong folder is not flagged). Deterministic, no model.
+ * It cannot tell that a named test never ran, only that it is not there.
+ */
+import { readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+const TEST_FILE = /^(?:[\w.@-]+\/)*(?:test_[\w.-]+\.py|[\w.-]+_test\.(?:py|go)|[\w.-]+\.(?:test|spec)\.[cm]?[jt]sx?|[\w-]+Test\.php)$/;
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.venv',
+    'venv',
+    '__pycache__',
+    'vendor',
+    'target',
+]);
+const MAX_DEPTH = 8;
+const MAX_ENTRIES = 50_000;
+/** Separators: whitespace, quotes, backticks, brackets of every kind, markdown emphasis and table pipes. */
+const SEPARATORS = /[\s`'"(),;[\]<>{}|*]+/;
+/** `tests/test_x.py::test_y` → `tests/test_x.py`; `a.spec.ts:42:3` → `a.spec.ts`; `_a.test.js_` → `a.test.js`; trailing punctuation dropped. */
+function cleanToken(raw) {
+    let t = raw.replace(/^\.\//, '').replace(/::.*$/, '');
+    t = t.replace(/[.:…!?]+$/, '').replace(/(:\d+)+$/, '');
+    if (t.length > 2 && t.startsWith('_') && t.endsWith('_'))
+        t = t.slice(1, -1);
+    return t;
+}
+export function extractClaimedTestFiles(text) {
+    const found = [];
+    for (const raw of text.split(SEPARATORS)) {
+        const token = cleanToken(raw);
+        if (token.startsWith('/') || token.split('/').includes('..'))
+            continue;
+        if (TEST_FILE.test(token) && !found.includes(token))
+            found.push(token);
+    }
+    return found;
+}
+function namesInRepo(cwd) {
+    const names = new Set();
+    let seen = 0;
+    const walk = (dir, depth) => {
+        if (depth > MAX_DEPTH || seen > MAX_ENTRIES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            seen++;
+            if (e.isDirectory()) {
+                if (!SKIP_DIRS.has(e.name))
+                    walk(join(dir, e.name), depth + 1);
+            }
+            else {
+                names.add(e.name);
+            }
+        }
+    };
+    walk(cwd, 0);
+    return names;
+}
+export function findMissingClaimedTests(cwd, claim) {
+    const claimed = extractClaimedTestFiles(claim);
+    if (!claimed.length)
+        return [];
+    const present = namesInRepo(cwd);
+    return claimed.filter((p) => !present.has(basename(p)));
+}
+//# sourceMappingURL=check-claimed-tests.js.map

package/dist/application/use-cases/detect-test-weakening.js

@@ -0,0 +1,237 @@
+/**
+ * Did the change make a test pass without checking anything?
+ *
+ * A green re-run proves nothing when the agent got there by editing the test: swapping a failing
+ * assertion for `assert True`, skipping the test, commenting the assertion out, or returning above
+ * it. This reads `git diff` against HEAD and flags such lines added to test files that already
+ * existed. It is a deterministic diff read (no model), so it is measured evidence (DESIGN.md §1).
+ * By default it reads uncommitted changes against HEAD. With a base ref it reads everything since
+ * the branch left that base (committed or not), which is the view a pull request needs.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const TEST_PATH = /(^|\/)(test_[^/]*\.py|[^/]*_test\.py|[^/]*\.(test|spec)\.[cm]?[jt]sx?|[^/]*_test\.go|[^/]*Test\.php)$|(^|\/)(__tests__|tests?)\//;
+const TRIVIAL = [
+    // `assert True`, `assert(True)`, `assert True, "message"`
+    /^assert\s*\(?\s*(True|1|not\s+False)\s*\)?\s*(,.*)?(#.*)?$/,
+    /^assert\s+([\w.'"]+)\s*==\s*\1\s*(#.*)?$/,
+    /\bexpect\(\s*(true|1)\s*\)\s*\.\s*(toBe|toEqual|toStrictEqual)\(\s*(true|1)\s*\)/,
+    /\bexpect\(\s*([\w.'"]+)\s*\)\s*\.\s*(toBe|toEqual|toStrictEqual)\(\s*\1\s*\)/,
+    /\bexpect\(\s*true\s*\)\s*\.\s*toBeTruthy\(\)/,
+    /\bassert(\.ok)?\(\s*true\s*\)/,
+    /\bassert\.(equal|strictEqual|deepEqual|deepStrictEqual)\(\s*([\w.'"]+)\s*,\s*\2\s*\)/,
+    /\bassert(Equal|Equals|Same)\(\s*([\w.'"]+)\s*,\s*\2\s*\)/,
+    /\bassertTrue\(\s*(true|True)\s*\)/,
+];
+const SKIP = [
+    /@pytest\.mark\.(skip|xfail)\b/,
+    /@pytest\.mark\.skipif\(\s*True\b/,
+    /\bpytest\.(skip|xfail)\(/,
+    /@unittest\.skip/,
+    /\b(it|test|describe)\.(skip|todo)\(/,
+    /\b(xit|xtest|xdescribe)\(/,
+    /\bmarkTest(Skipped|Incomplete)\(/,
+    /\bt\.Skip(f|Now)?\(/,
+    // node:test options: { skip: true } / { skip: 'reason' } / { todo: true }; a conditional skip is left alone
+    /\b(skip|todo)\s*:\s*(true\b|['"`])/,
+];
+/** `.only` makes jest, mocha and Playwright skip every other test: the original pattern, on any test file. */
+const ONLY = /\b(it|test|describe)\.only\(/;
+/** `fit` and `fdescribe` do the same, but `fit` is also an ordinary function name: JS, TS and Vue files, at a statement
+ * start, after `=>`, or after `void`, `await` or `return`. */
+const JS_FILE = /\.([cm]?[jt]sx?|vue)$/i;
+const JS_FOCUS = /(^|[;{}]\s*|=>\s*|\b(void|await|return)\s+)(fit|fdescribe)\(/;
+/** The line with quoted text emptied and a trailing `//` comment dropped, so neither can pose as a call. */
+const jsCode = (text) => text.replace(/(["'`])(?:\\.|(?!\1).)*\1/g, '""').replace(/\/\/.*$/, '');
+const ASSERTION = /\b(assert\w*|expect|should|self\.assert\w*|this->assert\w*|t\.(Error|Fatal)\w*)\s*[.(]|^\s*assert\s+\S/;
+const BARE_RETURN = /^return\s*;?$/;
+/** A line that opens a branch: a return under it is conditional, not an unconditional skip. */
+const CONDITIONAL = /^(\}\s*)?(if|else|for|while|switch|case|default|catch|try|finally)\b/;
+/** How far below a bare return an assertion still counts as the one it hides. */
+const RETURN_LOOKAHEAD = 8;
+function uncomment(text) {
+    const m = /^(?:\/\/+|#+|\/\*+|\*)\s?(.*?)\s*(?:\*\/)?$/.exec(text);
+    return m ? m[1].trim() : null;
+}
+/** The commented text is an assertion that the same change removed (alone on its line, or inside a one-line test). */
+function wasCommentedOut(body, removed) {
+    const core = body.replace(/;$/, '');
+    return core.length >= 12 && ASSERTION.test(core) && removed.some((r) => r.includes(core));
+}
+/** `b/path` or git's C-quoted `"b/p\"ath"` form → `path`. */
+function headerPath(raw) {
+    // git appends a tab to the header when the path contains a space.
+    const v = raw.slice(4).replace(/\t$/, '');
+    if (v.startsWith('b/'))
+        return v.slice(2);
+    if (v.startsWith('"b/') && v.endsWith('"')) {
+        return v.slice(3, -1).replace(/\\(["\\tn])/g, (_, c) => (c === 't' ? '\t' : c === 'n' ? '\n' : c));
+    }
+    return null;
+}
+export function parseTestWeakening(diff, readLines) {
+    const found = [];
+    let file = null;
+    let existing = false;
+    let line = 0;
+    let removed = [];
+    // File headers (`--- a/...`, `+++ b/...`) only appear between `diff --git` and the first hunk, so an added line
+    // whose text starts with `++ ` cannot pose as a header.
+    let inHeader = false;
+    for (const raw of diff.split('\n')) {
+        if (raw.startsWith('diff --git ')) {
+            file = null;
+            existing = true;
+            removed = [];
+            inHeader = true;
+        }
+        else if (inHeader && raw.startsWith('--- ')) {
+            existing = raw !== '--- /dev/null';
+        }
+        else if (inHeader && raw.startsWith('+++ ')) {
+            const path = headerPath(raw);
+            file = path && existing && TEST_PATH.test(path) ? path : null;
+        }
+        else if (raw.startsWith('@@')) {
+            inHeader = false;
+            const m = /\+(\d+)/.exec(raw);
+            line = m ? Number(m[1]) : 0;
+            removed = [];
+        }
+        else if (raw.startsWith('-')) {
+            removed.push(raw.slice(1).trim());
+        }
+        else if (raw.startsWith('+') && file) {
+            const text = raw.slice(1).trim();
+            const body = uncomment(text);
+            let why = null;
+            if (TRIVIAL.some((re) => re.test(text)))
+                why = 'trivial-assertion';
+            else if (SKIP.some((re) => re.test(text)) ||
+                ONLY.test(jsCode(text)) ||
+                (JS_FILE.test(file) && JS_FOCUS.test(jsCode(text))))
+                why = 'skipped';
+            else if (body !== null && wasCommentedOut(body, removed))
+                why = 'commented-out';
+            else if (BARE_RETURN.test(text)) {
+                const lines = readLines?.(file);
+                const above = (lines?.[line - 2] ?? '').trim();
+                const below = lines?.slice(line, line + RETURN_LOOKAHEAD) ?? [];
+                if (!CONDITIONAL.test(above) && below.some((l) => ASSERTION.test(l)))
+                    why = 'unreachable-assertion';
+            }
+            if (why)
+                found.push({ file, line, why, text: text.slice(0, 80) });
+            line++;
+        }
+    }
+    return found;
+}
+/** The commit the current branch left `base` at, so changes made on `base` since are not blamed on the branch. */
+function resolveBase(cwd, base) {
+    if (base.startsWith('-'))
+        throw new Error(`Invalid --base "${base}": a ref cannot start with "-".`);
+    try {
+        return execFileSync('git', ['merge-base', base, 'HEAD'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        throw new Error(`Unknown --base "${base}": not a ref in this repository.`);
+    }
+}
+const MAX_DIFF = 64 * 1024 * 1024;
+/** git with literal paths and unquoted non-ASCII names. */
+function git(cwd, args) {
+    // GIT_DIFF_OPTS overrides --unified=0, and context lines would shift every line number after them.
+    const env = { ...process.env };
+    delete env.GIT_DIFF_OPTS;
+    return execFileSync('git', ['-c', 'core.quotepath=false', '--literal-pathspecs', ...args], {
+        cwd,
+        env,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: MAX_DIFF,
+    });
+}
+function hasGitAbove(cwd) {
+    for (let d = resolve(cwd);; d = dirname(d)) {
+        if (existsSync(join(d, '.git')))
+            return true;
+        if (dirname(d) === d)
+            return false;
+    }
+}
+/**
+ * Changes in `cwd` against HEAD, or against where the branch left `base` when it is given. Only test files are
+ * diffed, so a large change elsewhere cannot push the test diff past the read limit.
+ */
+export function scanTestWeakening(cwd, base) {
+    try {
+        git(cwd, ['rev-parse', '--is-inside-work-tree']);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return { findings: [], error: 'git is not installed' };
+        // Skipped only when there is no repository at all. Any other git failure (GIT_DIR, ownership checks, a broken
+        // .git) means the scan should have run and did not; with --base a repository is required.
+        if (!base && !hasGitAbove(cwd))
+            return { findings: [], skipped: 'not a git repository' };
+        return { findings: [], error: 'git could not read this repository; run `git status` here to see why' };
+    }
+    if (!base) {
+        try {
+            git(cwd, ['rev-parse', '--verify', '--quiet', 'HEAD']);
+        }
+        catch {
+            return { findings: [], skipped: 'no commit to compare against yet' };
+        }
+    }
+    const from = base ? resolveBase(cwd, base) : 'HEAD';
+    // Fixed diff options, so a user's or the change's own git config cannot alter what the parser reads: paths
+    // relative to `cwd` (a package folder inside a repository), a/ and b/ prefixes, no external diff or textconv,
+    // binary attributes ignored, renames paired.
+    const opts = ['--relative', '--no-ext-diff', '--no-textconv', '--text', '--src-prefix=a/', '--dst-prefix=b/', '-M'];
+    let tests;
+    try {
+        // -z name-status: status, path (and for renames and copies a second path), NUL-separated. Both paths of a
+        // rename go into the pathspec so git can pair them; a test renamed and weakened is still an existing test.
+        const fields = git(cwd, ['diff', ...opts, '--name-status', '-z', from]).split('\0');
+        tests = [];
+        for (let i = 0; i < fields.length - 1;) {
+            const status = fields[i++];
+            const paths = /^[RC]/.test(status) ? [fields[i++], fields[i++]] : [fields[i++]];
+            if (paths.some((p) => p && TEST_PATH.test(p)))
+                tests.push(...paths.filter(Boolean));
+        }
+    }
+    catch {
+        return { findings: [], error: 'could not read the diff (the list of changed files)' };
+    }
+    if (!tests.length)
+        return { findings: [] };
+    let diff;
+    try {
+        diff = git(cwd, ['diff', ...opts, '--unified=0', '--no-color', from, '--', ...tests]);
+    }
+    catch {
+        return {
+            findings: [],
+            error: `could not read the diff of ${tests.length} changed test file(s); it may be larger than 64 MB`,
+        };
+    }
+    return {
+        findings: parseTestWeakening(diff, (f) => {
+            try {
+                return readFileSync(join(cwd, f), 'utf8').split('\n');
+            }
+            catch {
+                return null;
+            }
+        }),
+    };
+}
+//# sourceMappingURL=detect-test-weakening.js.map