@jwilger/pi-development-system 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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

@@ -41,7 +41,10 @@ check now uses expiry; clock-skew tolerance is deliberately not added.
 
 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.
+commit is a `fix` and Jev reads its diff as only repairing the failing run (it needs
+the failing log and Jev online; otherwise the push is a hard stop). 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
 

package/src/core/commit-command.ts

@@ -1,53 +1,25 @@
-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[] } {
-  const bodies: string[] = [];
-  const rest = command.replace(HEREDOC, (_all, _quote, _tag, body: string) => {
-    bodies.push(body);
+function stripHeredocs(command: string): { rest: string; bodies: Heredoc[] } {
+  const bodies: Heredoc[] = [];
+  const rest = command.replace(HEREDOC, (...m: unknown[]) => {
+    bodies.push({ body: String(m[3]), at: Number(m[m.length - 2]) });
     return "\n";
   });
   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 Heredoc = { readonly body: string; readonly at: number };
 
 type Options = {
   messages: string[];
@@ -56,59 +28,107 @@ 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"],
+];
+
+/** The option a `--name`/`--na=value` spelling means; git accepts any unambiguous prefix (3+ chars). */
+function longOption(arg: string): { kind: Parsed["kind"]; inline: string | undefined } | undefined {
+  if (!arg.startsWith("--")) return undefined;
+  const eq = arg.indexOf("=");
+  const name = eq < 0 ? arg : arg.slice(0, eq);
+  if (name.length < 5) return undefined;
+  const hit = LONG.find(([long]) => long.startsWith(name));
+  return hit === undefined
+    ? undefined
+    : { kind: hit[1], inline: eq < 0 ? undefined : arg.slice(eq + 1) };
+}
+
+/** 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] ?? "";
+  const long = longOption(a);
+  if (long !== undefined) {
+    return long.inline === undefined
+      ? { kind: long.kind, value: args[i + 1], next: i + 2 }
+      : { kind: long.kind, value: long.inline, 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;
 }
 
-/** 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 unknown = (trailers: readonly string[] = []): CommitExtraction => ({
+  kind: "unknown",
+  trailers,
+});
+
+const STDIN_PATHS = new Set(["-", "/dev/stdin", "/proc/self/fd/0"]);
+
+/** The heredoc that is this commit's input: the first one written after the word `commit`. */
+const heredocFor = (command: string, bodies: readonly Heredoc[]): string | undefined => {
+  const from = command.search(/\bcommit\b/);
+  return bodies.find((h) => h.at >= from)?.body.trim();
+};
+
+function extractOne(args: readonly string[], heredoc: string | undefined): CommitExtraction {
+  const options = readOptions(args);
+  if (options.file !== undefined && STDIN_PATHS.has(options.file)) {
+    return heredoc === undefined
+      ? unknown(options.trailers)
+      : { kind: "message", message: heredoc };
+  }
+  if (options.file !== undefined) return { kind: "file", path: options.file };
+  const parts = [...options.messages];
+  if (options.opaque) {
+    if (heredoc === undefined) return unknown(options.trailers);
+    parts.push(heredoc);
   }
-  return { kind: "not-commit" };
+  if (parts.length === 0) return unknown(options.trailers);
+  const trailers = options.trailers.length === 0 ? "" : `\n\n${options.trailers.join("\n")}`;
+  return { kind: "message", message: `${parts.join("\n\n")}${trailers}` };
+}
+
+/** One extraction per `git commit` in the command (empty when it commits nothing). */
+export function extractCommits(command: string): CommitExtraction[] {
+  const { rest, bodies } = stripHeredocs(command);
+  const resolution = resolveGit(rest);
+  const heredoc = heredocFor(command, bodies);
+  const commits = resolution.invocations.filter((g) => g.sub === "commit");
+  const found = commits.map((g) => extractOne(g.args, heredoc));
+  const hidden = resolution.opaque && /\bcommit\b/.test(command);
+  return hidden ? [...found, unknown()] : found;
 }
 
-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) }];
-    }),
-  );
+/** The first commit a shell command makes: its message, or why it cannot be known. */
+export function extractCommit(command: string): CommitExtraction {
+  return extractCommits(command)[0] ?? { kind: "not-commit" };
 }

package/src/core/commit-message.ts

@@ -86,20 +86,43 @@ 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);
     });
 }
 
+const AI_TRAILER_ANYWHERE = /(?:co-authored-by|generated-by)\s*[:=]/gi;
+
+/** AI-attribution trailer keys anywhere in free text (command lines, quoted strings, printf bodies). */
+export function findForbiddenTrailerKeys(text: string): string[] {
+  return [...text.matchAll(AI_TRAILER_ANYWHERE)].map((m) => m[0].trim());
+}
+
 const isBullets = (paragraph: string): boolean =>
   paragraph.split("\n").every((line) => /^\s*(?:[-*+]|\d+[.)])\s/.test(line));
 
 const wordCount = (text: string): number => text.split(/\s+/).filter((w) => w !== "").length;
 
+const PROSE_TRAILER_WORDS = 5;
+
+/** A trailer-shaped line whose value is a sentence ("Reason: the cache was stale…") is prose. */
+const isProseTrailer = (line: string): boolean => {
+  const m = TRAILER.exec(line.trim());
+  return m !== null && m[1] !== "BREAKING CHANGE" && wordCount(m[2] ?? "") >= PROSE_TRAILER_WORDS;
+};
+
 /** A body needs at least one prose paragraph (not a file list) that says more than a few words. */
 export function hasRationaleBody(message: string): boolean {
-  const { body } = split(message);
-  return body.some((paragraph) => !isBullets(paragraph) && wordCount(paragraph) >= 5);
+  const { body, trailers } = split(message);
+  const trailerBlockLines =
+    withoutComments(message)
+      .split(/\n\s*\n/)
+      .at(-1)
+      ?.split("\n") ?? [];
+  const proseTrailer = trailers.length > 0 && trailerBlockLines.some(isProseTrailer);
+  return (
+    proseTrailer || body.some((paragraph) => !isBullets(paragraph) && wordCount(paragraph) >= 5)
+  );
 }

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,21 @@ 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",
+  "--config-env",
+  "--super-prefix",
+]);
 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 +228,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 +250,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 +269,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,116 @@
+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[];
+  /** Directory the command runs in, relative to the starting one (from `cd` and `git -C`), when it moved. */
+  readonly dir?: 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; dir: string | undefined };
+
+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");
+
+const joinDir = (base: string | undefined, next: string): string =>
+  next.startsWith("/") || base === undefined ? next : `${base}/${next}`;
+
+/** `git [global options] <sub> <args…>` (tokens start at the word after `git`). */
+function visitGit(rest: readonly string[], into: Collector): void {
+  let j = 0;
+  let dir = into.dir;
+  while (j < rest.length && (rest[j] ?? "").startsWith("-")) {
+    if (rest[j] === "-C") dir = joinDir(dir, rest[j + 1] ?? ".");
+    j += GLOBAL_WITH_VALUE.has(rest[j] ?? "") ? 2 : 1;
+  }
+  const sub = rest[j];
+  if (sub === undefined) return;
+  if (sub.startsWith("$")) into.opaque = true;
+  else {
+    const args = rest.slice(j + 1);
+    into.invocations.push(dir === undefined ? { sub, args } : { sub, args, dir });
+  }
+}
+
+/** 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));
+}
+
+/** `cd <dir>`: later git commands run there (a `$`-built target is unknowable, so it is ignored). */
+function visitCd(rest: readonly string[], into: Collector): void {
+  const target = rest.find((t) => !t.startsWith("-"));
+  if (target === undefined || /[$`]/.test(target) || target === "-") return;
+  into.dir = joinDir(into.dir, target);
+}
+
+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 (base === "cd") visitCd(rest, into);
+  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, dir: undefined };
+  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,36 +1,64 @@
-import { gitInvocations } from "./commit-command.ts";
+import { resolveGit } from "./git-invocations.ts";
 
 export type PushTarget = {
   readonly remote: string | undefined;
   /** Destination branch names named by refspecs; empty means "the current branch's default". */
   readonly branches: readonly string[];
   readonly allBranches: boolean;
+  /** Where the push runs when `cd`/`git -C` moved it away from the session's directory. */
+  readonly dir?: string | undefined;
 };
 
 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\//, "");
+  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[], dir: string | undefined): 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),
+    ...(dir === undefined ? {} : { dir }),
+  };
 };
 
 /** 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, g.dir)] : [],
+  );
+  // 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,21 @@ 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|passphrase|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(/\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}/g, "[redacted]")
+    .replace(/\bAIza[0-9A-Za-z_-]{35}/g, "[redacted]")
+    .replace(/(\s-u\s+[^\s:]+:)\S+/g, "$1[redacted]")
+    .replace(/\b(Cookie:\s*)[^\n]+/gi, "$1[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/gates/commit-guard.ts

@@ -1,12 +1,13 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, statSync } from "node:fs";
+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, extractCommits } from "../core/commit-command.ts";
 import {
+  findForbiddenTrailerKeys,
   findForbiddenTrailers,
   hasRationaleBody,
   parseConventionalCommit,
@@ -38,12 +39,19 @@ const MIXED = gateId("commit.mixed-change");
 
 const readMessageFile = (cwd: string, path: string): string | undefined => {
   try {
-    return readFileSync(join(cwd, path), "utf8");
+    const file = resolve(cwd, path);
+    if (!statSync(file).isFile()) return undefined; // never read a FIFO or device (it can block)
+    return readFileSync(file, "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 +66,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(
@@ -99,34 +111,52 @@ const blockReason = (need: Need): string =>
   `departing is deliberate call devsys_record_departure with gate "${need.gate}", what you are doing ` +
   "instead, why, and the cost if wrong; then retry.";
 
+const forbiddenReason = (found: readonly string[]): string =>
+  `commit.forbidden-trailer: this commit carries an AI attribution (${found.join("; ")}). ` +
+  "Commits in this repository have no Co-Authored-By or generated-by trailers and this is not " +
+  "something to depart from. Remove the trailer and commit again.";
+
+/** AI trailers in any message, --trailer value, or the command text itself (heredocs, printf, echo). */
+function forbiddenIn(
+  command: string,
+  extractions: readonly CommitExtraction[],
+  messages: readonly (string | undefined)[],
+): string[] {
+  const trailers = extractions.flatMap((e) => (e.kind === "unknown" ? e.trailers : []));
+  const text = [...messages, ...trailers].join("\n");
+  return [...findForbiddenTrailers(text), ...findForbiddenTrailerKeys(command)];
+}
+
+async function needsOf(
+  deps: CommitGuardDeps,
+  ctx: ExtensionContext,
+  message: string,
+): Promise<Need[]> {
+  const needs = messageNeeds(message);
+  const bodyPresent = !needs.some((n) => n.why.startsWith("the message has no body"));
+  const viaJev = await jevNeeds(deps, ctx, message, bodyPresent);
+  return [...needs, ...viaJev.filter((n) => !needs.some((m) => m.gate === n.gate))];
+}
+
 /** Soft gates on `git commit`: rationale, Conventional shape, structural/behavioural separation; AI trailers are refused. */
 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 forbidden = findForbiddenTrailers(message);
-    if (forbidden.length > 0) {
-      return {
-        block: true,
-        reason:
-          `commit.forbidden-trailer: this message carries an AI attribution (${forbidden.join("; ")}). ` +
-          "Commits in this repository have no Co-Authored-By or generated-by trailers and this is not " +
-          "something to depart from. Remove the trailer and commit again.",
-      };
-    }
+    const command = event.input.command;
+    const extractions = extractCommits(command);
+    if (extractions.length === 0) return undefined;
+    const messages = extractions.map((e) => messageOf(e, ctx.cwd));
 
-    const needs = messageNeeds(message);
-    const bodyPresent = !needs.some((n) => n.why.startsWith("the message has no body"));
-    const viaJev = await jevNeeds(deps, ctx, message, bodyPresent);
-    const all = [...needs, ...viaJev.filter((n) => !needs.some((m) => m.gate === n.gate))];
+    const forbidden = forbiddenIn(command, extractions, messages);
+    if (forbidden.length > 0) return { block: true, reason: forbiddenReason(forbidden) };
+
+    const known = messages.flatMap((m) => (m === undefined ? [] : [m]));
+    const all: Need[] = [];
+    for (const message of known) {
+      for (const need of await needsOf(deps, ctx, message)) {
+        if (!all.some((n) => n.gate === need.gate)) all.push(need);
+      }
+    }
     const uses = all.map((need) => ({ need, use: departureUse(deps.state, need.gate) }));
     const uncovered = uses.find(({ use }) => !use.hasOpen());
     if (uncovered !== undefined) return { block: true, reason: blockReason(uncovered.need) };

package/src/gates/push-guard.ts

@@ -1,3 +1,4 @@
+import { resolve } from "node:path";
 import {
   type ExtensionAPI,
   type ExtensionContext,
@@ -35,9 +36,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(
@@ -48,7 +53,8 @@ async function pushesTrunk(
 ): Promise<boolean> {
   for (const t of targets) {
     if (t.allBranches || t.branches.includes(trunk)) return true;
-    if (t.branches.length === 0 && (await currentBranch(exec, cwd)) === trunk) return true;
+    const where = t.dir === undefined ? cwd : resolve(cwd, t.dir);
+    if (t.branches.length === 0 && (await currentBranch(exec, where)) === trunk) return true;
   }
   return false;
 }
@@ -58,6 +64,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,
@@ -68,9 +75,11 @@ async function repairsRedTrunk(
   const range = `${config.delivery.remote}/${config.delivery.trunk}..HEAD`;
   const diff = await deps.exec("git", ["diff", range], { cwd: ctx.cwd, timeout: 10_000 });
   if (diff.code !== 0 || diff.stdout.trim() === "") return false;
+  const failingLog = await getFailureLog(deps.exec, ctx.cwd, runId);
+  if (failingLog.trim() === "") return false; // nothing to compare the diff against: fail closed
   const judged = await judgeFixRelated(deps.jev(ctx), {
     diff: diff.stdout,
-    failingLog: await getFailureLog(deps.exec, ctx.cwd),
+    failingLog,
     message: message.stdout,
   });
   return judged.ok && judged.value >= FIX_RELATED_THRESHOLD;
@@ -145,7 +154,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

@@ -16,6 +16,15 @@ export type CiCommandDeps = {
   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;
 
@@ -29,7 +38,9 @@ export async function runCiWatch(
     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,

package/src/state/ci-watch.ts

@@ -11,9 +11,11 @@ export type WatchOptions = {
   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 until it settles (not pending) or the poll budget is spent. */
+/** 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++) {
@@ -21,10 +23,9 @@ export async function watchCi(options: WatchOptions): Promise<CiState> {
       branch: options.branch,
       cwd: options.cwd,
     });
-    last =
-      trunk.headSha === undefined
-        ? { status: trunk.status }
-        : { status: trunk.status, sha: trunk.headSha };
+    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);

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(