@jwilger/pi-development-system 0.7.0 → 0.8.1

package/extensions/development-system.ts

@@ -11,6 +11,7 @@ import { createRecordDepartureTool } from "../src/gates/record-departure-tool.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 { createModelsTool, registerModelsCommand } from "../src/state/models-command.ts";
 import { createSessionState } from "../src/state/session-state.ts";
 
@@ -66,6 +67,11 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     jev: (ctx) => jevHolder.forContext(ctx),
     exec: (command, args, options) => pi.exec(command, args, options),
   });
+  registerCiCommand({
+    pi,
+    state,
+    exec: (command, args, options) => pi.exec(command, args, options),
+  });
   registerPushGuard({
     pi,
     state,

package/package.json

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

package/skills/delivery-discipline/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: delivery-discipline
+description: How to commit, push and release in this development system - trunk-based delivery, Conventional Commit messages that carry their rationale, handling a red build, and when worktrees are warranted. Use before committing, pushing, opening a pull request, or when CI is red.
+---
+
+# Delivery discipline
+
+Delivery mode comes from `.development-system.toml` (`[delivery] mode`):
+`trunk` (default), `pull-request`, or `local-only`. The repository's own policy
+wins over any habit. The extension enforces the hard parts; this skill is how
+to work with them.
+
+## Commit messages
+
+Shape: `type(scope): subject` then a body that says **why**.
+
+```text
+fix(auth): reject expired refresh tokens
+
+Expired tokens were accepted for up to a minute because the clock check used
+the issue time. Sessions outliving their grant is a security defect, so the
+check now uses expiry; clock-skew tolerance is deliberately not added.
+```
+
+- Do not write a body that only restates the diff. The diff already says what;
+  the body is the only place the reason survives.
+- Do not add `Co-Authored-By`, "Generated with" or any AI trailer. This is
+  never a departure; the guard blocks it outright.
+- Do not mix structural changes (rename, move, reformat) with behavioural ones
+  in one commit. Reviewers cannot see the behaviour change inside the noise.
+  Tidy first, commit, then change behaviour.
+- A body-less commit is allowed only through a recorded departure
+  (`devsys_record_departure`, gate `commit.rationale`); say why in it.
+
+## Trunk flow
+
+1. Small increment, tests green locally, commit with rationale.
+2. Push to trunk, then watch CI (`/devsys-ci`). A push is not done until CI is green.
+3. If an hour passes without a pushed commit, stop and ask whether the
+   increment is too big; split it.
+
+Do not start unrelated work while trunk CI is red. Fix it first; a red build
+hides every later failure. A push to a red trunk is a hard stop unless the
+commit is `fix(ci): ...` and its diff only repairs the failing build. If `gh`
+is missing or unauthenticated, CI reads as unknown and the push is allowed:
+check CI by other means before relying on it.
+
+## Pull-request mode
+
+Never push to the trunk directly (hard stop, gate `push.delivery-mode`). Push a
+branch, open the PR, and wait for its checks.
+
+## Local-only
+
+Pushes are blocked. Commit locally, tell the user what is unpublished.
+
+## Worktrees
+
+Use `.worktrees/<name>` only when two pieces of work genuinely run in
+parallel. One increment at a time needs none; they add cleanup and confusion.
+
+## Never
+
+- `--no-verify`, `git push --force`, rewriting published history, deleting
+  remote branches: hard stops needing the user's explicit approval each time.
+- Weakening or deleting tests to get green (gate `tests.weaken`).
+- Claiming CI passed without having looked at it.
+
+## Checklist
+
+Copy and tick:
+
+```text
+- [ ] Commit is one kind of change (structural or behavioural)
+- [ ] Subject is Conventional; body explains why
+- [ ] No AI trailer
+- [ ] Local gates green (see references/lefthook.yml for the template)
+- [ ] Pushed per delivery mode; CI watched to green
+```

package/skills/delivery-discipline/references/lefthook.yml

@@ -0,0 +1,18 @@
+---
+# Template: local gates that mirror CI so a red build is found before the push.
+# Adapt the commands to the repository's toolchain.
+# Keep CI re-running every gate.
+commit-msg:
+  commands:
+    conventional:
+      run: your-commit-message-check {1}
+
+pre-commit:
+  parallel: true
+  commands:
+    typecheck:
+      run: npx tsc --noEmit
+    lint:
+      run: biome check .
+    test:
+      run: npm test

package/src/context/status.ts

@@ -5,8 +5,17 @@ export const STATUS_KEY = "devsys";
 const jevLabel = (state: DevsysState, model: string | undefined): string =>
   state.jev === "online" && model !== undefined ? `online (${model})` : state.jev;
 
+const ciLabel = (state: DevsysState): string | undefined => {
+  const { ci } = state;
+  if (ci === undefined || ci.status === "unknown") return undefined;
+  const sha = ci.sha === undefined ? "" : ` (${ci.sha.slice(0, 7)})`;
+  return `ci ${ci.status}${sha}`;
+};
+
 export const renderStatusLine = (state: DevsysState, jevModel?: string): string =>
-  `devsys: ${state.phase} · jev ${jevLabel(state, jevModel)}`;
+  [`devsys: ${state.phase}`, `jev ${jevLabel(state, jevModel)}`, ciLabel(state)]
+    .filter((part) => part !== undefined)
+    .join(" · ");
 
 export const renderStatus = (state: DevsysState, jevModel?: string): string =>
   [
@@ -16,4 +25,5 @@ export const renderStatus = (state: DevsysState, jevModel?: string): string =>
     `- active slice: ${state.activeSlice ?? "none"}`,
     `- open departures: ${state.openDepartures.length}`,
     `- jev: ${jevLabel(state, jevModel)}`,
+    `- ci: ${ciLabel(state)?.slice(3) ?? "unknown"}`,
   ].join("\n");

package/src/core/commit-command.ts

@@ -1,15 +1,13 @@
-import { splitLines } from "./git-intent.ts";
-import { parseShell } from "./shell-parse.ts";
+import { resolveGit } from "./git-invocations.ts";
 
 export type CommitExtraction =
   | { readonly kind: "not-commit" }
   | { readonly kind: "message"; readonly message: string }
   | { readonly kind: "file"; readonly path: string }
-  | { readonly kind: "unknown" };
+  | { readonly kind: "unknown"; readonly trailers: readonly string[] };
 
 const HEREDOC =
   /<<-?[ \t]*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[^\n]*\n([\s\S]*?)\n[ \t]*\2[ \t]*(?:\n|$)/g;
-const GLOBAL_WITH_VALUE = new Set(["-c", "-C", "--git-dir", "--work-tree", "--namespace"]);
 
 /** Heredoc bodies are data: take them out so their quotes cannot confuse line splitting. */
 function stripHeredocs(command: string): { rest: string; bodies: string[] } {
@@ -21,34 +19,6 @@ function stripHeredocs(command: string): { rest: string; bodies: string[] } {
   return { rest, bodies };
 }
 
-function segmentsOf(line: string): string[][] {
-  const out: string[][] = [[]];
-  for (const t of parseShell(line, (name) => `$${name}`)) {
-    if (typeof t === "string") out.at(-1)?.push(t);
-    else if ("op" in t && /^[<>]/.test(t.op)) continue;
-    else if (!("comment" in t)) out.push([]);
-  }
-  return out.filter((s) => s.length > 0);
-}
-
-const WRAPPERS = new Set(["command", "sudo", "env", "time", "nohup", "exec", "builtin", "nice"]);
-const isAssignment = (w: string): boolean => /^[A-Za-z_][A-Za-z0-9_]*=/.test(w);
-const isGit = (w: string): boolean => w === "git" || w.endsWith("/git");
-
-/** Index of the word after `git [global options]`, when this segment's command is git. */
-function subcommandIndex(segment: readonly string[]): number | undefined {
-  const start = segment.findIndex((w) => !isAssignment(w) && !WRAPPERS.has(w));
-  if (start === -1 || !isGit(segment[start] ?? "")) return undefined;
-  let skipNext = false;
-  for (let i = start + 1; i < segment.length; i++) {
-    const w = segment[i] ?? "";
-    if (skipNext) skipNext = false;
-    else if (GLOBAL_WITH_VALUE.has(w)) skipNext = true;
-    else if (!w.startsWith("-")) return i;
-  }
-  return undefined;
-}
-
 type Options = {
   messages: string[];
   trailers: string[];
@@ -56,59 +26,73 @@ type Options = {
   opaque: boolean;
 };
 
+type Parsed = {
+  readonly kind: "message" | "file" | "trailer";
+  readonly value: string | undefined;
+  /** Index of the next argument to read. */
+  readonly next: number;
+};
+
+const LONG: ReadonlyArray<readonly [string, Parsed["kind"]]> = [
+  ["--message", "message"],
+  ["--file", "file"],
+  ["--trailer", "trailer"],
+];
+
+/** Reads the message/file/trailer option starting at args[i], in any of its spellings. */
+function parseArg(args: readonly string[], i: number): Parsed | undefined {
+  const a = args[i] ?? "";
+  for (const [name, kind] of LONG) {
+    if (a === name) return { kind, value: args[i + 1], next: i + 2 };
+    if (a.startsWith(`${name}=`)) return { kind, value: a.slice(name.length + 1), next: i + 1 };
+  }
+  if (a === "-F") return { kind: "file", value: args[i + 1], next: i + 2 };
+  if (/^-F./.test(a)) return { kind: "file", value: a.slice(2), next: i + 1 };
+  if (/^-[A-Za-z]*m$/.test(a)) return { kind: "message", value: args[i + 1], next: i + 2 };
+  if (/^-[A-Za-z]*m./.test(a)) {
+    return { kind: "message", value: a.slice(a.indexOf("m") + 1), next: i + 1 };
+  }
+  return undefined;
+}
+
 function readOptions(args: readonly string[]): Options {
   const options: Options = { messages: [], trailers: [], file: undefined, opaque: false };
-  const take = (value: string | undefined) => {
-    if (value === undefined || /\$\(|`/.test(value)) options.opaque = true;
-    else options.messages.push(value);
-  };
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i] ?? "";
-    if (a === "-m" || a === "--message") take(args[++i]);
-    else if (a.startsWith("--message=")) take(a.slice("--message=".length));
-    else if (a === "-F" || a === "--file") options.file = args[++i];
-    else if (a.startsWith("--file=")) options.file = a.slice("--file=".length);
-    else if (a === "--trailer") options.trailers.push(args[++i] ?? "");
-    else if (a.startsWith("--trailer=")) options.trailers.push(a.slice("--trailer=".length));
-    else if (/^-[A-Za-z]*m$/.test(a)) take(args[++i]);
-    else if (/^-[A-Za-z]*m./.test(a)) take(a.slice(a.indexOf("m") + 1));
+  let i = 0;
+  while (i < args.length) {
+    const parsed = parseArg(args, i);
+    i = parsed?.next ?? i + 1;
+    if (parsed === undefined) continue;
+    if (parsed.kind === "file") options.file = parsed.value;
+    else if (parsed.kind === "trailer") options.trailers.push(parsed.value ?? "");
+    else if (parsed.value === undefined || /\$\(|`/.test(parsed.value)) options.opaque = true;
+    else options.messages.push(parsed.value);
   }
   return options;
 }
 
+const unknown = (trailers: readonly string[] = []): CommitExtraction => ({
+  kind: "unknown",
+  trailers,
+});
+
 /** The commit message a `git commit` shell command will use, or why it cannot be known. */
 export function extractCommit(command: string): CommitExtraction {
   const { rest, bodies } = stripHeredocs(command);
   const heredoc = bodies[0]?.trim();
-  for (const line of splitLines(rest)) {
-    for (const segment of segmentsOf(line)) {
-      const at = subcommandIndex(segment);
-      if (at === undefined || segment[at] !== "commit") continue;
-      const options = readOptions(segment.slice(at + 1));
-      if (options.file === "-" && heredoc !== undefined)
-        return { kind: "message", message: heredoc };
-      if (options.file !== undefined) return { kind: "file", path: options.file };
-      if (options.opaque) {
-        return heredoc === undefined ? { kind: "unknown" } : { kind: "message", message: heredoc };
-      }
-      if (options.messages.length === 0) return { kind: "unknown" };
-      const trailers = options.trailers.length === 0 ? "" : `\n\n${options.trailers.join("\n")}`;
-      return { kind: "message", message: `${options.messages.join("\n\n")}${trailers}` };
-    }
+  const resolution = resolveGit(rest);
+  const commit = resolution.invocations.find((g) => g.sub === "commit");
+  if (commit === undefined) {
+    return resolution.opaque && /\bcommit\b/.test(command) ? unknown() : { kind: "not-commit" };
   }
-  return { kind: "not-commit" };
-}
-
-export type GitInvocation = { readonly sub: string; readonly args: readonly string[] };
-
-/** Every `git <sub> <args…>` simple command in a shell command string (heredoc bodies excluded). */
-export function gitInvocations(command: string): GitInvocation[] {
-  const { rest } = stripHeredocs(command);
-  return splitLines(rest).flatMap((line) =>
-    segmentsOf(line).flatMap((segment): GitInvocation[] => {
-      const at = subcommandIndex(segment);
-      const sub = at === undefined ? undefined : segment[at];
-      return at === undefined || sub === undefined ? [] : [{ sub, args: segment.slice(at + 1) }];
-    }),
-  );
+  const options = readOptions(commit.args);
+  if (options.file === "-" && heredoc !== undefined) return { kind: "message", message: heredoc };
+  if (options.file !== undefined) return { kind: "file", path: options.file };
+  if (options.opaque) {
+    return heredoc === undefined
+      ? unknown(options.trailers)
+      : { kind: "message", message: heredoc };
+  }
+  if (options.messages.length === 0) return unknown(options.trailers);
+  const trailers = options.trailers.length === 0 ? "" : `\n\n${options.trailers.join("\n")}`;
+  return { kind: "message", message: `${options.messages.join("\n\n")}${trailers}` };
 }

package/src/core/commit-message.ts

@@ -86,7 +86,7 @@ export function findForbiddenTrailers(
     .split("\n")
     .filter((line) => {
       const trimmed = line.trim();
-      const key = /^([A-Za-z][A-Za-z-]*):/.exec(trimmed)?.[1]?.toLowerCase();
+      const key = /^([A-Za-z][A-Za-z-]*)\s*[:=]/.exec(trimmed)?.[1]?.toLowerCase();
       if (key !== undefined && keys.includes(key)) return true;
       if (key === "signed-off-by") return AI_NAMES.test(trimmed);
       return GENERATED_BANNER.test(trimmed) && AI_NAMES.test(trimmed);

package/src/core/gates.ts

@@ -18,7 +18,7 @@ export const GATES: Readonly<Record<string, GateInfo>> = {
     tier: "soft",
     default: "structural and behavioural changes go in separate commits",
   },
-  "commit.forbidden-trailer": { tier: "soft", default: "no Co-Authored-By or AI trailers" },
+  "commit.forbidden-trailer": { tier: "hard", default: "no Co-Authored-By or AI trailers" },
   "push.red-trunk": { tier: "hard", default: "do not push unrelated work onto a red trunk" },
   "push.delivery-mode": { tier: "hard", default: "follow the repository's delivery mode" },
   "tdd.red-first": { tier: "soft", default: "write a failing test before changing behaviour" },

package/src/core/git-intent.ts

@@ -59,7 +59,7 @@ export function splitLines(command: string): string[] {
 const isRedirect = (op: string): boolean => /^[<>]/.test(op) && !op.endsWith("(");
 
 /** Tokens of one line grouped into simple commands (operators separate segments). */
-function segments(line: string): string[][] {
+export function segments(line: string): string[][] {
   const result: string[][] = [[]];
   for (const token of parseShell(line, (name) => `$${name}`)) {
     if (typeof token === "string") result[result.length - 1]?.push(token);
@@ -70,9 +70,29 @@ function segments(line: string): string[][] {
   return result.filter((s) => s.length > 0);
 }
 
-const WRAPPERS = new Set(["command", "sudo", "env", "time", "nohup", "exec", "builtin", "nice"]);
-const KEYWORDS = new Set(["then", "do", "else", "elif", "if", "while", "until", "{", "!", "time"]);
-const DATA_ONLY = new Set([
+export const WRAPPERS = new Set([
+  "command",
+  "sudo",
+  "env",
+  "time",
+  "nohup",
+  "exec",
+  "builtin",
+  "nice",
+]);
+export const KEYWORDS = new Set([
+  "then",
+  "do",
+  "else",
+  "elif",
+  "if",
+  "while",
+  "until",
+  "{",
+  "!",
+  "time",
+]);
+export const DATA_ONLY = new Set([
   "echo",
   "printf",
   "cat",
@@ -84,13 +104,13 @@ const DATA_ONLY = new Set([
   "head",
   "tail",
 ]);
-const SHELLS = new Set(["bash", "sh", "zsh", "dash", "ksh"]);
-const OPAQUE = new Set(["xargs", "ssh", "find", "parallel", "watch"]);
-const GLOBAL_WITH_VALUE = new Set(["-c", "-C", "--git-dir", "--work-tree", "--namespace"]);
+export const SHELLS = new Set(["bash", "sh", "zsh", "dash", "ksh"]);
+export const OPAQUE = new Set(["xargs", "ssh", "find", "parallel", "watch"]);
+export const GLOBAL_WITH_VALUE = new Set(["-c", "-C", "--git-dir", "--work-tree", "--namespace"]);
 const HOOK_SKIP_ENV = new Set(["LEFTHOOK=0", "HUSKY=0"]);
 
-const basename = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
-const isAssignment = (t: string): boolean => /^[A-Za-z_][A-Za-z0-9_]*=/.test(t);
+export const basename = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
+export const isAssignment = (t: string): boolean => /^[A-Za-z_][A-Za-z0-9_]*=/.test(t);
 
 /** True when `arg` is `name` or an unambiguous-looking git abbreviation of it (`--amen`, `--del=x`). */
 const isLong = (arg: string, ...names: string[]): boolean => {
@@ -200,7 +220,7 @@ function classifySegment(tokens: string[]): GitIntent {
  * The parts of a line bash may still execute or treat as syntax: single-quoted text and
  * backslash-escaped characters are dropped; double-quoted text is kept unless `dropDouble`.
  */
-function live(line: string, dropDouble: boolean): string {
+export function live(line: string, dropDouble: boolean): string {
   let out = "";
   let quote: "'" | '"' | undefined;
   for (let i = 0; i < line.length; i++) {
@@ -222,7 +242,7 @@ function live(line: string, dropDouble: boolean): string {
 }
 
 /** Bodies of `$(...)` and backtick substitutions anywhere in the text (quoted or not). */
-function substitutions(text: string): string[] {
+export function substitutions(text: string): string[] {
   const bodies: string[] = [];
   for (let at = text.indexOf("$("); at >= 0; at = text.indexOf("$(", at + 2)) {
     let depth = 1;
@@ -241,7 +261,7 @@ function substitutions(text: string): string[] {
 const HEREDOC = /^<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/;
 
 /** The delimiter of a heredoc started by an unquoted `<<` on this line, if any. */
-function heredocDelimiter(line: string): string | undefined {
+export function heredocDelimiter(line: string): string | undefined {
   let quote: "'" | '"' | undefined;
   for (let i = 0; i < line.length; i++) {
     const ch = line.charAt(i);

package/src/core/git-invocations.ts

@@ -0,0 +1,95 @@
+import {
+  basename,
+  DATA_ONLY,
+  GLOBAL_WITH_VALUE,
+  heredocDelimiter,
+  isAssignment,
+  KEYWORDS,
+  live,
+  OPAQUE,
+  SHELLS,
+  segments,
+  splitLines,
+  substitutions,
+  WRAPPERS,
+} from "./git-intent.ts";
+
+export type GitInvocation = { readonly sub: string; readonly args: readonly string[] };
+
+export type GitResolution = {
+  readonly invocations: readonly GitInvocation[];
+  /** True when git may run through something the parser cannot see into (xargs, `$CMD`, …). */
+  readonly opaque: boolean;
+};
+
+type Collector = { invocations: GitInvocation[]; opaque: boolean };
+
+const firstCommand = (tokens: readonly string[]): number => {
+  const at = tokens.findIndex((t) => !(isAssignment(t) || WRAPPERS.has(t) || KEYWORDS.has(t)));
+  return at < 0 ? tokens.length : at;
+};
+
+const gitIndex = (tokens: readonly string[]): number =>
+  tokens.findIndex((t) => basename(t) === "git");
+
+/** `git [global options] <sub> <args…>` (tokens start at the word after `git`). */
+function visitGit(rest: readonly string[], into: Collector): void {
+  let j = 0;
+  while (j < rest.length && (rest[j] ?? "").startsWith("-")) {
+    j += GLOBAL_WITH_VALUE.has(rest[j] ?? "") ? 2 : 1;
+  }
+  const sub = rest[j];
+  if (sub === undefined) return;
+  if (sub.startsWith("$")) into.opaque = true;
+  else into.invocations.push({ sub, args: rest.slice(j + 1) });
+}
+
+/** A shell or `eval`: its script is more command text to resolve. */
+function visitScript(base: string, rest: readonly string[], into: Collector): void {
+  if (base === "eval") {
+    merge(into, resolveGit(rest.join(" ")));
+    return;
+  }
+  const c = rest.findIndex((t) => /^-[A-Za-z]*c[A-Za-z]*$/.test(t));
+  const script = c >= 0 ? rest[c + 1] : undefined;
+  if (script !== undefined) merge(into, resolveGit(script));
+}
+
+function visitSegment(tokens: readonly string[], into: Collector): void {
+  const head = tokens[firstCommand(tokens)];
+  if (head === undefined) return;
+  const rest = tokens.slice(firstCommand(tokens) + 1);
+  const base = basename(head);
+  if (head.startsWith("$")) into.opaque = true;
+  else if (SHELLS.has(base) || base === "eval") visitScript(base, rest, into);
+  else if (OPAQUE.has(base)) into.opaque = into.opaque || gitIndex(rest) >= 0;
+  else if (base === "git") visitGit(rest, into);
+  else if (!DATA_ONLY.has(base) && gitIndex(rest) >= 0) {
+    // Wrapper with options (`sudo -E git …`, `timeout 5 git …`): resolve from the git token.
+    visitSegment(rest.slice(gitIndex(rest)), into);
+  }
+}
+
+function merge(into: Collector, other: GitResolution): void {
+  into.invocations.push(...other.invocations);
+  if (other.opaque) into.opaque = true;
+}
+
+/**
+ * Every `git <sub> <args…>` the shell command may run: simple commands, wrapped ones (`env`,
+ * `timeout`, `if … then`), `bash -c`/`eval` scripts and `$(…)` substitutions. Heredoc bodies are data.
+ */
+export function resolveGit(command: string): GitResolution {
+  const into: Collector = { invocations: [], opaque: false };
+  let heredocEnd: string | undefined;
+  for (const line of splitLines(command)) {
+    if (heredocEnd !== undefined) {
+      if (line.trim() === heredocEnd) heredocEnd = undefined;
+      continue;
+    }
+    for (const segment of segments(line)) visitSegment(segment, into);
+    for (const body of substitutions(live(line, false))) merge(into, resolveGit(body));
+    heredocEnd = heredocDelimiter(line) ?? heredocEnd;
+  }
+  return into;
+}

package/src/core/models.ts

@@ -40,7 +40,10 @@ const MIN_DATE_DIGITS = 6;
 function versionKey(id: string): VersionKey {
   const numbers: number[] = [];
   let date: number | undefined;
-  for (const run of id.match(/\d+/g) ?? []) {
+  // Hyphenated ISO snapshot dates (`-2024-08-06`) collapse to one date, like compact YYYYMMDD.
+  const iso = /-(\d{4})-(\d{2})-(\d{2})(?!\d)/.exec(id);
+  if (iso !== null) date = Number(`${iso[1]}${iso[2]}${iso[3]}`);
+  for (const run of id.replace(/-\d{4}-\d{2}-\d{2}(?!\d)/, "").match(/\d+/g) ?? []) {
     if (run.length >= MIN_DATE_DIGITS) date = Number(run);
     else numbers.push(Number(run));
   }
@@ -208,7 +211,7 @@ export function renderMatrixToml(matrix: ModelMatrix): string {
 export function upsertModelsTable(text: string, matrix: ModelMatrix): string {
   const table = renderMatrixToml(matrix);
   const lines = text.split("\n");
-  const start = lines.findIndex((l) => l.trim() === "[models]");
+  const start = lines.findIndex((l) => /^\[models\]\s*(#.*)?$/.test(l.trim()));
   if (start === -1) {
     const body = text.trimEnd();
     return body === "" ? table : `${body}\n\n${table}`;

package/src/core/push-command.ts

@@ -1,4 +1,4 @@
-import { gitInvocations } from "./commit-command.ts";
+import { resolveGit } from "./git-invocations.ts";
 
 export type PushTarget = {
   readonly remote: string | undefined;
@@ -8,29 +8,54 @@ export type PushTarget = {
 };
 
 const VALUE_OPTIONS = new Set(["--repo", "-o", "--push-option", "--receive-pack", "--exec"]);
+const isDynamic = (refspec: string): boolean => /[$`*?[]/.test(refspec);
 
 const destination = (refspec: string): string => {
   const dst = refspec.includes(":") ? refspec.slice(refspec.lastIndexOf(":") + 1) : refspec;
   return dst.replace(/^\+/, "").replace(/^refs\/heads\//, "");
 };
 
+type ParsedArgs = { positional: string[]; all: boolean; repo: string | undefined };
+
+const VALUE_PREFIX = "--repo=";
+
+function positionalArgs(args: readonly string[]): ParsedArgs {
+  const parsed: ParsedArgs = { positional: [], all: false, repo: undefined };
+  let valueFor: "repo" | "skip" | undefined;
+  for (const a of args) {
+    if (valueFor === "repo") parsed.repo = a;
+    if (valueFor !== undefined) valueFor = undefined;
+    else if (a === "--repo") valueFor = "repo";
+    else if (a.startsWith(VALUE_PREFIX)) parsed.repo = a.slice(VALUE_PREFIX.length);
+    else if (VALUE_OPTIONS.has(a)) valueFor = "skip";
+    else if (a === "--all" || a === "--mirror") parsed.all = true;
+    else if (!a.startsWith("-")) parsed.positional.push(a);
+  }
+  return parsed;
+}
+
+const toTarget = (args: readonly string[]): PushTarget => {
+  const { positional, all, repo } = positionalArgs(args);
+  // With --repo, every positional argument is a refspec.
+  const [remote, ...refspecs] = repo === undefined ? positional : [repo, ...positional];
+  const destinations = refspecs.map(destination);
+  const named = (b: string): boolean => b !== "HEAD" && b !== "" && !isDynamic(b);
+  return {
+    remote,
+    branches: destinations.filter(named),
+    allBranches: all || destinations.some(isDynamic),
+  };
+};
+
 /** The remote and branches of every `git push` in a command (empty list when there is no push). */
 export function pushTargets(command: string): PushTarget[] {
-  return gitInvocations(command).flatMap((g): PushTarget[] => {
-    if (g.sub !== "push") return [];
-    const positional: string[] = [];
-    let allBranches = false;
-    for (let i = 0; i < g.args.length; i++) {
-      const a = g.args[i] ?? "";
-      if (VALUE_OPTIONS.has(a)) i++;
-      else if (a === "--all" || a === "--mirror") allBranches = true;
-      else if (!a.startsWith("-")) positional.push(a);
-    }
-    const [remote, ...refspecs] = positional;
-    const branches = refspecs.flatMap((r) => {
-      const b = destination(r);
-      return b === "HEAD" || b === "" ? [] : [b];
-    });
-    return [{ remote, branches, allBranches }];
-  });
+  const resolution = resolveGit(command);
+  const targets = resolution.invocations.flatMap((g) =>
+    g.sub === "push" ? [toTarget(g.args)] : [],
+  );
+  // git run through something opaque (xargs, `$CMD`): a push cannot be ruled out, so assume the worst.
+  const opaquePush = resolution.opaque && /\bpush\b/.test(command);
+  return opaquePush
+    ? [...targets, { remote: undefined, branches: [], allBranches: true }]
+    : targets;
 }

package/src/core/redact.ts

@@ -11,8 +11,17 @@ export function redactSecrets(text: string): string {
       "[redacted private key]",
     )
     .replace(
-      /\b(\w*(?:token|key|secret|password|passwd)\w*["']?\s*[:=]\s*)(["'])[^"'\n]+\2/gi,
+      /\b(\w*(?:token|key|secret|password|passwd)\w*["']?\s*(?::=|[:=])\s*)(["'])[^"'\n]+\2/gi,
       "$1$2[redacted]$2",
     )
-    .replace(/\bsk-[A-Za-z0-9_-]{16,}/g, "[redacted]");
+    .replace(
+      /\b(\w*(?:token|key|secret|password|passwd|pwd)\w*\s*(?::=|[:=])[ \t]*)[^\s"'`,;]{4,}/gi,
+      "$1[redacted]",
+    )
+    .replace(/\bsk-[A-Za-z0-9_-]{16,}/g, "[redacted]")
+    .replace(/\bAKIA[0-9A-Z]{16}\b/g, "[redacted]")
+    .replace(/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "[redacted]")
+    .replace(/\bglpat-[A-Za-z0-9_-]{16,}/g, "[redacted]")
+    .replace(/\bnpm_[A-Za-z0-9]{30,}/g, "[redacted]")
+    .replace(/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/g, "[redacted]");
 }

package/src/core/types.ts

@@ -56,6 +56,12 @@ export type Departure = {
 
 export type JevStatus = "online" | "offline" | "unknown";
 
+export type CiStatusName = "green" | "red" | "pending" | "unknown";
+export const CI_STATUSES: readonly CiStatusName[] = ["green", "red", "pending", "unknown"];
+
+/** Last observed CI state of the trunk (see `/devsys-ci`). */
+export type CiState = { readonly status: CiStatusName; readonly sha?: string };
+
 export type DevsysState = {
   readonly phase: Phase;
   readonly sizing?: Sizing;
@@ -63,6 +69,7 @@ export type DevsysState = {
   readonly openDepartures: ReadonlyArray<Departure>;
   readonly jev: JevStatus;
   readonly lastPushAt?: string;
+  readonly ci?: CiState;
 };
 
 export const initialState = (): DevsysState => ({

package/src/gates/commit-guard.ts

@@ -1,11 +1,11 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { resolve } from "node:path";
 import {
   type ExtensionAPI,
   type ExtensionContext,
   isToolCallEventType,
 } from "@earendil-works/pi-coding-agent";
-import { extractCommit } from "../core/commit-command.ts";
+import { type CommitExtraction, extractCommit } from "../core/commit-command.ts";
 import {
   findForbiddenTrailers,
   hasRationaleBody,
@@ -38,12 +38,17 @@ const MIXED = gateId("commit.mixed-change");
 
 const readMessageFile = (cwd: string, path: string): string | undefined => {
   try {
-    return readFileSync(join(cwd, path), "utf8");
+    return readFileSync(resolve(cwd, path), "utf8");
   } catch {
     return undefined;
   }
 };
 
+const messageOf = (extracted: CommitExtraction, cwd: string): string | undefined => {
+  if (extracted.kind === "message") return extracted.message;
+  return extracted.kind === "file" ? readMessageFile(cwd, extracted.path) : undefined;
+};
+
 /** Deterministic checks: Conventional subject and a prose rationale body. */
 function messageNeeds(message: string): Need[] {
   const parsed = parseConventionalCommit(message);
@@ -58,12 +63,16 @@ async function pendingDiff(
   exec: Exec,
   cwd: string,
 ): Promise<{ stat: string; diff: string } | undefined> {
-  const [stat, diff] = await Promise.all([
-    exec("git", ["diff", "HEAD", "--stat"], { cwd, timeout: 10_000 }),
-    exec("git", ["diff", "HEAD"], { cwd, timeout: 10_000 }),
-  ]);
-  if (stat.code !== 0 || diff.code !== 0 || diff.stdout.trim() === "") return undefined;
-  return { stat: stat.stdout, diff: diff.stdout };
+  try {
+    const [stat, diff] = await Promise.all([
+      exec("git", ["diff", "HEAD", "--stat"], { cwd, timeout: 10_000 }),
+      exec("git", ["diff", "HEAD"], { cwd, timeout: 10_000 }),
+    ]);
+    if (stat.code !== 0 || diff.code !== 0 || diff.stdout.trim() === "") return undefined;
+    return { stat: stat.stdout, diff: diff.stdout };
+  } catch {
+    return undefined;
+  }
 }
 
 async function jevNeeds(
@@ -103,16 +112,15 @@ const blockReason = (need: Need): string =>
 export function registerCommitGuard(deps: CommitGuardDeps): void {
   deps.pi.on("tool_call", async (event, ctx) => {
     if (!isToolCallEventType("bash", event)) return undefined;
-    const extracted = extractCommit(event.input.command);
-    const message =
-      extracted.kind === "message"
-        ? extracted.message
-        : extracted.kind === "file"
-          ? readMessageFile(ctx.cwd, extracted.path)
-          : undefined;
-    if (message === undefined) return undefined;
+    const command = event.input.command;
+    const extracted = extractCommit(command);
+    if (extracted.kind === "not-commit") return undefined;
+    const message = messageOf(extracted, ctx.cwd);
 
-    const forbidden = findForbiddenTrailers(message);
+    // Safety net: whatever the message source, the command text itself must not carry an AI trailer
+    // (heredocs written to a file first, --trailer values on amends, messages built elsewhere).
+    const trailers = extracted.kind === "unknown" ? extracted.trailers.join("\n") : "";
+    const forbidden = findForbiddenTrailers(`${message ?? ""}\n${trailers}\n${command}`);
     if (forbidden.length > 0) {
       return {
         block: true,
@@ -122,6 +130,7 @@ export function registerCommitGuard(deps: CommitGuardDeps): void {
           "something to depart from. Remove the trailer and commit again.",
       };
     }
+    if (message === undefined) return undefined;
 
     const needs = messageNeeds(message);
     const bodyPresent = !needs.some((n) => n.why.startsWith("the message has no body"));

package/src/gates/push-guard.ts

@@ -35,9 +35,13 @@ const RED_TRUNK = gate("push.red-trunk");
 const DELIVERY_MODE = gate("push.delivery-mode");
 
 async function currentBranch(exec: Exec, cwd: string): Promise<string | undefined> {
-  const r = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, timeout: 5000 });
-  const name = r.code === 0 ? r.stdout.trim() : "";
-  return name === "" || name === "HEAD" ? undefined : name;
+  try {
+    const r = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, timeout: 5000 });
+    const name = r.code === 0 ? r.stdout.trim() : "";
+    return name === "" || name === "HEAD" ? undefined : name;
+  } catch {
+    return undefined;
+  }
 }
 
 async function pushesTrunk(
@@ -58,6 +62,7 @@ async function repairsRedTrunk(
   deps: PushGuardDeps,
   ctx: ExtensionContext,
   config: DevsysConfig,
+  runId: number | undefined,
 ): Promise<boolean> {
   const message = await deps.exec("git", ["log", "-1", "--format=%B"], {
     cwd: ctx.cwd,
@@ -70,7 +75,7 @@ async function repairsRedTrunk(
   if (diff.code !== 0 || diff.stdout.trim() === "") return false;
   const judged = await judgeFixRelated(deps.jev(ctx), {
     diff: diff.stdout,
-    failingLog: await getFailureLog(deps.exec, ctx.cwd),
+    failingLog: await getFailureLog(deps.exec, ctx.cwd, runId),
     message: message.stdout,
   });
   return judged.ok && judged.value >= FIX_RELATED_THRESHOLD;
@@ -145,7 +150,7 @@ export function registerPushGuard(deps: PushGuardDeps): void {
     }
     const status = await getTrunkStatus(deps.exec, { branch: trunk, cwd: ctx.cwd });
     if (status.status !== "red") return undefined;
-    if (await repairsRedTrunk(deps, ctx, loaded.value)) return undefined;
+    if (await repairsRedTrunk(deps, ctx, loaded.value, status.runId)) return undefined;
     return hardStop(deps, {
       ctx,
       toolCallId: event.toolCallId,

package/src/gates/request-approval-tool.ts

@@ -33,6 +33,12 @@ export function createRequestApprovalTool(
     exposure: "direct",
     async execute(toolCallId, params: Static<typeof Parameters>, _signal, _onUpdate, ctx) {
       const gate = parseGateId(params.gate);
+      if (params.gate === "commit.forbidden-trailer") {
+        return text(
+          "commit.forbidden-trailer is never approvable: remove the AI attribution from the commit instead.",
+          true,
+        );
+      }
       if (isParseError(gate) || gate.includes(":") || lookupGate(gate)?.tier !== "hard") {
         const hard = gateIds().filter((id) => lookupGate(id)?.tier === "hard");
         return text(`"${params.gate}" is not a hard gate. Hard gates: ${hard.join(", ")}`, true);

package/src/state/ci-command.ts

@@ -0,0 +1,77 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { Exec } from "../core/exec.ts";
+import type { CiState } from "../core/types.ts";
+import { watchCi } from "./ci-watch.ts";
+import { loadConfig } from "./config.ts";
+import type { SessionState } from "./session-state.ts";
+
+export const CI_ENTRY_TYPE = "devsys-ci";
+
+export type CiCommandDeps = {
+  pi: ExtensionAPI;
+  state: SessionState;
+  exec: Exec;
+  sleep?: (ms: number) => Promise<void>;
+  intervalMs?: number;
+  maxPolls?: number;
+};
+
+async function headSha(exec: Exec, cwd: string): Promise<string | undefined> {
+  try {
+    const r = await exec("git", ["rev-parse", "HEAD"], { cwd, timeout: 5000 });
+    return r.code === 0 && r.stdout.trim() !== "" ? r.stdout.trim() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const sameCi = (a: CiState | undefined, b: CiState): boolean =>
+  a?.status === b.status && a?.sha === b.sha;
+
+/** Observes trunk CI until it settles, mirroring each change into state (status line) and a `devsys-ci` entry. */
+export async function runCiWatch(
+  deps: CiCommandDeps,
+  ctx: Pick<ExtensionCommandContext, "cwd" | "ui">,
+): Promise<CiState | undefined> {
+  const config = await loadConfig(ctx.cwd);
+  if (!config.ok) {
+    ctx.ui.notify(`cannot read the delivery policy: ${config.error.message}`, "error");
+    return undefined;
+  }
+  const head = await headSha(deps.exec, ctx.cwd);
+  const final = await watchCi({
+    expectSha: head,
+    exec: deps.exec,
+    branch: config.value.delivery.trunk,
+    cwd: ctx.cwd,
+    sleep: deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    intervalMs: deps.intervalMs ?? 15_000,
+    maxPolls: deps.maxPolls ?? 120,
+    onObserved: (observed) => {
+      if (sameCi(deps.state.get().ci, observed)) return;
+      deps.state.update((s) => ({ ...s, ci: observed }));
+      deps.pi.appendEntry(CI_ENTRY_TYPE, observed);
+    },
+  });
+  ctx.ui.notify(
+    `CI on ${config.value.delivery.trunk}: ${final.status}${final.sha === undefined ? "" : ` (${final.sha.slice(0, 7)})`}`,
+    final.status === "red" ? "error" : "info",
+  );
+  return final;
+}
+
+/** `/devsys-ci`: watch the trunk's CI without blocking the session. */
+export function registerCiCommand(deps: CiCommandDeps): void {
+  deps.pi.registerCommand("devsys-ci", {
+    description: "Watch CI on the trunk and show its state in the status line",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify("watching CI on the trunk…", "info");
+      runCiWatch(deps, ctx).catch((cause: unknown) => {
+        ctx.ui.notify(
+          `CI watch failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          "error",
+        );
+      });
+    },
+  });
+}

package/src/state/ci-watch.ts

@@ -0,0 +1,34 @@
+import type { Exec } from "../core/exec.ts";
+import type { CiState } from "../core/types.ts";
+import { getTrunkStatus } from "./ci.ts";
+
+export type WatchOptions = {
+  exec: Exec;
+  branch: string;
+  cwd: string;
+  /** Called with every observation, including the first. */
+  onObserved: (observed: CiState) => void;
+  sleep: (ms: number) => Promise<void>;
+  intervalMs: number;
+  maxPolls: number;
+  /** The commit whose run is being waited for; runs of other commits count as still pending. */
+  expectSha?: string | undefined;
+};
+
+/** Observes the trunk's newest run (for `expectSha`, when given) until it settles (not pending) or the poll budget is spent. */
+export async function watchCi(options: WatchOptions): Promise<CiState> {
+  let last: CiState = { status: "unknown" };
+  for (let poll = 0; poll < options.maxPolls; poll++) {
+    const trunk = await getTrunkStatus(options.exec, {
+      branch: options.branch,
+      cwd: options.cwd,
+    });
+    const stale = options.expectSha !== undefined && trunk.headSha !== options.expectSha;
+    const status = stale ? "pending" : trunk.status;
+    last = trunk.headSha === undefined ? { status } : { status, sha: trunk.headSha };
+    options.onObserved(last);
+    if (last.status !== "pending") return last;
+    await options.sleep(options.intervalMs);
+  }
+  return last;
+}

package/src/state/ci.ts

@@ -3,6 +3,7 @@ import type { Exec } from "../core/exec.ts";
 export type TrunkStatus = {
   readonly status: "green" | "red" | "pending" | "unknown";
   readonly headSha: string | undefined;
+  readonly runId?: number | undefined;
 };
 
 const UNKNOWN: TrunkStatus = { status: "unknown", headSha: undefined };
@@ -12,7 +13,7 @@ const isRecord = (v: unknown): v is Record<string, unknown> =>
 
 const FAILED = new Set(["failure", "timed_out", "startup_failure", "action_required"]);
 
-/** Parses `gh run list --json status,conclusion,headSha` output for the newest run. */
+/** Parses `gh run list --json status,conclusion,headSha,databaseId` output for the newest run. */
 export function parseRunList(stdout: string): TrunkStatus {
   let parsed: unknown;
   try {
@@ -23,12 +24,13 @@ export function parseRunList(stdout: string): TrunkStatus {
   const run = Array.isArray(parsed) ? parsed[0] : undefined;
   if (!isRecord(run)) return UNKNOWN;
   const headSha = typeof run.headSha === "string" ? run.headSha : undefined;
-  if (run.status !== "completed") return { status: "pending", headSha };
-  if (run.conclusion === "success") return { status: "green", headSha };
+  const id = typeof run.databaseId === "number" ? { runId: run.databaseId } : {};
+  if (run.status !== "completed") return { status: "pending", headSha, ...id };
+  if (run.conclusion === "success") return { status: "green", headSha, ...id };
   if (typeof run.conclusion === "string" && FAILED.has(run.conclusion)) {
-    return { status: "red", headSha };
+    return { status: "red", headSha, ...id };
   }
-  return { status: "unknown", headSha };
+  return { status: "unknown", headSha, ...id };
 }
 
 /** CI state of the newest run on the trunk branch; `unknown` whenever `gh` cannot say. */
@@ -47,7 +49,7 @@ export async function getTrunkStatus(
         "--limit",
         "1",
         "--json",
-        "status,conclusion,headSha",
+        "status,conclusion,headSha,databaseId",
       ],
       { ...(where.cwd !== undefined ? { cwd: where.cwd } : {}), timeout: 15_000 },
     );
@@ -57,10 +59,15 @@ export async function getTrunkStatus(
   }
 }
 
-/** The failing log of the newest failed run, clipped; empty when unavailable. */
-export async function getFailureLog(exec: Exec, cwd: string | undefined): Promise<string> {
+/** The failing log of a failed run, clipped; empty when unavailable (`gh run view` needs an id when non-interactive). */
+export async function getFailureLog(
+  exec: Exec,
+  cwd: string | undefined,
+  runId: number | undefined,
+): Promise<string> {
+  if (runId === undefined) return "";
   try {
-    const r = await exec("gh", ["run", "view", "--log-failed"], {
+    const r = await exec("gh", ["run", "view", String(runId), "--log-failed"], {
       ...(cwd !== undefined ? { cwd } : {}),
       timeout: 30_000,
     });

package/src/state/config.ts

@@ -124,11 +124,13 @@ const POSITIVE = { min: 1, max: 1_000_000, integer: true };
 
 const MODEL_CANDIDATE = /^(@[a-z]+|[^/\s]+\/\S+)$/;
 
+const knownSlotRef = (c: string): boolean => !c.startsWith("@") || isSlot(c.slice(1));
+
 function candidates(raw: unknown, key: string): Result<readonly string[], ConfigError> {
   const valid =
     Array.isArray(raw) &&
     raw.length > 0 &&
-    raw.every((c) => typeof c === "string" && MODEL_CANDIDATE.test(c));
+    raw.every((c) => typeof c === "string" && MODEL_CANDIDATE.test(c) && knownSlotRef(c));
   return valid
     ? ok(raw.map(String))
     : fail(

package/src/state/session-state.ts

@@ -1,6 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { parseDeparture } from "../core/departure.ts";
 import {
+  CI_STATUSES,
+  type CiState,
+  type CiStatusName,
   type Departure,
   type DevsysState,
   initialState,
@@ -29,10 +32,20 @@ const JEV: ReadonlyArray<JevStatus> = ["online", "offline", "unknown"];
 const isRecord = (v: unknown): v is Record<string, unknown> =>
   typeof v === "object" && v !== null && !Array.isArray(v);
 
+function parseCi(input: unknown): CiState | ParseError {
+  if (!isRecord(input)) return parseError("ci must be an object");
+  const { status, sha } = input;
+  if (!CI_STATUSES.includes(status as CiStatusName)) {
+    return parseError(`unknown ci status: ${String(status)}`);
+  }
+  if (sha !== undefined && typeof sha !== "string") return parseError("ci.sha must be a string");
+  return { status: status as CiStatusName, ...(sha !== undefined ? { sha } : {}) };
+}
+
 /** 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 } = input;
+  const { phase, sizing, activeSlice, openDepartures, jev, lastPushAt, ci } = 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");
@@ -51,6 +64,8 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
   if (lastPushAt !== undefined && typeof lastPushAt !== "string") {
     return parseError("lastPushAt must be a string");
   }
+  const parsedCi = ci === undefined ? undefined : parseCi(ci);
+  if (isParseError(parsedCi)) return parsedCi;
   return {
     phase: phase as Phase,
     jev: jev as JevStatus,
@@ -58,6 +73,7 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
     ...(sizing !== undefined ? { sizing: sizing as Sizing } : {}),
     ...(activeSlice !== undefined ? { activeSlice: activeSlice as SliceRef } : {}),
     ...(lastPushAt !== undefined ? { lastPushAt } : {}),
+    ...(parsedCi !== undefined ? { ci: parsedCi } : {}),
   };
 }