neohaskell
diff --git a/‎.claude/hooks/session-start.sh‎
Lines changed: 9 additions & 1 deletion b/‎.claude/hooks/session-start.sh‎
Lines changed: 9 additions & 1 deletion
diff --git a/‎.github/workflows/checks.yml‎
Lines changed: 30 additions & 0 deletions b/‎.github/workflows/checks.yml‎
Lines changed: 30 additions & 0 deletions
diff --git a/‎.gitignore‎
Lines changed: 5 additions & 0 deletions b/‎.gitignore‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎AGENTS.md‎
Lines changed: 18 additions & 0 deletions b/‎AGENTS.md‎
Lines changed: 18 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 24 additions & 0 deletions b/‎README.md‎
Lines changed: 24 additions & 0 deletions
diff --git a/‎cabal.project.dev‎
Lines changed: 10 additions & 0 deletions b/‎cabal.project.dev‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎dev‎
Lines changed: 54 additions & 0 deletions b/‎dev‎
Lines changed: 54 additions & 0 deletions
diff --git a/‎docs/plans/2026-07-07-continuous-generation-pipeline-plan.md‎
Lines changed: 5 additions & 1 deletion b/‎docs/plans/2026-07-07-continuous-generation-pipeline-plan.md‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎nix/hix.nix‎
Lines changed: 1 addition & 0 deletions b/‎nix/hix.nix‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎scripts/check‎
Lines changed: 33 additions & 0 deletions b/‎scripts/check‎
Lines changed: 33 additions & 0 deletions
@@ -21,7 +21,15 @@
 #
 set -euo pipefail
 
-# Only run inside the remote (Claude Code on the web) environment.
+# --- 0. Warm Postgres for the test suites (local + remote, best-effort) -----
+# Service/integration suites gate on POSTGRES_AVAILABLE; keeping the container
+# warm removes a ~10s cold-start from the verification loop (pipeline Phase 1).
+# Backgrounded and failure-tolerant: no docker => no-op.
+if command -v docker >/dev/null 2>&1; then
+  (cd "${CLAUDE_PROJECT_DIR:-$(pwd)}" && docker compose up -d >/dev/null 2>&1 || true) &
+fi
+
+# Only run the rest inside the remote (Claude Code on the web) environment.
 if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
   exit 0
 fi
 
@@ -0,0 +1,30 @@
+# Fast governance checks (pipeline Phase 1+). Pure bash, no toolchain —
+# feedback in seconds, long before the build workflows finish.
+#
+# Currently: ./dev doctor — enforces "every pipeline asset registers a ./dev
+# verb or carries a reasoned exemption" (see scripts/doctor for the contract).
+# Phase 2 adds the dialect hlint gate as a separate job (needs the toolchain).
+name: checks
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: checks-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  doctor:
+    name: dev doctor (verb registration)
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+      - run: ./dev doctor
@@ -82,3 +82,8 @@ installer/target/
 .ruff_cache
 # Phase 0: untracked local pipeline-state archive (Phase 1 will manage telemetry/ properly)
 /telemetry/archive/
+
+# Phase 1: inner-loop + telemetry local state
+.ghcid-errors.txt
+/telemetry/.current-run.json
+/telemetry/golden/
@@ -34,6 +34,24 @@ cabal test                      # all suites (Postgres needed: docker-compose up
 ./testbed/scripts/run-tests.sh  # acceptance tests (auto-starts the app)
 ```
 
+## Fast inner loop (measured 2026-07-07 — use this in repair loops, NOT cabal build)
+
+Single entrypoint: **`./dev`** (no-args lists all verbs; same tools for humans and agents, deliberately):
+
+```bash
+./dev watch                  # start resident typecheck watcher → .ghcid-errors.txt (once per session)
+./dev check                  # quick typecheck status (instant from watcher; one-shot fallback)
+./dev test "pattern" [suite] # link-free hspec --match (~4-9s; default suite nhcore-test-core)
+./dev refresh                # re-warm -O0 build after pull/switch; prints modules-rebuilt
+./dev exec <cmd>             # any command with the pinned toolchain
+```
+
+- Repair-loop protocol: edit → wait ~2s → **`./dev check`** (measured: error feedback 0.6s, recovery 1.9s). Never spawn `cabal build` inside the loop.
+- You do NOT need to be inside `nix develop`: every verb self-provisions the pinned toolchain (~0.4s warm overhead).
+- Everything uses the dev flavor (`cabal.project.dev`, `-O0`); full nhcore -O0 build = 249 modules / ~54s on this machine.
+- Pipeline telemetry: `scripts/telemetry.py` (schema: `telemetry/SCHEMA.md`, frozen v1). Every pipeline run emits one line to `telemetry/runs.jsonl`. Telemetry is pipeline-only: never emit lines for ad-hoc runs.
+- These are the same commands humans use (README "Fast inner loop") — parity is deliberate; don't create agent-only variants.
+
 - Test discovery: **only `nhcore-test` uses hspec-discover**; `nhcore-test-core`, `-auth`, `-service`, `-integration` register specs manually in their `Main.hs` — new spec modules must be added there AND to the cabal `other-modules`.
 - Postgres-dependent specs self-gate on `POSTGRES_AVAILABLE=true`.
 - ⚠ **hlint does NOT run in CI**, and the current `.hlint.yaml` does not encode NeoHaskell style — do not treat hlint output as style guidance until the Phase 2 rebuild lands.
 
@@ -80,6 +80,30 @@ To run manually:
 hlint .
 ```
 
+> ⚠ The current hlint configuration does not yet encode NeoHaskell's dialect
+> rules and does not run in CI — don't treat its output as style guidance.
+> The dialect-first rebuild is tracked in
+> [#715](https://github.com/neohaskell/NeoHaskell/issues/715) (Phase 2).
+
+## Fast inner loop
+
+The same tools the CI/agent pipeline uses work on demand for humans (they are
+the *same scripts* on purpose — if you can't reproduce what the pipeline saw,
+you can't debug it). One entrypoint, run `./dev` for the full menu:
+
+```sh
+./dev watch                          # resident typecheck watcher (ghcid, -O0)
+./dev check                          # instant typecheck status
+./dev test "EventStore"              # run only matching specs, no linking (~4-9s)
+./dev test "insert" nhcore-test-service   # pick a suite
+./dev refresh                        # re-warm the -O0 build after pull/branch switch
+./dev exec ghc --version             # anything else, with the pinned toolchain
+```
+
+Typecheck feedback lands in under a second once the watcher is running. You
+don't need to be inside `nix develop`: every verb enters it on demand (pinned
+toolchain from any bare shell). Measured baselines: `telemetry/SCHEMA.md`.
+
 ## Running Tests
 
 The core library tests are split into domain-specific suites that run in parallel on CI:
 
@@ -0,0 +1,10 @@
+-- Fast dev flavor for the agent inner loop (pipeline Phase 1).
+-- Usage: cabal build --project-file=cabal.project.dev <target>
+--        (scripts/dev-loop and scripts/test-match use this automatically)
+--
+-- Rationale: the repair loop must never pay -O1 compile times. The bake job
+-- and all pool worktrees build with THIS flavor so dist-newstyle stays valid
+-- for the loop (optimization level is part of the build-config hash).
+import: cabal.project
+
+optimization: 0
@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+#
+# Developer entrypoint — dispatches the shared human/agent dev tools.
+# (Pipeline doctrine: every pipeline tool is a human tool; every new pipeline
+# asset registers a verb here or it doesn't ship.)
+#
+# Implementations live in scripts/; all of them self-provision the pinned
+# toolchain via scripts/with-toolchain — no need to be inside `nix develop`.
+#
+set -euo pipefail
+cd "$(dirname "$0")"
+
+usage() {
+  cat <<'EOF'
+usage: ./dev <verb> [args]
+
+  watch [target]        start the resident typecheck watcher (ghcid, -O0);
+                          writes errors to .ghcid-errors.txt (default: lib:nhcore)
+  check [target]        quick typecheck status — reads the watcher's file
+                          (instant), or one-shot typecheck of target if no watcher
+  test "pattern" [suite]  run only matching specs, link-free (~4-9s;
+                          default suite: nhcore-test-core)
+  refresh [target]      re-warm the -O0 build after pull/branch switch;
+                          prints modules-rebuilt (cache health)
+  doctest               run the doctest suite
+  test-all              run every test suite (colored human runner)
+  doctor                harness self-check: every script has a verb or a
+                          reasoned exemption; no dangling verbs (CI-enforced)
+  exec <cmd> [args]     run any command with the pinned toolchain
+                          (e.g. ./dev exec ghc --version)
+
+Measured baselines: telemetry/SCHEMA.md
+EOF
+}
+
+VERB="${1:-}"
+[ $# -gt 0 ] && shift
+
+case "${VERB}" in
+  watch)    exec scripts/watch "$@" ;;
+  check)    exec scripts/check "$@" ;;
+  test)     exec scripts/test-match "$@" ;;
+  refresh)  exec scripts/refresh-dev-cache "$@" ;;
+  doctest)  exec scripts/run-doctest "$@" ;;
+  test-all) exec scripts/run-all-tests.sh "$@" ;;
+  doctor)   exec scripts/doctor "$@" ;;
+  exec)     exec scripts/with-toolchain "$@" ;;
+  ""|help|-h|--help) usage ;;
+  *)
+    echo "dev: unknown verb '${VERB}'" >&2
+    usage >&2
+    exit 2
+    ;;
+esac
@@ -23,11 +23,15 @@
 | Invented-API events (GHC "not in scope") per PR | unmeasured | measured, trending ↓ |
 | Style violations reaching CI | unmeasured | 0 (caught at edit-hook/hlint layer) |
 
-## Governing rule (the anti-rot constitution)
+## Governing rules (the anti-rot constitution)
 
 > **No agent-visible document without a CI check or a generation source.**
 > Every asset in this plan is either compiler/script-generated (with a regenerate-and-diff sync check) or human-curated (with a structural validity check). Anything else gets archived.
 
+> **Every pipeline tool is a human tool.** (Added 2026-07-07, panel-reviewed.) Same script, same environment, same build flavor for agents and humans — parity is what makes agent failures reproducible by a human in minutes. Non-interactive by default; TTY niceties never break the agent path. Telemetry records *pipeline runs only* — ad-hoc human use never emits. **Human-runnable is an acceptance criterion for every pipeline asset**, operationalized as: every asset registers a verb in `./dev`.
+
+> **Every governing rule names its gate.** (Added 2026-07-07.) A rule without a named enforcement mechanism is a wish — rejected at plan review. Current pairings: doc-truth → `codemap check` + generated-file sync checks (Phase 3); verb registration → `./dev doctor` (CI: `checks.yml`, seconds, no toolchain); telemetry discipline → emitter validation in `scripts/telemetry.py`; dialect → hlint CI gate + edit hook (Phase 2); spec fidelity → signatures drift check (Phase 5); doc coverage → the ratchet (Phase 3).
+
 ---
 
 ## Phase 0 — Archive & truth reset
 
@@ -23,6 +23,7 @@
     hspec-discover = "latest";
     haskell-language-server = "latest";
     cabal-gild = "latest";
+    ghcid = "latest"; # powers scripts/dev-loop (agent + human inner loop)
   };
   shell.buildInputs = with pkgs; [ git nixfmt-classic postgresql hurl poppler_utils ];
 }
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+#
+# Quick typecheck status (pipeline Phase 1). THE verb agents and humans call
+# after an edit — instantaneous when the watcher is running.
+#
+#   ./dev check
+#
+# Reads the watcher's output file (.ghcid-errors.txt, rewritten by
+# `./dev watch` on every save). If no watcher is running, falls back to a
+# one-shot incremental typecheck (a few seconds at -O0).
+#
+# Exit code: 0 = typechecks, 1 = errors.
+#
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "${SCRIPT_DIR}/.."
+
+TARGET="${1:-lib:nhcore}"
+OUT=".ghcid-errors.txt"
+
+if [ -f "${OUT}" ]; then
+  # mtime shown so a stale file (killed watcher) is detectable at a glance.
+  echo "check: from watcher (file updated $(date -r "${OUT}" '+%H:%M:%S')):"
+  cat "${OUT}"
+  if [ ! -s "${OUT}" ] || grep -q "All good" "${OUT}"; then
+    exit 0
+  else
+    exit 1
+  fi
+else
+  echo "check: no watcher running (start one with ./dev watch) — one-shot typecheck of ${TARGET}:" >&2
+  "${SCRIPT_DIR}/with-toolchain" cabal build "${TARGET}" --project-file=cabal.project.dev 2>&1 | tail -5
+fi
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@`
`23`	`23`	`hspec-discover = "latest";`
`24`	`24`	`haskell-language-server = "latest";`
`25`	`25`	`cabal-gild = "latest";`
	`26`	`+ ghcid = "latest"; # powers scripts/dev-loop (agent + human inner loop)`
`26`	`27`	`};`
`27`	`28`	`shell.buildInputs = with pkgs; [ git nixfmt-classic postgresql hurl poppler_utils ];`
`28`	`29`	`}`