@jwilger/pi-development-system 0.9.0 → 0.10.1

package/extensions/development-system.ts

@@ -3,17 +3,22 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { appendContextTail, renderContextTail } from "../src/context/context-tail.ts";
 import { renderStatus, renderStatusLine, STATUS_KEY } from "../src/context/status.ts";
 import { applyPromptSection } from "../src/context/system-prompt.ts";
+import { detectProfiles } from "../src/core/profile.ts";
 import { createApprovalStore } from "../src/gates/approvals.ts";
 import { registerCommitGuard } from "../src/gates/commit-guard.ts";
 import { registerGitGuard } from "../src/gates/git-guard.ts";
+import { registerLintSuppressionGuard } from "../src/gates/lint-suppression-guard.ts";
 import { registerPushGuard } from "../src/gates/push-guard.ts";
 import { createRecordDepartureTool } from "../src/gates/record-departure-tool.ts";
+import { registerRedFirstGuard } from "../src/gates/red-first-guard.ts";
 import { createRequestApprovalTool } from "../src/gates/request-approval-tool.ts";
 import { registerTestGuard } from "../src/gates/test-guard.ts";
 import { createJevHolder } from "../src/jev/holder.ts";
 import { registerCiCommand } from "../src/state/ci-command.ts";
+import { loadConfig } from "../src/state/config.ts";
 import { createModelsTool, registerModelsCommand } from "../src/state/models-command.ts";
 import { createSessionState } from "../src/state/session-state.ts";
+import { registerTestEvidence } from "../src/state/test-evidence.ts";
 
 const nonNegotiables = readFileSync(
   new URL("../principles/NON-NEGOTIABLES.md", import.meta.url),
@@ -33,7 +38,15 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     lastCtx?.ui.setStatus(STATUS_KEY, renderStatusLine(state.get(), jevModel));
   };
 
-  const rebuild = (ctx: ExtensionContext) => {
+  const refreshProfiles = async (ctx: ExtensionContext) => {
+    const config = await loadConfig(ctx.cwd);
+    const override = config.ok ? config.value.profiles.override : [];
+    const profiles = await detectProfiles(ctx.cwd, override);
+    const current = state.get().profiles ?? [];
+    if (profiles.join() !== current.join()) state.update((s) => ({ ...s, profiles }));
+  };
+
+  const rebuild = async (ctx: ExtensionContext) => {
     lastCtx = ctx;
     const entries = ctx.sessionManager
       .getBranch()
@@ -45,6 +58,7 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     jevModel = probe.model;
     state.update((s) => (s.jev === probe.availability ? s : { ...s, jev: probe.availability }));
     refreshStatus();
+    await refreshProfiles(ctx);
   };
 
   state.onChange(refreshStatus);
@@ -80,6 +94,9 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     exec: (command, args, options) => pi.exec(command, args, options),
   });
   registerTestGuard({ pi, state, approvals, jev: (ctx) => jevHolder.forContext(ctx) });
+  registerTestEvidence({ pi, state });
+  registerRedFirstGuard({ pi, state });
+  registerLintSuppressionGuard({ pi, state });
   pi.registerTool(createRecordDepartureTool({ pi, state }));
   pi.registerTool(createRequestApprovalTool({ pi, approvals }));
   pi.registerTool(createModelsTool());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/skills/behaviour-tests/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: behaviour-tests
+description: Tests that assert observable behaviour through public interfaces, built as vertical slices, never against committed file text or internal structure. Use when writing or reviewing a test, deciding what to assert, or when a refactor breaks tests that should not care.
+---
+
+# Behaviour tests
+
+A test is an executable statement of behaviour a user of the code could observe.
+It should survive any refactor that keeps that behaviour.
+
+## Rules
+
+- **Black-box.** Call the public interface; assert on outputs and observable effects.
+  If the test must reach into private state, the interface is missing something.
+- **Vertical slices.** Each test drives one user-visible capability from entry point to
+  outcome, with real core code and only the *outside world* faked (exec, clock, UI).
+- **Name the behaviour,** not the function: "a commit with a Co-Authored-By trailer is
+  blocked", not "test checkCommit 3".
+- **One reason to fail** per test, and a failure message that says what was expected.
+- **Table tests for pure rules:** input, expected value, one row per case, including
+  edge and hostile inputs (empty, huge, malformed, adversarial).
+- **Tests go beside the code they prove** and run in the default test command.
+
+## Desiderata (Beck) to trade off consciously
+
+Tests should be isolated, deterministic, fast, readable, behavioural, structure-
+insensitive and specific about failures. When two conflict, say which you picked.
+
+## Do not
+
+- Do not assert on committed file text or structure ("README contains X",
+  "file has 40 lines"). It pins wording, not behaviour, and breaks on every edit.
+  Exception: a lint test that checks a *contract* (skill frontmatter, referenced paths).
+- Do not mock the unit under test, or assert that an internal function was called.
+- Do not share mutable state between tests or rely on order.
+- Do not snapshot big outputs you did not read. A snapshot nobody reviewed asserts nothing.
+- Do not delete or skip a test to get green. Fix the code (gate `tests.weaken`).
+
+## Checklist
+
+- [ ] Asserts on outputs/effects through the public interface
+- [ ] Named after the behaviour
+- [ ] Only the outside world is faked
+- [ ] Includes edge and hostile inputs for pure rules
+- [ ] Survives a behaviour-preserving refactor

package/skills/functional-core-imperative-shell/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: functional-core-imperative-shell
+description: Functional core, imperative shell - keep decisions in pure functions and push all I/O to a thin outer layer that executes the effects. Use when designing a module, deciding where logic belongs, or when a test needs mocks or a real filesystem/network to check a business rule.
+---
+
+# Functional core, imperative shell
+
+Decisions are data-in, data-out functions with no I/O. The shell reads the world,
+calls the core, and performs what the core returned. This is what makes behaviour
+testable without mocks and keeps the part that changes most (policy) easy to change.
+
+## Shape
+
+- **Core** (`src/core/`): pure. Takes values, returns values (including *descriptions*
+  of effects). No `fs`, network, clock, randomness, environment, or logging.
+- **Shell** (`src/<adapter>/`, entry points): reads input, calls the core, runs the
+  returned effects, maps results to the outside world. Holds no business rules.
+- **Effects as data:** when the core needs "then do X, then decide Y", return a
+  step the shell executes and feeds back (a `Step`/continuation or a plain list of
+  commands) rather than calling X itself.
+- **Time, ids and randomness are inputs.** Pass `now`/`newId` in; tests then pass
+  fixed values.
+
+## Do not
+
+- Do not call `Date.now()`, read env vars or touch the filesystem inside core logic.
+  The test for the rule then needs a fake clock or temp dir, which means the rule is
+  not isolated.
+- Do not put a conditional business rule in the shell "because it is only one if".
+  Rules accrete; the shell becomes the place nobody can test.
+- Do not mock the core to test the shell. Give the shell real core code and fake only
+  the outside world (the exec function, the clock, the UI).
+- Do not let core types import shell types. Dependencies point inward only.
+
+## Test consequence
+
+Core tests are plain table tests: input in, expected value out, no setup. If a core
+test needs setup, something impure leaked in. Shell tests check wiring: given this
+outside-world response, the right effect was executed.
+
+## Checklist
+
+- [ ] The rule lives in a function with no I/O imports
+- [ ] Time, ids and randomness arrive as parameters
+- [ ] The shell contains no branching on business conditions
+- [ ] Core tests need no mocks, temp files or network
+- [ ] No inward-pointing import from core to shell

package/skills/profile-rust/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: profile-rust
+description: Rust idioms for this development system - nutype-style semantic types, thiserror error enums, strict clippy, cargo-mutants policy, test layout. Use when working in a Rust repo (Cargo.toml, *.rs files), adding a crate, or reviewing Rust code.
+---
+
+# Rust profile
+
+Applies the universal skills (`tdd-canon`, `functional-core-imperative-shell`,
+`semantic-types`, `typed-errors`, `strict-lints`, `behaviour-tests`) with Rust idioms.
+Read the reference you need, not all of them:
+
+- Semantic types: `references/types.md`
+- Errors: `references/errors.md`
+- Lints: `references/lints.md`
+- Tests and mutation testing: `references/tests.md`
+
+## Defaults
+
+- **Newtypes with a fallible constructor** for every domain value; no public field
+  that lets a caller skip validation.
+- **`Result<T, E>` everywhere** a caller can recover; `thiserror` enums, one per module.
+  `anyhow` only in binaries' `main`, never in library code.
+- **Core is pure.** Effects are a returned `Step`/command enum executed by a thin
+  `main`/adapter layer; the core crate has no `std::fs`, `std::time` or `std::env`.
+- **Pedantic clippy as errors** in CI; every `#[allow]` has a reason
+  (`#[allow(..., reason = "...")]` or a trailing comment).
+- **No `unwrap`/`expect`/`panic!`/indexing in non-test code** unless it is a proven
+  invariant with a comment naming the proof.
+
+## Do not
+
+- Do not use `String`/`PathBuf`/`u64` for domain values with rules. Name the newtype.
+- Do not `#[allow(clippy::...)]` at crate level to quiet a few warnings.
+- Do not `unwrap()` on input that came from outside the process.
+- Do not make types `pub` just to test them; test through the public interface.
+
+## Checklist
+
+- [ ] New domain values are newtypes with fallible constructors
+- [ ] Errors are `thiserror` enums with stable kebab-case ids in `Display`/`kind()`
+- [ ] `cargo clippy --all-targets -- -D warnings` clean
+- [ ] `cargo test` green after a failing test was seen first
+- [ ] Mutation testing run on changed core logic (see `references/tests.md`)

package/skills/profile-rust/references/errors.md

@@ -0,0 +1,18 @@
+# Errors in Rust
+
+```rust
+#[derive(Debug, thiserror::Error)]
+pub enum ConfigError {
+    #[error("unknown key {key}")]
+    UnknownKey { key: String },
+    #[error("cannot read config")]
+    Io(#[from] std::io::Error),
+}
+```
+
+- One enum per module; variants carry the data a caller can act on.
+- Stable id for tests/logs: add `fn kind(&self) -> &'static str` returning kebab-case
+  (`"unknown-key"`); do not match on message text.
+- Libraries return `Result`; only a binary's `main` may use `anyhow` to print a report.
+- `?` for propagation; `map_err` to translate at a boundary, keeping the cause via `#[from]`/`#[source]`.
+- Panic only for broken invariants (Wlaschin exception: fail fast), with a comment.

package/skills/profile-rust/references/lints.md

@@ -0,0 +1,22 @@
+# Lints for Rust
+
+`Cargo.toml` (workspace):
+
+```toml
+[workspace.lints.rust]
+unsafe_code = "forbid"
+
+[workspace.lints.clippy]
+all = { level = "deny", priority = -1 }
+pedantic = { level = "deny", priority = -1 }
+unwrap_used = "deny"
+expect_used = "deny"
+panic = "deny"
+indexing_slicing = "deny"
+```
+
+- Run `cargo clippy --all-targets --all-features -- -D warnings` in CI and the pre-commit hook.
+- Prefer `#[expect(lint, reason = "...")]` over `#[allow]`: it fails when the lint stops firing.
+- Test modules may relax `unwrap_used`/`expect_used` with
+  `#![cfg_attr(test, allow(clippy::unwrap_used, reason = "tests assert by panicking"))]`.
+- `cargo fmt --check` in CI; no hand-formatting arguments.

package/skills/profile-rust/references/tests.md

@@ -0,0 +1,10 @@
+# Tests in Rust
+
+- Unit tests of pure rules: `#[cfg(test)] mod tests` beside the code, table style.
+- Behaviour/vertical-slice tests: `tests/*.rs` (integration), public API only.
+- Prefer `proptest` for parsers and state machines (invariants over examples).
+- `cargo test` is the RED/GREEN signal the extension watches; also `cargo nextest run`.
+- **Mutation testing (`cargo-mutants`)**: run on changed core logic before review
+  (`cargo mutants --in-diff <(git diff main)`). A surviving mutant means a missing
+  assertion: add the test, do not exclude the mutant. Excluding needs a reason comment.
+- Do not test private functions by making them `pub`; test through the interface.

package/skills/profile-rust/references/types.md

@@ -0,0 +1,22 @@
+# Semantic types in Rust
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GateId(String);
+
+impl GateId {
+    pub fn parse(input: &str) -> Result<Self, GateIdError> {
+        // validate once; the field is private so every GateId is valid
+        if is_valid(input) { Ok(Self(input.to_owned())) } else { Err(GateIdError::Malformed) }
+    }
+    pub fn as_str(&self) -> &str { &self.0 }
+}
+```
+
+- The `nutype` crate generates this (`#[nutype(sanitize(trim), validate(not_empty), derive(Debug, Clone, PartialEq))]`);
+  adding it is a dependency decision (ADR).
+- Model states as enums, data in the variant that owns it:
+  `enum Slice { Draft{..}, InProgress{ started: Instant }, Done{ at: Instant } }`.
+- Transitions are functions `fn advance(self, ev: Event) -> Result<Slice, TransitionError>`.
+- Use `#[non_exhaustive]` on public enums that will grow.
+- Parse at the boundary with `serde` into a raw DTO, then `TryFrom<Dto> for Domain`.

package/skills/profile-typescript/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: profile-typescript
+description: TypeScript idioms for this development system - branded types with parse functions, Result-style errors, strict tsconfig and biome, node:test layout, ESM. Use when working in a TypeScript or JavaScript repo (package.json, tsconfig.json, *.ts files) or reviewing such code.
+---
+
+# TypeScript profile
+
+Applies the universal skills (`tdd-canon`, `functional-core-imperative-shell`,
+`semantic-types`, `typed-errors`, `strict-lints`, `behaviour-tests`) with TypeScript idioms.
+Read the reference you need:
+
+- Branded types and parsing: `references/types.md`
+- Result pattern: `references/errors.md`
+- tsconfig and biome: `references/lints.md`
+- Test layout: `references/tests.md`
+
+## Defaults
+
+- **`strict` TypeScript, ESM, no `any`**, no `as` outside a boundary parse function
+  (commented as the boundary).
+- **Branded types** for ids, paths and statuses, each with a `parseX(input: unknown)`
+  returning `X | ParseError` (or `Result`).
+- **Discriminated unions** (`kind` field) for states and errors; exhaustive `switch`
+  with a `never` check.
+- **Result values, not exceptions**, for expected failure; throw only for bugs.
+- **Pure core in `src/core`**; I/O (fs, network, `process`) only in adapters and the
+  extension entry point.
+- **`readonly` by default**; no mutation of inputs.
+
+## Do not
+
+- Do not use `any`, non-null `!`, or `as Foo` to silence the compiler in core code.
+- Do not use `enum`; use string-literal unions.
+- Do not export mutable module state.
+- Do not add a runtime dependency without an ADR; prefer Node built-ins.
+
+## Checklist
+
+- [ ] `tsc --noEmit` clean under `strict` (plus `noUncheckedIndexedAccess`)
+- [ ] `biome check .` clean; every suppression has a reason
+- [ ] New ids/paths are branded with a parse function
+- [ ] Failures returned as values with a `kind`
+- [ ] Test written and seen failing before the source change

package/skills/profile-typescript/references/errors.md

@@ -0,0 +1,15 @@
+# Result pattern in TypeScript
+
+```ts
+export type Result<T, E> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly error: E };
+export const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
+export const err = <E>(error: E): Result<never, E> => ({ ok: false, error });
+```
+
+- `E` is a closed union of `{ kind: "kebab-case-id"; ...data }` variants.
+- Early return on failure: `if (!r.ok) return r;`.
+- Never `catch` and return `false`; convert to a typed error with the cause as data.
+- Throw only for the five Wlaschin exceptions, with a comment naming which.
+- Guards and hooks must never throw into their host: return a safe decision instead.

package/skills/profile-typescript/references/lints.md

@@ -0,0 +1,13 @@
+# Lints for TypeScript
+
+`tsconfig.json` compiler options: `"strict": true`, `"noUncheckedIndexedAccess": true`,
+`"exactOptionalPropertyTypes": true`, `"noImplicitOverride": true`,
+`"verbatimModuleSyntax": true`, `"noEmit": true`.
+
+`biome.json`: enable `recommended` rules, plus `suspicious/noExplicitAny`,
+`style/noNonNullAssertion`, `complexity/noExcessiveCognitiveComplexity` as errors.
+
+- Run `tsc --noEmit` and `biome check .` in CI and the pre-commit hook.
+- Suppressions: `// biome-ignore lint/<group>/<rule>: <reason of 15+ characters>`;
+  prefer `@ts-expect-error: <reason>` over `@ts-ignore`.
+- Do not widen `include`/`exclude` to hide failing files.

package/skills/profile-typescript/references/tests.md

@@ -0,0 +1,9 @@
+# Tests in TypeScript
+
+- Runner: `node --test "test/**/*.test.ts"` (Node strips types) or vitest if the repo already uses it.
+- Layout mirrors `src/`: `test/core/foo.test.ts` for `src/core/foo.ts`.
+- Pure core: table tests with `node:assert/strict`.
+- Shell/adapters: inject the outside world (an `exec` function, a clock, a UI) and assert effects.
+- Test names are sentences about behaviour.
+- `npm test` / `node --test` is the RED/GREEN signal the extension watches.
+- Do not `.skip`/`.only` and commit; the `tests.weaken` gate will ask for a departure.

package/skills/profile-typescript/references/types.md

@@ -0,0 +1,21 @@
+# Semantic types in TypeScript
+
+```ts
+export type GateId = string & { readonly __brand: "GateId" };
+const GATE_ID = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
+
+export type ParseError = { readonly kind: "parse-error"; readonly message: string };
+
+/** The one place the brand is asserted: after the regex has proven the shape. */
+export function parseGateId(input: string): GateId | ParseError {
+  return GATE_ID.test(input)
+    ? (input as GateId)
+    : { kind: "parse-error", message: `invalid gate id "${input}"` };
+}
+```
+
+- Parse `unknown` JSON with a hand-written parser (or a schema lib *if* an ADR adopted one);
+  never `JSON.parse(x) as Foo`.
+- Unions over optionals: `type Slice = { kind: "draft" } | { kind: "started"; at: string }`.
+- Exhaustiveness: `default: { const _: never = value; return _; }`.
+- Use `readonly` and `ReadonlyArray` in public types.

package/skills/semantic-types/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: semantic-types
+description: Parse, don't validate - turn raw input into types that prove their own validity, and make illegal states unrepresentable. Use when modelling a domain, accepting external input (JSON, CLI args, files, env), writing a state machine, or seeing a string/number standing in for an id, path or status.
+---
+
+# Semantic types
+
+The type is the proof. Validate once at the boundary and produce a value the compiler
+knows is valid; everything inside the boundary then needs no re-checking and cannot
+be handed something invalid.
+
+## Rules
+
+- **Parse at the edge.** One function per boundary takes `unknown` (or a raw string)
+  and returns either the typed value or a typed error. This is the only place a cast
+  (`as`) or `any` may appear, and it has a comment saying so.
+- **No primitive obsession.** A branded/newtype `GateId`, `SliceRef`, `RepoPath` beats
+  `string`. Two ids of different things must not be assignable to each other.
+- **Make illegal states unrepresentable.** If a field only makes sense in one state,
+  put it in that variant. "Has an email *or* a postal address" is a union, not two
+  optional fields and a runtime check.
+- **Explicit state machines.** States are a union of variants; transitions are
+  functions `(State, Event) -> State`. No boolean flag combinations.
+- **Constructors that can fail return a result** (`T | ParseError`, `Result<T, E>`),
+  never throw for expected bad input.
+
+## Do not
+
+- Do not validate the same invariant in three places. If you re-check it, the type
+  is not carrying the proof; strengthen the type.
+- Do not use optional fields to model "sometimes present". Use a union keyed by a
+  discriminant (`kind`).
+- Do not cast to silence the compiler inside the core. A cast there hides a missing
+  parse step.
+- Do not add a new `string` field for something with rules (an id, a path, a status).
+  Name the type first.
+
+## Checklist
+
+- [ ] Every external input passes through one parse function
+- [ ] Parse functions return typed errors; only they cast
+- [ ] Ids/paths/statuses are distinct types, not bare strings
+- [ ] Mutually exclusive data lives in a discriminated union
+- [ ] State transitions are total functions over a union

package/skills/strict-lints/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: strict-lints
+description: Strict linting with reasoned suppressions - lints are errors, and a suppression always says why. Use when a linter or type-checker complains, when tempted to add an ignore/allow/disable comment, or when configuring lint rules for a project.
+---
+
+# Strict lints
+
+Lints and type errors are failing checks, not suggestions. A suppression hides a
+finding from every later reader, so it must carry its reason.
+
+## Rules
+
+- **Fix the finding first.** Most lint complaints are right. Suppress only when the
+  rule is wrong *here*, and be able to say why in one line.
+- **Every suppression has a reason** of at least 15 characters on the same line or the
+  next: `// biome-ignore lint/suspicious/noExplicitAny: boundary parse of foreign JSON`,
+  `#[allow(clippy::too_many_arguments)] // mirrors the C ABI exactly`,
+  `#[allow(..., reason = "...")]`.
+- **Narrowest scope.** One line, never a whole file or crate, unless the whole file
+  is generated.
+- **Prefer `expect` over `allow`** where the language has it (`#[expect]`,
+  `@ts-expect-error`): it fails when the suppression stops being needed.
+- **Lints are configured strict from day one** (see the language profile): pedantic
+  clippy; biome recommended-plus; TypeScript `strict`. Loosening a project rule is a
+  recorded decision, not an edit.
+
+## What the extension does
+
+Editing a file so that it adds `#[allow(`, `#[expect(`, `// biome-ignore`,
+`// eslint-disable`, `@ts-ignore`, `@ts-expect-error` or `@ts-nocheck` without such
+a reason is blocked with gate `lints.suppression`. Add the reason, or record a
+departure naming why a bare one is right. Suppressions already in the file are not re-flagged.
+
+## Do not
+
+- Do not suppress to make CI green. That is weakening verification (non-negotiable 2).
+- Do not write a reason that restates the rule ("ignore the lint"). It must explain
+  why the code is correct despite the rule.
+- Do not disable a rule project-wide because three files trip it. Fix the three.
+
+## Checklist
+
+- [ ] Tried to fix the finding before suppressing
+- [ ] Suppression is one line with a reason of 15+ characters
+- [ ] `expect` used where available
+- [ ] No lint rule loosened in project config without a recorded decision

package/skills/tdd-canon/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: tdd-canon
+description: Test-driven development the way this system does it - a test list, one failing test at a time, minimal code to pass, structural changes kept apart from behavioural ones. Use before changing production behaviour, when deciding whether a change needs a RED test, or when tempted to write tests after the code.
+---
+
+# TDD (Canon)
+
+The extension watches for this: while a slice is `implementing`, editing production
+source after a green (or absent) test run asks for a `tdd.red-first` departure.
+This skill is how to work so that gate never fires.
+
+## The loop
+
+1. **Write a test list** for the behaviour (plain bullets, in a scratch file or the
+   task record). Add to it as you learn; never finish the list from memory.
+2. **Turn exactly one item into a runnable test.** Deciding the test is where you
+   design the interface: call the code the way a user of it would.
+3. **Run it and watch it fail (RED) for the right reason.** A test that fails on a
+   typo or missing import has proven nothing.
+4. **Write the least code that passes** this test and all earlier ones (GREEN).
+5. **Refactor** only while green, as its own *structural* step.
+6. Cross the item off. Repeat until the list is empty.
+
+## Do not
+
+- Do not write several tests, then the code. One failing test at a time keeps each
+  step small enough to be wrong cheaply.
+- Do not write the code first and "add tests after". The test then describes what
+  the code does, not what it should do, so it cannot catch the bug you just wrote.
+- Do not make a failing test pass by weakening it (skip, delete, loosen an expected
+  value, comment out). A green gate must mean the same thing afterwards; this is
+  non-negotiable 2 and the `tests.weaken` gate.
+- Do not mix structural and behavioural changes in one commit (Tidy First). Rename,
+  move, reformat: commit. Then change behaviour: commit. Reviewers cannot see a
+  behaviour change inside refactoring noise.
+- Do not add behaviour nobody asked for because "it will be needed". Unrequested
+  functionality is a warning sign of drift; scope is the steering wheel.
+
+## When RED is not required
+
+RED is for **adding or changing first-party production behaviour** when no existing
+failing test already proves the required change. These are exempt. Docs, config, test and generated files are
+exempt by path, so the gate never asks. For the rest, *name* the exemption in a
+recorded departure (scope `slice`; one departure covers the slice):
+
+- docs or metadata only
+- functionality removal (the proof is that nothing still depends on it)
+- documented third-party behaviour you are only wiring up
+- a test of committed-file text or structure (don't write such tests at all)
+- a change already shown by a failing test you have just seen
+- straightforward CI workflow scripting, where running CI is the test
+- a simple development-environment utility
+- a behaviour-preserving refactor with adequate green coverage
+
+"It is simple" is not an exemption. Simple changes are where untested regressions live.
+
+## Evidence the extension sees
+
+It records each test-runner command (`cargo test`, `npm test`, `node --test`,
+`vitest`, `pytest`, `go test`) with its exit code. After a *failing* run, source
+edits flow freely; after a *passing* run, the next source edit needs a failing test
+first. Run the new test before touching the source, and the evidence exists.
+
+## Checklist
+
+- [ ] Test list written, one item chosen
+- [ ] Test fails, and for the intended reason (read the failure)
+- [ ] Minimal code, test passes, earlier tests still pass
+- [ ] Refactor done separately, tests still green
+- [ ] Structural and behavioural changes in separate commits
+- [ ] If RED was skipped: the exemption is named in a recorded departure

package/skills/typed-errors/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: typed-errors
+description: Errors as values - expected failures are returned as typed results with stable kebab-case ids, not thrown; exceptions are for bugs. Use when writing a function that can fail, designing an error type, or choosing between returning a Result and throwing.
+---
+
+# Typed errors
+
+Failures the caller should handle are part of the function's type. They travel as
+values; they are never strings, never `null` standing for "something went wrong".
+
+## Rules
+
+- **Expected failure -> result.** `Result<T, E>` (or `T | ParseError`) where `E` is a
+  union of named variants with data the caller can act on.
+- **Stable ids.** Each variant has a kebab-case `kind` (`config-error`, `no-model`,
+  `timeout`) that tests and logs can match on. The human message is separate.
+- **One error type per module boundary**, a closed union. Wrapping a lower layer's
+  error keeps the cause as data.
+- **Compose with early returns** (`if (!r.ok) return r`), not nested callbacks.
+- **Never swallow.** Handle it, return it, or record why ignoring it is safe.
+
+## When to throw anyway (Wlaschin's five exceptions)
+
+Do not use `Result` when:
+
+1. you need **diagnostics** (a stack trace beats a "glorified boolean");
+2. you would be **reinventing exceptions** for truly exceptional conditions;
+3. you need to **fail fast** because continuing would corrupt state;
+4. **nobody will see** the error (it cannot be surfaced anywhere);
+5. **nobody cares** (best-effort cleanup).
+
+If you throw, name which of the five applies in a comment. If none applies, return a value.
+
+## Do not
+
+- Do not throw for expected bad input (a malformed file, a missing option). The caller
+  cannot see it in the type and will forget to handle it.
+- Do not catch and return a bare `false`/`undefined`; the reason is lost.
+- Do not use error message text as the contract. Match on `kind`.
+- Do not let a guard or hook crash its host: parse defensively and return a safe
+  decision (fail closed or ask) rather than throw.
+
+## Checklist
+
+- [ ] Each fallible function returns a result with a closed error union
+- [ ] Every error variant has a stable kebab-case `kind`
+- [ ] No expected failure is thrown; each `throw` names its exception
+- [ ] No error is swallowed without a stated reason

package/src/context/context-tail.ts

@@ -15,6 +15,7 @@ export function renderContextTail(state: DevsysState): string | undefined {
     "[development-system]",
     `phase: ${state.phase} · slice: ${state.activeSlice ?? "none"}`,
     `Jev: ${state.jev}`,
+    ...((state.profiles?.length ?? 0) > 0 ? [`profiles: ${state.profiles?.join(", ")}`] : []),
   ];
   const tailLines = [REMINDER];
   const room = MAX_LINES - head.length - tailLines.length - 1;

package/src/core/lint-suppression.ts

@@ -0,0 +1,131 @@
+/** Pure detector for lint/type-check suppressions that carry no written reason (gate `lints.suppression`). */
+
+export type Suppression = {
+  /** 1-based line in the text the suppression was found in. */
+  readonly line: number;
+  readonly marker: string;
+  readonly text: string;
+};
+
+/** A reason shorter than this says nothing a reader could use. */
+export const MIN_RATIONALE = 15;
+
+type Kind = {
+  readonly marker: string;
+  readonly pattern: RegExp;
+  /** The reason written on the marker's own line, if any. */
+  readonly inline: (line: string, after: string) => string | undefined;
+};
+
+const lastGroup = (re: RegExp, text: string): string | undefined => re.exec(text)?.[1];
+
+const KINDS: readonly Kind[] = [
+  {
+    marker: "#[allow(",
+    pattern: /#!?\[allow\(/,
+    inline: (line, after) =>
+      lastGroup(/reason\s*=\s*"([^"]*)"/, line) ??
+      lastGroup(/\)\]\s*\/\/\s*(.+)$/, after) ??
+      lastGroup(/\)\]\s*\/\*\s*(.+?)\s*\*\/\s*$/, after),
+  },
+  {
+    marker: "#![allow(",
+    pattern: /#!\[allow\(/,
+    inline: () => undefined,
+  },
+  {
+    marker: "#[expect(",
+    pattern: /#!?\[expect\(/,
+    inline: (line, after) =>
+      lastGroup(/reason\s*=\s*"([^"]*)"/, line) ?? lastGroup(/\)\]\s*\/\/\s*(.+)$/, after),
+  },
+  {
+    marker: "biome-ignore",
+    pattern: /\/\/\s*biome-ignore(?:-all|-start|-end)?\b/,
+    inline: (_line, after) => lastGroup(/:\s*(.+)$/, after),
+  },
+  {
+    marker: "eslint-disable",
+    pattern: /(?:\/\/|\/\*)\s*eslint-disable(?:-next-line|-line)?\b/,
+    inline: (_line, after) => lastGroup(/(?:\s--\s+|:\s+)(.+?)(?:\s*\*\/)?\s*$/, after),
+  },
+  {
+    marker: "@ts-ignore",
+    pattern: /@ts-ignore\b/,
+    inline: (_line, after) => lastGroup(/^\s*:?\s*(.+?)(?:\s*\*\/)?\s*$/, after),
+  },
+  {
+    marker: "@ts-expect-error",
+    pattern: /@ts-expect-error\b/,
+    inline: (_line, after) => lastGroup(/^\s*:?\s*(.+?)(?:\s*\*\/)?\s*$/, after),
+  },
+  {
+    marker: "@ts-nocheck",
+    pattern: /@ts-nocheck\b/,
+    inline: (_line, after) => lastGroup(/^\s*:?\s*(.+?)(?:\s*\*\/)?\s*$/, after),
+  },
+];
+
+const COMMENT_LINE = /^\s*(?:\/\/+|\/\*+|\*|#+)\s*(.*?)(?:\s*\*\/)?\s*$/;
+
+const isSuppressionLine = (line: string): boolean => KINDS.some((k) => k.pattern.test(line));
+
+/** Prose of a neighbouring comment line, unless that line is itself a suppression marker. */
+function neighbourReason(line: string | undefined): string | undefined {
+  if (line === undefined || isSuppressionLine(line)) return undefined;
+  return COMMENT_LINE.exec(line)?.[1];
+}
+
+const long = (reason: string | undefined): boolean =>
+  reason !== undefined && reason.trim().length >= MIN_RATIONALE;
+
+function kindOf(line: string): Kind | undefined {
+  // `#![allow(` also matches the `#[allow(` shape; the inner form is more specific and wins.
+  const matched = KINDS.filter((k) => k.pattern.test(line));
+  return matched.find((k) => k.marker === "#![allow(") ?? matched[0];
+}
+
+/** A rustfmt-wrapped `#[allow(\n  lint,\n  reason = "...",\n)]`: the reason sits on a later line. */
+function wrappedReason(lines: readonly string[], index: number): boolean {
+  const attr = lines.slice(index, index + 8);
+  const end = attr.findIndex((l) => l.includes(")]"));
+  const text = (end < 0 ? attr : attr.slice(0, end + 1)).join(" ");
+  return long(lastGroup(/reason\s*=\s*"([^"]*)"/, text));
+}
+
+function reasonOf(kind: Kind, lines: readonly string[], index: number): boolean {
+  const line = lines[index] ?? "";
+  if (/^\s*#!?\[(?:allow|expect)\(\s*$/.test(line) && wrappedReason(lines, index)) return true;
+  const match = kind.pattern.exec(line);
+  const after = match === null ? "" : line.slice(match.index + match[0].length);
+  return (
+    long(kind.inline(line, after)) ||
+    long(neighbourReason(lines[index + 1])) ||
+    long(neighbourReason(lines[index - 1]))
+  );
+}
+
+/** Every suppression in `text` whose reason is missing or under {@link MIN_RATIONALE} characters. */
+function unreasoned(text: string): Suppression[] {
+  const lines = text.split("\n");
+  return lines.flatMap((line, index): Suppression[] => {
+    const kind = kindOf(line);
+    if (kind === undefined || reasonOf(kind, lines, index)) return [];
+    return [{ line: index + 1, marker: kind.marker, text: line.trim() }];
+  });
+}
+
+/**
+ * Unreasoned suppressions that `after` adds relative to `before`: a suppression whose text already
+ * occurred (as often) in `before` is not new, so touching a file never re-flags old debt.
+ */
+export function findUnreasonedSuppressions(before: string, after: string): Suppression[] {
+  const known = new Map<string, number>();
+  for (const s of unreasoned(before)) known.set(s.text, (known.get(s.text) ?? 0) + 1);
+  return unreasoned(after).filter((s) => {
+    const left = known.get(s.text) ?? 0;
+    if (left === 0) return true;
+    known.set(s.text, left - 1);
+    return false;
+  });
+}

package/src/core/path-class.ts

@@ -0,0 +1,37 @@
+import { isTestPath, type TestPathProfile } from "./test-paths.ts";
+
+/** What kind of file a repo-relative path is, for gates that only care about production code. */
+export type PathClass = "source" | "test" | "docs" | "config" | "generated" | "other";
+
+const SOURCE_EXT =
+  /\.(?:[cm]?[jt]sx?|py|rb|rs|go|java|kt|kts|scala|cs|ex|exs|php|swift|c|cc|cpp|h|hpp|sh|lua|clj|hs|ml)$/;
+const DOCS_EXT = /\.(?:md|mdx|rst|txt|adoc)$/i;
+const DOCS_NAME = /^(?:LICENSE|LICENCE|CHANGELOG|NOTICE|AUTHORS|CONTRIBUTING)(?:\..*)?$/i;
+const CONFIG_EXT = /\.(?:json|jsonc|toml|ya?ml|ini|cfg|conf|env|properties)$/i;
+const CONFIG_NAME = /^(?:Dockerfile|Makefile|justfile|Rakefile|Gemfile|Procfile)$/i;
+// Build output directories only count at the repo root; `src/build/` is usually real source.
+const GENERATED_DIR =
+  /(?:^|\/)(?:node_modules|__generated__|\.next)\/|^(?:dist|target|build|coverage|vendor|generated)\//;
+const GENERATED_FILE =
+  /(?:\.generated\.|\.gen\.|\.min\.[cm]?js$|\.pb\.go$|\.snap$|(?:^|\/)(?:package-lock\.json|Cargo\.lock|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$|\.lock$)/;
+
+const basename = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
+
+/** Classifies a repo-relative path by convention; tests win over docs/config so test data stays guarded. */
+export function classifyPath(input: string, profile?: TestPathProfile): PathClass {
+  const path = input.replace(/^\.\//, "");
+  const name = basename(path);
+  if (GENERATED_DIR.test(path) || GENERATED_FILE.test(path)) return "generated";
+  if (isTestPath(path, profile) && SOURCE_EXT.test(path)) return "test";
+  if (DOCS_EXT.test(name) || DOCS_NAME.test(name) || /^docs\//.test(path)) return "docs";
+  if (
+    CONFIG_EXT.test(name) ||
+    CONFIG_NAME.test(name) ||
+    name.startsWith(".") ||
+    /^\.github\//.test(path)
+  ) {
+    return "config";
+  }
+  if (SOURCE_EXT.test(path)) return "source";
+  return isTestPath(path, profile) ? "test" : "other";
+}

package/src/core/profile.ts

@@ -0,0 +1,49 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { isParseError, type ParseError, type Profile, parseError } from "./types.ts";
+
+export type { Profile };
+
+export const PROFILES: readonly Profile[] = ["rust", "typescript"];
+
+const MARKERS: ReadonlyArray<{ profile: Profile; files: readonly string[] }> = [
+  { profile: "rust", files: ["Cargo.toml"] },
+  { profile: "typescript", files: ["package.json", "tsconfig.json"] },
+];
+
+export const isProfile = (value: string): value is Profile => PROFILES.some((p) => p === value);
+
+/** Boundary parse for configured profile names. */
+export function parseProfiles(names: readonly string[]): Profile[] | ParseError {
+  const out: Profile[] = [];
+  for (const name of names) {
+    if (!isProfile(name)) {
+      return parseError(`unknown profile "${name}": expected one of ${PROFILES.join(", ")}`);
+    }
+    out.push(name);
+  }
+  return out;
+}
+
+const exists = (path: string): Promise<boolean> =>
+  access(path).then(
+    () => true,
+    () => false,
+  );
+
+/** Profiles that apply to `repoRoot`; a non-empty `override` (valid names only) replaces detection. */
+export async function detectProfiles(
+  repoRoot: string,
+  override: readonly string[] = [],
+): Promise<Profile[]> {
+  if (override.length > 0) {
+    const parsed = parseProfiles(override);
+    if (!isParseError(parsed)) return parsed;
+  }
+  const found: Profile[] = [];
+  for (const { profile, files } of MARKERS) {
+    const hits = await Promise.all(files.map((f) => exists(join(repoRoot, f))));
+    if (hits.some(Boolean)) found.push(profile);
+  }
+  return found;
+}

package/src/core/test-runner.ts

@@ -0,0 +1,87 @@
+import { basename, isAssignment, segments, splitLines, WRAPPERS } from "./git-intent.ts";
+import { redactSecrets } from "./redact.ts";
+
+const PACKAGE_MANAGERS = new Set(["npm", "pnpm", "yarn", "bun"]);
+const DIRECT_RUNNERS = new Set(["vitest", "jest", "pytest", "mocha", "ava", "tap"]);
+const EXEC_PREFIX = new Set(["npx", "bunx", "pnpx"]);
+const SUMMARY_LINES = 3;
+const SUMMARY_MAX = 300;
+
+/** Words after wrappers (`time`, `timeout 60`, `env`), assignments and `+toolchain` selectors. */
+function commandWords(words: readonly string[]): string[] {
+  let i = 0;
+  while (i < words.length) {
+    const word = words[i] ?? "";
+    const wrapper = WRAPPERS.has(basename(word)) || basename(word) === "timeout";
+    if (isAssignment(word)) i += 1;
+    else if (wrapper) {
+      i += 1;
+      while (i < words.length && /^(?:-|\d+[smhd]?$)/.test(words[i] ?? "")) i += 1;
+    } else break;
+  }
+  return words.slice(i);
+}
+
+function isRunner(words: readonly string[]): boolean {
+  const [head, ...rest] = words.map((w, i) => (i === 0 ? basename(w) : w));
+  if (head === undefined) return false;
+  const args = rest.filter((w) => !w.startsWith("+"));
+  const first = args[0];
+  if (head === "cargo") return first === "test" || first === "nextest";
+  if (head === "go" || head === "deno") return first === "test";
+  if (head === "node") return rest.includes("--test");
+  if (head === "python" || head === "python3")
+    return first === "-m" && /^(?:pytest|unittest)$/.test(args[1] ?? "");
+  if (DIRECT_RUNNERS.has(head)) return true;
+  if (EXEC_PREFIX.has(head)) return DIRECT_RUNNERS.has(first ?? "");
+  if (PACKAGE_MANAGERS.has(head)) {
+    if (first === "test" || first === "t") return true;
+    return first === "run" && /^test(?::|$)/.test(args[1] ?? "");
+  }
+  return false;
+}
+
+/** Whether any simple command in `command` runs a test suite (`cargo test`, `npm test`, `vitest`, ...). */
+export function isTestRunnerCommand(command: string): boolean {
+  return splitLines(command).some((line) =>
+    segments(line).some((words) => isRunner(commandWords(words))),
+  );
+}
+
+export type ResultLike = {
+  readonly isError: boolean;
+  readonly text: string;
+  readonly structured?: unknown;
+  /** The command that ran; used to tell whether its exit status could have been masked. */
+  readonly command?: string;
+};
+
+/** A pipe or sequence makes the shell report the last command's status, not the runner's. */
+const MASKS_STATUS = /\||;/;
+const FAILURE_MARKERS =
+  /^# fail [1-9]|test result: FAILED|\b[1-9]\d* (?:failed|failing)\b|^FAILED\b|^FAIL\b|\bnot ok\b/m;
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** Exit code of a bash tool result: structured `exit_code`, else pi's status line, else error/not. */
+export function exitCodeOf(result: ResultLike): number {
+  if (isRecord(result.structured) && typeof result.structured.exit_code === "number") {
+    return result.structured.exit_code;
+  }
+  const line = /Command exited with code (\d+)\s*$/.exec(result.text);
+  if (line?.[1] !== undefined) return Number(line[1]);
+  if (result.isError) return 1;
+  // `npm test | tail` exits 0 whatever the tests did; trust the output over the masked status.
+  const masked = result.command !== undefined && MASKS_STATUS.test(result.command);
+  return masked && FAILURE_MARKERS.test(result.text) ? 1 : 0;
+}
+
+/** The last few non-empty output lines, redacted and bounded: what the runner said at the end. */
+export function summarizeOutput(output: string): string {
+  const lines = output
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l !== "" && !/^Command exited with code \d+$/.test(l));
+  return redactSecrets(lines.slice(-SUMMARY_LINES).join(" | ")).slice(0, SUMMARY_MAX);
+}

package/src/core/types.ts

@@ -62,6 +62,16 @@ export const CI_STATUSES: readonly CiStatusName[] = ["green", "red", "pending",
 /** Last observed CI state of the trunk (see `/devsys-ci`). */
 export type CiState = { readonly status: CiStatusName; readonly sha?: string };
 
+/** Language profile: universal principles plus the idioms of one language (decision D3). */
+export type Profile = "rust" | "typescript";
+
+/** Last observed test-runner invocation (see src/state/test-evidence.ts). */
+export type TestRun = {
+  readonly at: string;
+  readonly exitCode: number;
+  readonly summary: string;
+};
+
 export type DevsysState = {
   readonly phase: Phase;
   readonly sizing?: Sizing;
@@ -70,6 +80,8 @@ export type DevsysState = {
   readonly jev: JevStatus;
   readonly lastPushAt?: string;
   readonly ci?: CiState;
+  readonly profiles?: ReadonlyArray<Profile>;
+  readonly lastTestRun?: TestRun;
 };
 
 export const initialState = (): DevsysState => ({

package/src/gates/lint-suppression-guard.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  isToolCallEventType,
+  type ToolCallEvent,
+} from "@earendil-works/pi-coding-agent";
+import { findUnreasonedSuppressions, MIN_RATIONALE } from "../core/lint-suppression.ts";
+import { classifyPath } from "../core/path-class.ts";
+import { normalizeRepoPath } from "../core/test-paths.ts";
+import { applyEdits, normalizeText } from "../core/test-weakening.ts";
+import { type GateId, isParseError, parseGateId } from "../core/types.ts";
+import type { SessionState } from "../state/session-state.ts";
+import { departureUse } from "./departure-use.ts";
+
+export type LintSuppressionGuardDeps = { pi: ExtensionAPI; state: SessionState };
+
+const GATE_ID = "lints.suppression";
+
+const readIfExists = (file: string): string => {
+  try {
+    return normalizeText(readFileSync(file, "utf8"));
+  } catch {
+    return "";
+  }
+};
+
+/** Before/after text of the file an edit or write would produce; `undefined` for other tools. */
+function resultingText(
+  event: ToolCallEvent,
+  cwd: string,
+): { path: string; before: string; after: string } | undefined {
+  if (!isToolCallEventType("write", event) && !isToolCallEventType("edit", event)) return undefined;
+  const path = normalizeRepoPath(cwd, event.input.path, homedir());
+  const class_ = classifyPath(path);
+  if (class_ !== "source" && class_ !== "test") return undefined;
+  const before = readIfExists(join(cwd, path));
+  if (isToolCallEventType("write", event)) {
+    return { path, before, after: normalizeText(event.input.content) };
+  }
+  const applied = applyEdits(before, event.input.edits);
+  // When the edit text does not match, judge what the agent intends to write on its own.
+  return {
+    path,
+    before: applied === undefined ? "" : before,
+    after: applied ?? event.input.edits.map((e) => normalizeText(e.newText)).join("\n"),
+  };
+}
+
+/**
+ * Soft gate `lints.suppression`: a lint or type-check suppression needs a written reason
+ * (at least {@link MIN_RATIONALE} characters) or a recorded departure.
+ */
+export function registerLintSuppressionGuard(deps: LintSuppressionGuardDeps): void {
+  const parsed = parseGateId(GATE_ID);
+  if (isParseError(parsed)) return;
+  const gate: GateId = parsed;
+  const departure = departureUse(deps.state, gate);
+
+  deps.pi.on("tool_call", (event, ctx) => {
+    const change = resultingText(event, ctx.cwd);
+    if (change === undefined) return undefined;
+    const found = findUnreasonedSuppressions(change.before, change.after);
+    if (found.length === 0) return undefined;
+    if (departure.hasOpen()) {
+      departure.consume();
+      return undefined;
+    }
+    const list = found.map((s) => `${s.marker} (line ${s.line})`).join(", ");
+    return {
+      block: true,
+      reason:
+        `${GATE_ID}: ${change.path} adds a suppression without a reason: ${list}. A suppression hides a ` +
+        `finding from every later reader, so it must say why (at least ${MIN_RATIONALE} characters, on the ` +
+        `same line or the next, e.g. "// biome-ignore lint/x: boundary parse of foreign JSON"). Add the ` +
+        `reason, or fix the finding instead. If a bare suppression is truly right, call ` +
+        `devsys_record_departure with gate "${GATE_ID}", what you are doing, why, and the cost if wrong; then retry.`,
+    };
+  });
+}

package/src/gates/red-first-guard.ts

@@ -0,0 +1,63 @@
+import { homedir } from "node:os";
+import { type ExtensionAPI, isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import { classifyPath } from "../core/path-class.ts";
+import { normalizeRepoPath } from "../core/test-paths.ts";
+import { type GateId, isParseError, parseGateId } from "../core/types.ts";
+import type { SessionState } from "../state/session-state.ts";
+import { departureUse } from "./departure-use.ts";
+
+export type RedFirstGuardDeps = { pi: ExtensionAPI; state: SessionState };
+
+const GATE_ID = "tdd.red-first";
+
+/** Test code written inside a source file (Rust `#[cfg(test)]`/`#[test]`): that edit is the RED step itself. */
+const INLINE_TEST = /#\[(?:cfg\(test\)|test|tokio::test|rstest)\]/;
+
+const newText = (
+  input: { content: string } | { edits: ReadonlyArray<{ newText: string }> },
+): string => ("content" in input ? input.content : input.edits.map((e) => e.newText).join("\n"));
+
+/** Exemption classes a machine cannot see; the departure names which one applies (research 02). */
+const JUDGED_EXEMPTIONS =
+  "functionality removal, documented third-party behaviour, a change already shown by a failing test, " +
+  "straightforward CI scripting, a simple dev-environment utility, or a behaviour-preserving refactor with green coverage";
+
+/**
+ * Soft gate `tdd.red-first`: while implementing, production source is edited only after a failing
+ * test run has been observed. Test, docs, config and generated files are exempt by path; the
+ * judged exemptions go through one recorded departure, which covers its whole slice.
+ */
+export function registerRedFirstGuard(deps: RedFirstGuardDeps): void {
+  const parsed = parseGateId(GATE_ID);
+  if (isParseError(parsed)) return;
+  const gate: GateId = parsed;
+  const departure = departureUse(deps.state, gate);
+
+  deps.pi.on("tool_call", (event, ctx) => {
+    if (!isToolCallEventType("edit", event) && !isToolCallEventType("write", event))
+      return undefined;
+    const { phase, lastTestRun, activeSlice } = deps.state.get();
+    if (phase !== "implementing") return undefined;
+    if (lastTestRun !== undefined && lastTestRun.exitCode !== 0) return undefined;
+    const path = normalizeRepoPath(ctx.cwd, event.input.path, homedir());
+    if (classifyPath(path) !== "source") return undefined;
+    if (INLINE_TEST.test(newText(event.input))) return undefined;
+    if (departure.hasOpen()) {
+      departure.consume();
+      return undefined;
+    }
+    const seen =
+      lastTestRun === undefined
+        ? "no test run has been observed in this session"
+        : `the last test run passed (${lastTestRun.summary || "exit 0"})`;
+    const scope = activeSlice === undefined ? "session" : "slice";
+    return {
+      block: true,
+      reason:
+        `${GATE_ID}: ${path} is production source and ${seen}. Write the next failing test first, run it, ` +
+        `and watch it fail (RED); then change the source. If this change needs no new failing test (${JUDGED_EXEMPTIONS}), ` +
+        `call devsys_record_departure with gate "${GATE_ID}", scope "${scope}", naming the exemption in "why"; one ` +
+        `departure covers the rest of the ${scope}.`,
+    };
+  });
+}

package/src/state/session-state.ts

@@ -11,9 +11,11 @@ import {
   type JevStatus,
   type ParseError,
   type Phase,
+  type Profile,
   parseError,
   type Sizing,
   type SliceRef,
+  type TestRun,
 } from "../core/types.ts";
 
 export const STATE_ENTRY_TYPE = "devsys-state";
@@ -26,6 +28,7 @@ const PHASES: ReadonlyArray<Phase> = [
   "delivering",
   "idle",
 ];
+const PROFILE_NAMES: ReadonlyArray<Profile> = ["rust", "typescript"];
 const SIZINGS: ReadonlyArray<Sizing> = ["fix", "change", "capability", "product"];
 const JEV: ReadonlyArray<JevStatus> = ["online", "offline", "unknown"];
 
@@ -42,10 +45,31 @@ function parseCi(input: unknown): CiState | ParseError {
   return { status: status as CiStatusName, ...(sha !== undefined ? { sha } : {}) };
 }
 
+function parseProfileList(input: unknown): Profile[] | ParseError {
+  if (!Array.isArray(input)) return parseError("profiles must be an array");
+  const out: Profile[] = [];
+  for (const name of input) {
+    if (!PROFILE_NAMES.includes(name as Profile))
+      return parseError(`unknown profile: ${String(name)}`);
+    out.push(name as Profile);
+  }
+  return out;
+}
+
+function parseTestRun(input: unknown): TestRun | ParseError {
+  if (!isRecord(input)) return parseError("lastTestRun must be an object");
+  const { at, exitCode, summary } = input;
+  if (typeof at !== "string" || typeof exitCode !== "number" || typeof summary !== "string") {
+    return parseError("lastTestRun needs string at, number exitCode and string summary");
+  }
+  return { at, exitCode, summary };
+}
+
 /** Boundary parse for persisted state: the only place state is cast from `unknown`. */
 export function parseDevsysState(input: unknown): DevsysState | ParseError {
   if (!isRecord(input)) return parseError("devsys state must be an object");
-  const { phase, sizing, activeSlice, openDepartures, jev, lastPushAt, ci } = input;
+  const { phase, sizing, activeSlice, openDepartures, jev, lastPushAt, ci, profiles, lastTestRun } =
+    input;
   if (!PHASES.includes(phase as Phase)) return parseError(`unknown phase: ${String(phase)}`);
   if (!JEV.includes(jev as JevStatus)) return parseError(`unknown jev status: ${String(jev)}`);
   if (!Array.isArray(openDepartures)) return parseError("openDepartures must be an array");
@@ -66,6 +90,10 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
   }
   const parsedCi = ci === undefined ? undefined : parseCi(ci);
   if (isParseError(parsedCi)) return parsedCi;
+  const parsedProfiles = profiles === undefined ? undefined : parseProfileList(profiles);
+  if (isParseError(parsedProfiles)) return parsedProfiles;
+  const parsedRun = lastTestRun === undefined ? undefined : parseTestRun(lastTestRun);
+  if (isParseError(parsedRun)) return parsedRun;
   return {
     phase: phase as Phase,
     jev: jev as JevStatus,
@@ -74,6 +102,8 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
     ...(activeSlice !== undefined ? { activeSlice: activeSlice as SliceRef } : {}),
     ...(lastPushAt !== undefined ? { lastPushAt } : {}),
     ...(parsedCi !== undefined ? { ci: parsedCi } : {}),
+    ...(parsedProfiles !== undefined ? { profiles: parsedProfiles } : {}),
+    ...(parsedRun !== undefined ? { lastTestRun: parsedRun } : {}),
   };
 }
 

package/src/state/test-evidence.ts

@@ -0,0 +1,29 @@
+import { type ExtensionAPI, isBashToolResult } from "@earendil-works/pi-coding-agent";
+import { exitCodeOf, isTestRunnerCommand, summarizeOutput } from "../core/test-runner.ts";
+import type { SessionState } from "./session-state.ts";
+
+export type TestEvidenceDeps = { pi: ExtensionAPI; state: SessionState; now?: () => Date };
+
+/**
+ * Records the outcome of every test-runner command in `lastTestRun`, so gates can ask "has this
+ * session seen a failing test?" without trusting the model's say-so.
+ */
+export function registerTestEvidence(deps: TestEvidenceDeps): void {
+  const now = deps.now ?? (() => new Date());
+  deps.pi.on("tool_result", (event) => {
+    if (!isBashToolResult(event)) return;
+    const { command } = event.input;
+    if (typeof command !== "string" || !isTestRunnerCommand(command)) return;
+    const text = event.content.flatMap((c) => (c.type === "text" ? [c.text] : [])).join("\n");
+    const exitCode = exitCodeOf({
+      isError: event.isError,
+      text,
+      structured: event.structuredContent,
+      command,
+    });
+    deps.state.update((s) => ({
+      ...s,
+      lastTestRun: { at: now().toISOString(), exitCode, summary: summarizeOutput(text) },
+    }));
+  });
+}