@dev-loops/core 1.0.2 → 1.0.4-pre.0

package/src/config/extension-defaults.yaml

@@ -133,6 +133,26 @@ gates:
         mandatory: true
         persona: review
         prompt: 'Review the PR description for completeness, contract fitness, and checkbox formatting before this PR is marked ready for review. The PR body is the implementation contract — it must have: - A Summary section explaining what changed and why - A Scope and context section defining the boundary of the change - An Acceptance criteria section with the linked issue acceptance criteria - A Definition of done section - A Non-goals section - A Validation command section describing exactly how to verify the change - The "Closes #N" line must match the linked issue; flag changes that alter or remove the operator-intended close target Checkboxes (`- [ ]` / `- [x]`, or `* [ ]` / `* [x]`) must appear inside genuine Markdown list items. Flag any checkbox marker used outside a list item (including table cells) as a medium finding. Flag any checkbox marker wrapped in backticks (e.g. `` `[x]` ``) as a medium finding. Flag PRs where the body is a single sentence or lacks any of these sections. Do not block on formatting preferences other than checkbox correctness.'
+      - name: holistic
+        mandatory: true
+        persona: review
+        prompt: >-
+          Review the WHOLE change holistically, on its merits, as a senior
+          engineer doing a final read of the entire diff. You are independent and
+          un-briefed: you receive only the spec (acceptance criteria, definition
+          of done, non-goals) and the diff — no author or developer brief and no
+          steering from the reviewed party. Your mandate is broad, not a single
+          named lens. Read the whole change end to end and judge whether, taken
+          together, it correctly and completely does what the spec asks, is
+          internally coherent, and is safe to ship. Concentrate on CROSS-CUTTING
+          problems that no narrow angle owns: mismatches between parts of the
+          change, gaps between the diff and the acceptance criteria, unintended
+          interactions across modules, missing pieces the spec implies, and
+          defects that would otherwise surface later in Copilot review or a
+          consumer repo. Cite concrete file:line evidence for each finding and
+          give a minimal fix. Respect declared non-goals — do not manufacture
+          scope. If the change is coherent and complete against the spec, return
+          clean.
     # #1442 (ADR 0041 prose half): required fail-closed deslop angle for prose
     # deliverables. Runs the A/B-contrast-removal deslop step (ab-contrast-
     # deslop-step.md) — flag surviving binary-contrast constructions so the gate
@@ -221,6 +241,14 @@ gates:
         angles: [srp, soc, ocp, lsp, isp, dip]
       - name: finalization
         angles: [correctness-final, ui-validation]
+      # The holistic reviewer reads the whole diff, so it gets its own
+      # reviewer rather than being auto-chunked with unrelated leftover
+      # angles — one reviewer reviews the whole change holistically.
+      # A consumer repo that overrides gates.fanout.groups replaces this
+      # table wholesale (shallow merge) and must restate this singleton to
+      # keep holistic un-batched.
+      - name: holistic
+        angles: [holistic]
   preApproval:
     angles:
       - name: dry
@@ -294,6 +322,26 @@ gates:
           require a matrix on the PR — the matrix lives on the issue; the PR carries the derived
           checklists. The boundary is explicit: the deterministic block enforces completeness (nothing
           left unchecked/forgotten); you verify each [x] is real and faithfully derived.
+      - name: holistic
+        mandatory: true
+        persona: review
+        prompt: >-
+          Review the WHOLE change holistically, on its merits, as a senior
+          engineer doing a final read of the entire diff. You are independent and
+          un-briefed: you receive only the spec (acceptance criteria, definition
+          of done, non-goals) and the diff — no author or developer brief and no
+          steering from the reviewed party. Your mandate is broad, not a single
+          named lens. Read the whole change end to end and judge whether, taken
+          together, it correctly and completely does what the spec asks, is
+          internally coherent, and is safe to ship. Concentrate on CROSS-CUTTING
+          problems that no narrow angle owns: mismatches between parts of the
+          change, gaps between the diff and the acceptance criteria, unintended
+          interactions across modules, missing pieces the spec implies, and
+          defects that would otherwise surface later in Copilot review or a
+          consumer repo. Cite concrete file:line evidence for each finding and
+          give a minimal fix. Respect declared non-goals — do not manufacture
+          scope. If the change is coherent and complete against the spec, return
+          clean.
       - contradiction-lens
       - correctness-final
       - ui-validation

package/src/github/copilot-helpers.mjs

@@ -10,6 +10,73 @@ import { trimmedOrNull } from "../loop/normalize.mjs";
 // acting on the gate's behalf must agree with the gate about what a submitted
 // review is.
 export const SUBMITTED_REVIEW_STATES = new Set(["APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED"]);
+
+// Copilot's `ccr-overview-v2` COMMENTED review opens with ONE of three
+// disposition headers: "### 🟢 Approval recommended" (clean), "### 🟡 Changes
+// recommended" (findings), or "### 🔵 Needs a closer look" (non-approval, the
+// reviewer is uncertain). All Copilot reviews are COMMENTED, so this header is
+// the only body signal. We match the disposition by its TEXT, not the emoji:
+// the old 🟡-only key read the 🔵 "Needs a closer look" non-approval as clean
+// and would fail-open on any future glyph change. Line-anchor the disposition
+// header (`^###\s+`, multiline) with the emoji optional so a body merely
+// QUOTING a phrase ("No changes recommended") never false-positives.
+const COPILOT_DISPOSITION_HEADER_RE = /^###\s+(.+)$/mu;
+// Strip a leading emoji/glyph run (any leading non-letters) so the text alone
+// is compared, then lowercase for a case-insensitive disposition lookup.
+const COPILOT_DISPOSITION_LEADING_GLYPHS_RE = /^[^\p{L}]+/u;
+const COPILOT_CLEAN_DISPOSITION = "approval recommended";
+const COPILOT_CHANGES_RECOMMENDED_DISPOSITION = "changes recommended";
+const COPILOT_NEEDS_CLOSER_LOOK_DISPOSITION = "needs a closer look";
+
+// Canonical current-head Copilot review body dispositions. `changes_recommended`
+// (🟡) and `unrecognized` are actionable non-approvals; `needs_closer_look` (🔵)
+// is a soft, conductor-overridable non-approval; `clean` (🟢) and `none` (no
+// disposition header) are not findings. Both the loop-block signal
+// (copilotReviewBodySignalsChanges) and the merge-convergence precondition read
+// the SAME classification, so the two can never drift.
+export const COPILOT_DISPOSITION = Object.freeze({
+  CLEAN: "clean",
+  CHANGES_RECOMMENDED: "changes_recommended",
+  NEEDS_CLOSER_LOOK: "needs_closer_look",
+  UNRECOGNIZED: "unrecognized",
+  NONE: "none",
+});
+
+/**
+ * Classify a Copilot review's current-head body disposition. Text-matched (not
+ * emoji-keyed) so a glyph change never silently reclassifies. Fails closed: an
+ * unrecognized `### ` disposition header returns UNRECOGNIZED (an actionable
+ * non-approval), so a future format change degrades safe.
+ */
+export function classifyCopilotReviewBodyDisposition(state, body) {
+  const normalizedState = typeof state === "string" ? state.toUpperCase() : "";
+  // A human-style CHANGES_REQUESTED is always actionable regardless of body.
+  if (normalizedState === "CHANGES_REQUESTED") return COPILOT_DISPOSITION.CHANGES_RECOMMENDED;
+  if (normalizedState !== "COMMENTED") return COPILOT_DISPOSITION.NONE;
+  if (typeof body !== "string") return COPILOT_DISPOSITION.NONE;
+
+  const headerMatch = body.match(COPILOT_DISPOSITION_HEADER_RE);
+  // No disposition header at all (empty body, generic footer, legacy format):
+  // no body signal, so this is not a finding.
+  if (!headerMatch) return COPILOT_DISPOSITION.NONE;
+
+  const disposition = headerMatch[1]
+    .replace(COPILOT_DISPOSITION_LEADING_GLYPHS_RE, "")
+    .trim()
+    .toLowerCase();
+  if (disposition === COPILOT_CLEAN_DISPOSITION) return COPILOT_DISPOSITION.CLEAN;
+  if (disposition === COPILOT_CHANGES_RECOMMENDED_DISPOSITION) return COPILOT_DISPOSITION.CHANGES_RECOMMENDED;
+  if (disposition === COPILOT_NEEDS_CLOSER_LOOK_DISPOSITION) return COPILOT_DISPOSITION.NEEDS_CLOSER_LOOK;
+  // Fail closed on an unrecognized disposition header on the current head.
+  return COPILOT_DISPOSITION.UNRECOGNIZED;
+}
+
+export function copilotReviewBodySignalsChanges(state, body) {
+  const disposition = classifyCopilotReviewBodyDisposition(state, body);
+  return disposition === COPILOT_DISPOSITION.CHANGES_RECOMMENDED
+    || disposition === COPILOT_DISPOSITION.NEEDS_CLOSER_LOOK
+    || disposition === COPILOT_DISPOSITION.UNRECOGNIZED;
+}
 const GATE_REVIEW_NAMES = new Set(["draft_gate", "pre_approval_gate"]);
 // `review` is a RECOGNIZED gate header that carries no draft/pre-approval
 // evidence by design. Recognizing it lets
@@ -700,6 +767,7 @@ export function summarizeCopilotReviews(reviews, { headSha, draftGateResetAtMs }
   let hasPendingReviewOnCurrentHead = false;
   let hasSubmittedReviewOnCurrentHead = false;
   let latestSubmittedReviewOnCurrentHeadAt = null;
+  let hasBodyFindingOnCurrentHead = false;
   let completedCopilotReviewRounds = 0;
 
   for (const review of effectiveReviews) {
@@ -722,9 +790,18 @@ export function summarizeCopilotReviews(reviews, { headSha, draftGateResetAtMs }
 
     if (SUBMITTED_REVIEW_STATES.has(state)) {
       hasSubmittedReviewOnCurrentHead = true;
-      const submittedAt = typeof review?.submittedAt === "string" ? review.submittedAt : null;
+      const submittedAt = typeof review?.submittedAt === "string"
+        ? review.submittedAt
+        : (typeof review?.submitted_at === "string" ? review.submitted_at : null);
       if (submittedAt !== null && (latestSubmittedReviewOnCurrentHeadAt === null || submittedAt > latestSubmittedReviewOnCurrentHeadAt)) {
         latestSubmittedReviewOnCurrentHeadAt = submittedAt;
+        hasBodyFindingOnCurrentHead = copilotReviewBodySignalsChanges(state, review?.body);
+      } else if (submittedAt !== null && submittedAt === latestSubmittedReviewOnCurrentHeadAt) {
+        // Equal-timestamp tie on the same head: fail toward surfacing so array
+        // order never silently drops a finding when two reviews share a timestamp.
+        hasBodyFindingOnCurrentHead = hasBodyFindingOnCurrentHead || copilotReviewBodySignalsChanges(state, review?.body);
+      } else if (submittedAt === null && latestSubmittedReviewOnCurrentHeadAt === null) {
+        hasBodyFindingOnCurrentHead = hasBodyFindingOnCurrentHead || copilotReviewBodySignalsChanges(state, review?.body);
       }
     }
   }
@@ -740,5 +817,6 @@ export function summarizeCopilotReviews(reviews, { headSha, draftGateResetAtMs }
     hasPendingReviewOnCurrentHead,
     hasSubmittedReviewOnCurrentHead,
     latestSubmittedReviewOnCurrentHeadAt,
+    hasBodyFindingOnCurrentHead,
   };
 }

package/src/github/issue-ops.mjs

@@ -4,6 +4,7 @@ import { runChild as defaultRunChild } from "../cli/primitives.mjs";
 import { parseJsonText } from "./review-threads.mjs";
 import { parseRepoSlug } from "./repo-slug.mjs";
 import { guardCommentBodyNoIssuePrIds } from "./comment-id-guard.mjs";
+import { assertGithubWriteStubbedInTestMode } from "./test-mode-write-guard.mjs";
 
 /**
  * Core `gh issue` operations, extracted from the thin CLI wrappers under
@@ -88,6 +89,7 @@ export async function resolveCreateBody(options) {
 }
 
 export async function createIssue(options, { env = process.env, ghCommand = "gh", run = defaultRunChild } = {}) {
+  assertGithubWriteStubbedInTestMode(run, "issue create", { env });
   const body = await resolveCreateBody(options);
   if (typeof body !== "string" || body.trim().length === 0) {
     const source = options.bodyFile !== undefined ? `--body-file ${options.bodyFile}` : "--body";
@@ -182,6 +184,7 @@ export function buildStateChangeArgs(options) {
 }
 
 export async function editIssue(options, { env = process.env, ghCommand = "gh", run = defaultRunChild } = {}) {
+  assertGithubWriteStubbedInTestMode(run, "issue edit/close", { env });
   const { args, edited } = await buildEditArgs(options);
   // Skip the edit call entirely when --state is the only change requested —
   // `gh issue edit` with no field flags errors ("no changed fields").
@@ -227,6 +230,7 @@ export async function resolveCommentBody(options) {
 }
 
 export async function commentIssue(options, { env = process.env, ghCommand = "gh", run = defaultRunChild } = {}) {
+  assertGithubWriteStubbedInTestMode(run, "issue comment", { env });
   const body = await resolveCommentBody(options);
   // ISSUE/PR-ID GUARD (#1731): a generated comment body must never emit a raw
   // issue/PR id (fail-closed unless explicitly allowlisted). `allowedRefs` is

package/src/github/repo-slug.mjs

@@ -83,10 +83,33 @@ export function dedupeRepoSlugOptions(options) {
   }
   return uniqueOptions;
 }
+// Parses a git remote URL into an <owner/name> slug, but only for github.com
+// remotes. The URI form (scheme://[user@]host[:port]/path) is checked before
+// the scp form (host:path), because the scp regex also matches URIs like
+// https://... — checking scp first would misparse the host out of the scheme.
+function parseGitHubRemoteSlug(url) {
+  let host, path;
+  const uri = url.match(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+)$/);
+  const scp = url.match(/^(?:[^@/]+@)?([^/:]+):(.+)$/);
+  if (uri) {
+    host = uri[1];
+    path = uri[2];
+  } else if (scp) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    return null;
+  }
+  if (host.toLowerCase() !== "github.com") return null;
+  const seg = path.match(/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  if (!seg) return null;
+  return `${seg[1]}/${seg[2]}`;
+}
+
 /**
  * Auto-detect <owner/name> from `git remote get-url origin`.
  * Returns the slug string on success, or null when detection fails
- * (no origin remote, not a git repo, or unparseable URL).
+ * (no origin remote, not a git repo, non-github.com host, or unparseable URL).
  * Does NOT throw — callers should add their own context-specific error messages.
  */
 export function detectRepoSlug(cwd) {
@@ -96,9 +119,7 @@ export function detectRepoSlug(cwd) {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
     }).trim();
-    const match = url.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
-    if (!match) return null;
-    return `${match[1]}/${match[2]}`;
+    return parseGitHubRemoteSlug(url);
   } catch {
     return null;
   }

package/src/github/test-mode-write-guard.mjs

@@ -0,0 +1,81 @@
+/**
+ * Fail-closed test-mode guard for GitHub WRITE helpers.
+ *
+ * A GitHub write helper (issue/PR create/edit/close/comment/merge) must never
+ * reach a live GitHub write path from a test. The real incident: an unstubbed
+ * `bun run verify` drove a dedup test's followUpDraft through
+ * applyFollowUpIssues -> ensureFollowUpIssue -> createIssue and FILED A REAL
+ * ISSUE against the repo. The DI stub seam existed; the test simply did not
+ * thread it, and nothing failed closed to stop the live write.
+ *
+ * This guard is TEST-MODE ONLY. In production (`NODE_ENV !== "test"`) it is a
+ * no-op — it never changes production write behavior (non-goal: no production
+ * behavior change; no general network sandbox). It only asserts, when a test is
+ * running, that the write is stubbed by one of the two sanctioned seams:
+ *
+ * Test mode is derived from the EXECUTING PROCESS's own env (`process.env`),
+ * never from the write-target `env` a caller passes in. A caller can build a
+ * sparse `env` (e.g. `{ GH_TOKEN }` with no `NODE_ENV`) to shape the `gh`
+ * child's environment; if that sparse env decided test mode, it could turn
+ * the guard off from under a test simply by omitting `NODE_ENV`. Reading the
+ * real process env instead makes that impossible: a caller-supplied env can
+ * never disable the guard.
+ *
+ *   (a) In-process DI seam: the helper's `run`/`runChild` was replaced with a
+ *       stub (e.g. `makeGhMock`), so it is no longer the live child-exec seam.
+ *   (b) Process-boundary seam: a subprocess test installed a fake `gh` on PATH
+ *       (`writeGhStub`) and attests it via `DEV_LOOPS_GH_STUB` in the child env.
+ *
+ * Anything else in test mode fails closed at the call site, before any network
+ * call, with an actionable error naming both seams.
+ */
+
+import { runChild as liveRunChild } from "../cli/primitives.mjs";
+
+/**
+ * Env var a process-boundary gh stub sets to attest that `gh` itself is a stub
+ * (set automatically by the `writeGhStub` test helper). Only consulted in test
+ * mode, so it is not a production escape hatch.
+ */
+export const GH_STUB_ATTESTATION_ENV = "DEV_LOOPS_GH_STUB";
+
+/**
+ * True when `run` is the live child-exec seam — i.e. NO in-process DI stub was
+ * injected. `null`/`undefined` (a helper with no run seam, e.g. the spawn-based
+ * create-pr path) is treated as live too, so it fails closed rather than open.
+ * @param {unknown} run
+ */
+export function isLiveExecutor(run) {
+  return run == null || run === liveRunChild;
+}
+
+/**
+ * Assert a GitHub write is stubbed when running under a test. No-op unless the
+ * EXECUTING PROCESS is in test mode (`processEnv.NODE_ENV === "test"`) — never
+ * decided by the caller-supplied write-target `env`, so a sparse `env` (e.g.
+ * missing `NODE_ENV`) cannot bypass the guard. Throws (code
+ * `GH_WRITE_UNSTUBBED_IN_TEST`) when the write would reach the live path with
+ * neither sanctioned stub seam present.
+ *
+ * @param {unknown} run - the helper's `run`/`runChild` seam (omit for spawn-only
+ *   helpers with no in-process seam).
+ * @param {string} op - human-readable op name, e.g. `"issue create"`.
+ * @param {{ env?: NodeJS.ProcessEnv, processEnv?: NodeJS.ProcessEnv }} [opts]
+ *   `env` is the write-target env (consulted only for the stub attestation);
+ *   `processEnv` (defaults to `process.env`, injectable for tests) is the
+ *   real executing process's env and is the sole source of test-mode.
+ */
+export function assertGithubWriteStubbedInTestMode(run, op, { env = process.env, processEnv = process.env } = {}) {
+  if (processEnv?.NODE_ENV !== "test") return; // production / non-test: never guards
+  if (!isLiveExecutor(run)) return; // (a) in-process DI stub injected
+  if (processEnv?.[GH_STUB_ATTESTATION_ENV] || env?.[GH_STUB_ATTESTATION_ENV]) return; // (b) process-boundary gh stub
+  throw Object.assign(
+    new Error(
+      `GitHub write helper "${op}" was called in test mode without an injected stub — ` +
+        `refusing to reach a live GitHub write path (a test must never mutate the real repo). ` +
+        `Inject the in-process DI seam (pass { run } / { runChild }, e.g. makeGhMock) or stub gh ` +
+        `at the process boundary (writeGhStub, which sets ${GH_STUB_ATTESTATION_ENV}). See issue 2216.`,
+    ),
+    { code: "GH_WRITE_UNSTUBBED_IN_TEST" },
+  );
+}