@lannguyensi/harness 0.41.0 → 0.42.0

package/dist/policy-packs/builtin/post-merge-gate-runtime.js

@@ -0,0 +1,290 @@
+// Shared runtime constants + helpers for the `post-merge-gate` policy pack.
+//
+// The pack itself (`post-merge-gate.ts`) only emits hooks + the audit-copy
+// instructions. The actual enforcement lives in two CLI verbs — `harness
+// pack hook post-merge-gate-record` (producer, PostToolUse) and `harness
+// pack hook post-merge-gate` (blocker, PreToolUse) — both under `src/cli/
+// pack/`. This module is the small shared surface they pull from: the
+// merged-tag format, the curated mutation matcher, the escape allowlist,
+// and a couple of small payload/command helpers.
+//
+// Binding decisions this module encodes (see
+// .ai/runs/2026-07-23-post-merge-gate/03-decisions.md, BINDING):
+//
+//   - The merged fact is keyed on an EXACT branch-tip sha match, not
+//     ancestry. `gh pr merge` merges the PR on the remote side; it does
+//     NOT move the local branch's tip. So the local tip observed by the
+//     PostToolUse producer, right after a successful merge, IS the exact
+//     commit that got merged. The blocker denies only while the current
+//     tip still equals that recorded value — a new local commit moves the
+//     tip and the gate falls silent (deliberate: that is legitimate
+//     continued work, not stale post-merge state), and a recycled branch
+//     name with a different tip never matches either. No expiry /
+//     freshness window is needed as a result (squash-fest, offline).
+//
+//   - Deny scope v1 is a CURATED command list (git commit / add / push /
+//     merge / rebase / cherry-pick / revert / reset / stash pop|apply, gh
+//     pr create / merge), not "every Bash call" — mirrors
+//     branch-protection.ts's documented v1 scope-cut (see its "Out of
+//     scope" section). Read-only git (status/log/diff/branch) and
+//     unrelated shell are never touched.
+//
+//   - The escape allowlist is checked FIRST in the blocker, unconditionally,
+//     before manifest load or any ledger query — see hook-post-merge-gate.ts.
+//     This module only supplies the matcher; the ordering guarantee lives
+//     in the hook, not here.
+//
+//   - Fails OPEN (allows) when the ledger is unreachable, unlike
+//     branch-protection's fail-closed posture: without the ledger,
+//     "merged" and "not merged" are indistinguishable, and fail-closed
+//     here would block every feature branch's git history forever. This
+//     pack is advisory-strength against a hostile agent, same honesty as
+//     the other `requires.ledger_tag`-style gates
+//     (docs/okf/evidence-ledger-trust-boundary.md).
+import { findGitEntry, resolveCommonDir, resolveOriginHeadBase } from "../../runtime/git-context.js";
+export const PACK_NAME = "post-merge-gate";
+/**
+ * Content prefix the producer writes and the blocker substring-matches.
+ * The full recorded content is
+ * `${MERGED_TAG_PREFIX}:${repo}:${branch}:${sha}[ pr:<n>] at:<iso>`; the
+ * blocker only ever tests for the `${MERGED_TAG_PREFIX}:${repo}:${branch}:
+ * ${sha}` prefix (an exact 40-hex-char sha), so the trailing `pr:` / `at:`
+ * tokens are audit decoration, not part of the match key.
+ */
+export const MERGED_TAG_PREFIX = "post-merge-gate:merged";
+/** The exact substring the blocker tests ledger entries for. */
+export function mergedTagMatchKey(repo, branch, sha) {
+    return `${MERGED_TAG_PREFIX}:${repo}:${branch}:${sha}`;
+}
+/** Build the full fact content the producer writes (match key + audit decoration). */
+export function buildMergedTagContent(args) {
+    const prPart = args.pr ? ` pr:${args.pr}` : "";
+    return `${mergedTagMatchKey(args.repo, args.branch, args.sha)}${prPart} at:${args.whenIso}`;
+}
+/**
+ * Producer trigger: does this Bash command look like a `gh pr merge`
+ * invocation? Same anchoring convention as `DEFAULT_PUSH_BASH_RE`
+ * (solution-acceptance-runtime.ts): tolerates a leading `cd … &&`, inline
+ * `VAR=val` assignments, and chaining. Known gap, same class as that
+ * regex's own documented residual: a heredoc / `sh -c` / `eval`
+ * indirection defeats this match before the producer ever runs — not
+ * attempted to close here (the MCP merge path, `pull_requests_merge`, is
+ * the other documented gap; see the pack's instructions.md).
+ */
+export const GH_PR_MERGE_BASH_RE = /(?:^|\n|;|\||&&|\()\s*(?:\w+=\S+\s+)*gh\s+pr\s+merge\b/;
+/**
+ * Blocker deny-scope v1 (03-decisions.md): the curated mutation command
+ * list. Deliberately NOT "every Bash command" — read-only git
+ * (status/log/diff/branch) and unrelated shell stay unaffected. Same
+ * anchoring convention as `GH_PR_MERGE_BASH_RE`.
+ */
+export const CURATED_MUTATION_BASH_RE = /(?:^|\n|;|\||&&|\()\s*(?:\w+=\S+\s+)*(?:git(?:\s+-C\s+\S+)?\s+(?:commit|add|push|merge|rebase|cherry-pick|revert|reset|stash\s+(?:pop|apply))\b|gh\s+pr\s+(?:create|merge)\b)/;
+/**
+ * Escape allowlist, git verbs (03-decisions.md): the exact recovery path
+ * the deny message recommends, plus read-only stash inspection. Checked
+ * BEFORE the curated-mutation match and before any manifest/ledger access
+ * — see hook-post-merge-gate.ts for the ordering guarantee.
+ */
+export const ESCAPE_GIT_BASH_RE = /(?:^|\n|;|\||&&|\()\s*(?:\w+=\S+\s+)*git(?:\s+-C\s+\S+)?\s+(?:switch\b|checkout\b|pull\b|fetch\b|branch\s+-(?:d|D)\b|stash\s+(?:list|show)\b)/;
+/**
+ * Escape allowlist, harness verbs (03-decisions.md): any invocation of
+ * harness's own CLI (recovery commands like `harness session-start
+ * branch-check`, diagnostics, a future self-check) always passes,
+ * regardless of spelling — mirrors the `npx` / absolute-path /
+ * `./node_modules/.bin` robustness the `deny-kill-switch-bash` regex in
+ * `src/cli/init/templates.ts` already established for the same class of
+ * bypass concern.
+ */
+export const ESCAPE_HARNESS_BASH_RE = /(?:^|\n|;|\||&&|\()\s*(?:\w+=\S+\s+)*(?:npx\s+|\S*\/)?harness\b/;
+/** True when `command` matches any escape pattern. Checked first, unconditionally. */
+export function isEscapeCommand(command) {
+    return ESCAPE_GIT_BASH_RE.test(command) || ESCAPE_HARNESS_BASH_RE.test(command);
+}
+/** True when `command` matches the curated v1 deny-scope. */
+export function isCuratedMutationCommand(command) {
+    return CURATED_MUTATION_BASH_RE.test(command);
+}
+/**
+ * Defensive `tool_output.exit_code` reader for the PostToolUse Bash
+ * payload — Contract A. Returns `null` on ANY shape other than a plain
+ * finite number — missing field, a differently-named variant, a string,
+ * etc. — so the producer's "no fact on anything but a confirmed success"
+ * rule (03-decisions.md) degrades to "no fact" rather than guessing.
+ *
+ * PAYLOAD REALITY (2026-07, follow-up to 03-decisions.md): live
+ * verification against a real Claude Code 2.1.218 native install (a
+ * `claude -p --settings` dump-hook capture, 19/19 fired events) found NO
+ * `tool_output` field at all — the field is `tool_response`, shaped
+ * `{ stdout, stderr, interrupted, isImage, noOutputExpected }` with no
+ * exit-code equivalent (see `tests/fixtures/post-merge-gate/
+ * real-posttooluse-payload-2.1.218.json`, a verbatim capture). The
+ * `tool_output.stdout/stderr/exit_code` shape this function reads
+ * evidently describes a DIFFERENT — newer, or differently-shimmed —
+ * Claude Code contract than 2.1.218's, not a documentation error to
+ * "fix" here: Contract A is left exactly as it was (any install that
+ * DOES send `tool_output.exit_code` still works unchanged), and Contract
+ * B below is the fallback that makes the producer fire on 2.1.218 at
+ * all. See `resolveMergeConfirmation`.
+ */
+export function extractExitCode(toolOutput) {
+    if (typeof toolOutput !== "object" || toolOutput === null)
+        return null;
+    const ec = toolOutput["exit_code"];
+    return typeof ec === "number" && Number.isFinite(ec) ? ec : null;
+}
+// Matches the first bare integer following `gh pr merge` — audit
+// decoration only (the deny/allow decision never depends on this).
+const PR_NUMBER_RE = /gh\s+pr\s+merge\b[^\n;|&]*?(\d+)\b/;
+/** Best-effort PR number extraction from a `gh pr merge` command string. */
+export function extractPrNumber(command) {
+    const m = PR_NUMBER_RE.exec(command);
+    return m ? m[1] : null;
+}
+/**
+ * Contract B success-text matcher (2.1.218 payload-reality follow-up).
+ * `gh pr merge`'s own past-tense confirmation sentence, verbatim across
+ * all three merge methods.
+ *
+ * SOURCE (verified against the installed `gh` binary, v2.94.0,
+ * `pkg/cmd/pr/merge/merge.go` lines 369-376): the success line is built
+ * as `infof("%s %s pull request %s#%d (%s)", icon, action,
+ * ghrepo.FullName(baseRepo), pr.Number, pr.Title)` — i.e. the repo
+ * FULLNAME sits directly between "pull request" and the bare `#<n>`,
+ * GLUED to the `#` with no space (`%s#%d`, not `%s #%d`):
+ *
+ *   ✓ Squashed and merged pull request owner/repo#65 (Some title)
+ *   ✓ Rebased and merged pull request owner/repo#65 (Some title)
+ *   ✓ Merged pull request owner/repo#65 (Some title)
+ *
+ * `infof` writes to `gh`'s STDERR (the informational-message channel,
+ * distinct from `gh`'s own stdout, which is reserved for machine-
+ * consumable output) — another reason this matcher tests the CONCATENATED
+ * `stdout`+`stderr`, not stdout alone. `icon` is a bare `✓` (or `!` for
+ * warnings) with no ANSI color codes when `gh` detects a non-TTY output
+ * stream, which a hook-captured Bash hijacks it into.
+ *
+ * `[^\s#]*` between "pull request" and `#` accepts BOTH that real
+ * `owner/repo#<n>` shape AND a bare `#<n>` (no fullname) — the latter is
+ * not `gh`'s actual current wording but is accepted defensively as a
+ * documentation-shape / future-`gh`-version tolerance, at zero matching-
+ * surface cost (repo fullnames never contain whitespace or `#`, so the
+ * character class cannot itself widen what counts as a match beyond
+ * "some non-space run immediately before the PR number").
+ *
+ * Still deliberately narrow overall (conservative — false negatives are
+ * the safe direction here, false positives are not):
+ *   - exact past-tense phrase, not a bare "merged" substring — excludes
+ *     `gh pr merge --auto`'s pending text (real wording, same source
+ *     file: "Pull request owner/repo#65 will be automatically merged via
+ *     squash when all requirements are met" — capitalized standalone
+ *     "Pull request", no "Squashed/Rebased and merged" or standalone
+ *     "Merged" immediately precedes it), and excludes the already-merged
+ *     warning (real wording: "Pull request owner/repo#65 was already
+ *     merged" — word order is reversed: "Pull request ... was already
+ *     merged", not "Merged pull request ...").
+ *   - case-sensitive, matching gh's own capitalization exactly (no `/i`)
+ *     — narrower matching surface, same conservative direction.
+ *   - `\b` word boundaries on both ends so a partial-word coincidence
+ *     (e.g. a hypothetical "ReMerged") cannot match.
+ *
+ * KNOWN GAP (documented, not attempted to close here): this is coupled
+ * to `gh`'s current wording. A future `gh` release that rephrases its
+ * success sentence makes this matcher — and therefore the whole
+ * Contract-B path — silently, fail-safely inert (no fact written, same
+ * as any other unmatched shape; never a false "merged" record). See the
+ * pack's instructions.md / docs/policy-packs/post-merge-gate.md "Known
+ * gaps" for the operator-facing verification path.
+ */
+export const GH_MERGE_SUCCESS_RE = /\b(?:Squashed and merged|Rebased and merged|Merged)\s+pull request\s+[^\s#]*#(\d+)\b/;
+/**
+ * Contract B confirmation: does `toolResponse` carry a real Claude Code
+ * 2.1.218-shaped Bash result (`{ stdout, stderr, interrupted, ... }`)
+ * whose `stdout`+`stderr` contain a `gh pr merge` success sentence?
+ *
+ * `interrupted` must be the LITERAL boolean `false` — missing, `true`,
+ * or any other value all fail closed (no match), the same fail-safe
+ * direction as Contract A's exit_code check. `stdout`/`stderr` default
+ * to `""` when absent or non-string (never throws), and are joined with
+ * a newline before matching so a phrase cannot accidentally form by
+ * concatenating the tail of one stream with the head of the other.
+ */
+export function matchGhMergeSuccessText(toolResponse) {
+    if (typeof toolResponse !== "object" || toolResponse === null)
+        return { matched: false };
+    const tr = toolResponse;
+    if (tr["interrupted"] !== false)
+        return { matched: false };
+    const stdout = typeof tr["stdout"] === "string" ? tr["stdout"] : "";
+    const stderr = typeof tr["stderr"] === "string" ? tr["stderr"] : "";
+    const combined = `${stdout}\n${stderr}`;
+    const match = GH_MERGE_SUCCESS_RE.exec(combined);
+    if (!match)
+        return { matched: false };
+    return { matched: true, pr: match[1] ?? null };
+}
+/**
+ * Dual-contract merge confirmation (2.1.218 payload-reality follow-up).
+ * Tries Contract A (`tool_output.exit_code`, unchanged) first; falls
+ * back to Contract B (`tool_response` + a matching `gh` success
+ * sentence) only when Contract A yields no verdict at all.
+ *
+ * BINDING ordering decision — Contract A wins whenever it resolves to
+ * ANY definite verdict, success OR failure: a well-formed, non-zero
+ * `exit_code` is Contract A's own explicit failure signal and short-
+ * circuits WITHOUT consulting Contract B, so a coincidental gh success
+ * phrase sitting in a sibling `tool_response` field (the hypothetical
+ * "both present" shape) can never override an authoritative failure.
+ * Contract B is consulted only when `exit_code` is entirely unresolvable
+ * (`extractExitCode` returns `null` — missing field, wrong shape, or the
+ * field genuinely absent as on 2.1.218).
+ */
+export function resolveMergeConfirmation(toolOutput, toolResponse, command) {
+    const exitCode = extractExitCode(toolOutput);
+    if (exitCode === 0) {
+        return {
+            confirmed: true,
+            contract: "exit_code",
+            pr: extractPrNumber(command),
+            reason: "tool_output.exit_code === 0 (Contract A)",
+        };
+    }
+    if (exitCode !== null) {
+        return {
+            confirmed: false,
+            contract: "none",
+            pr: null,
+            reason: `tool_output.exit_code is ${exitCode}, not 0 (Contract A reports failure; Contract B not consulted)`,
+        };
+    }
+    const ghSuccess = matchGhMergeSuccessText(toolResponse);
+    if (ghSuccess.matched) {
+        return {
+            confirmed: true,
+            contract: "gh_success_text",
+            pr: extractPrNumber(command) ?? ghSuccess.pr,
+            reason: "tool_response carries a confirmed gh merge success sentence (Contract B)",
+        };
+    }
+    return {
+        confirmed: false,
+        contract: "none",
+        pr: null,
+        reason: "no confirming tool_output.exit_code (Contract A) and no matching gh merge success text in tool_response (Contract B)",
+    };
+}
+/**
+ * Best-effort default-branch name for the deny message's `git switch
+ * <default>` line. Offline, reusing the same `origin/HEAD` resolution
+ * `harness record review --base` uses (now shared via
+ * `runtime/git-context.ts`, see that module's header). Returns `null`
+ * when `cwd` is not in a git work tree, or the repo has no resolvable
+ * `origin/HEAD` (e.g. no remote) — the caller falls back to a generic
+ * placeholder in that case; this is advisory text, never a gate input.
+ */
+export function resolveDefaultBranchName(cwd) {
+    const gitDir = findGitEntry(cwd)?.gitDir;
+    if (!gitDir)
+        return null;
+    return resolveOriginHeadBase(resolveCommonDir(gitDir));
+}
+//# sourceMappingURL=post-merge-gate-runtime.js.map

package/dist/policy-packs/builtin/post-merge-gate-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-merge-gate-runtime.js","sourceRoot":"","sources":["../../../src/policy-packs/builtin/post-merge-gate-runtime.ts"],"names":[],"mappings":"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"}

package/dist/policy-packs/builtin/post-merge-gate.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import type { PolicyPack, PolicyUx } from "../../schema/index.js";
+import { type Runtime } from "../runtime.js";
+import type { PackContribution } from "../types.js";
+import { PACK_NAME } from "./post-merge-gate-runtime.js";
+export { PACK_NAME };
+/**
+ * Zod schema for this pack's `config:` block. Strict by design so
+ * typo'd keys fail loud at lint time (mirrors sibling packs). `ux` is
+ * the only operator-tunable key today — the curated mutation list and
+ * escape allowlist are fixed in v1 (03-decisions.md); a config override
+ * for either can land as a follow-up if operators need it.
+ */
+export declare const configSchema: z.ZodObject<{
+    ux: z.ZodOptional<z.ZodObject<{
+        cannot: z.ZodString;
+        required: z.ZodArray<z.ZodString, "many">;
+        run: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        cannot: string;
+        required: string[];
+        run: string[];
+    }, {
+        cannot: string;
+        required: string[];
+        run: string[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    ux?: {
+        cannot: string;
+        required: string[];
+        run: string[];
+    } | undefined;
+}, {
+    ux?: {
+        cannot: string;
+        required: string[];
+        run: string[];
+    } | undefined;
+}>;
+/**
+ * Shipped default `config.ux` for this pack. Canonical source for the
+ * `full` init template and `harness pack reseed` (mirrors
+ * branch-protection's `defaultUx`): a future wording fix lands here once
+ * and reaches both a fresh `harness init --template full` and an
+ * operator running `harness pack reseed post-merge-gate` against an
+ * already-installed manifest. `${DEFAULT_BRANCH}` is always populated by
+ * the blocker (falling back to the literal placeholder `<default-branch>`
+ * when it cannot resolve `origin/HEAD`), never left as an unresolved
+ * template var.
+ */
+export declare function defaultUx(): PolicyUx;
+export declare function resolve(pack: PolicyPack, runtime?: Runtime): {
+    contribution: PackContribution;
+    warnings: string[];
+};

package/dist/policy-packs/builtin/post-merge-gate.js

@@ -0,0 +1,291 @@
+// Builtin Policy Pack: `post-merge-gate`.
+//
+// Catches the "kept working on a branch after it was already merged"
+// pattern: an agent (or operator) merges a PR via `gh pr merge`, then
+// keeps committing / pushing / rebasing on the SAME local checkout
+// without switching back to the default branch first — silently
+// building on top of a commit that is already integrated, which either
+// produces a confusing duplicate-merge PR or loses the new work off the
+// side of a branch nobody looks at again.
+//
+// Mechanics, mirroring `branch-protection` (see that pack's header for
+// the identical two-hook shape):
+//
+//   1. PostToolUse producer (`harness pack hook post-merge-gate-record`)
+//      watches every Bash call and, ONLY when the command matched
+//      `gh pr merge` AND the merge is CONFIRMED, writes a
+//      `post-merge-gate:merged:<repo>:<branch>:<sha>` fact (plus PR
+//      number and timestamp, audit-only) to the evidence ledger — `sha`
+//      being the LOCAL branch tip observed right after the merge, which
+//      is the exact commit that got merged (`gh pr merge` merges on the
+//      remote side; it does not move the local tip). Confirmation is
+//      DUAL-CONTRACT (payload-reality follow-up, 2026-07): a `tool_output.
+//      exit_code === 0` (Contract A) is NOT reliably present — live
+//      verification against a real Claude Code 2.1.218 install found the
+//      PostToolUse Bash payload carries no `tool_output` / exit-code field
+//      at all, only `tool_response` (`{ stdout, stderr, interrupted,
+//      isImage, noOutputExpected }`) — so a `gh pr merge` success sentence
+//      match against `tool_response` (Contract B) is the fallback that
+//      makes the producer fire at all on that install. See
+//      `resolveMergeConfirmation` in post-merge-gate-runtime.ts for the
+//      exact dual-contract / "Contract A wins" ordering. Payload reads are
+//      defensive throughout: an unexpected shape on either contract writes
+//      nothing.
+//
+//   2. PreToolUse blocker (`harness pack hook post-merge-gate`) checks a
+//      CURATED list of history-mutating commands (see
+//      post-merge-gate-runtime.ts for the exact list) and denies them
+//      when the CURRENT branch tip still equals a recorded merged tip
+//      for this repo+branch — an exact sha match, not ancestry, so a new
+//      commit (moving the tip) or a recycled branch name (a different
+//      tip) both fall silently outside the gate. An ESCAPE ALLOWLIST
+//      (git switch/checkout/pull/fetch, git branch -d/-D, git stash
+//      list/show, any `harness ...` command) is checked FIRST, before
+//      any manifest load or ledger query, so the recovery path can never
+//      be starved by an unrelated failure.
+//
+// Fails OPEN when the ledger is unreachable (unlike branch-protection's
+// fail-closed posture): without the ledger, "merged" and "not merged"
+// are indistinguishable, and fail-closed here would block ordinary git
+// history work on every branch whenever grounding-mcp hiccups. This pack
+// is advisory-strength against a hostile agent, like the other
+// `requires.ledger_tag`-style gates (docs/okf/evidence-ledger-trust-boundary.md);
+// see post-merge-gate-runtime.ts's header for the full rationale.
+//
+// No auto-switch: the blocker only ever recommends the recovery commands
+// in its deny message, never runs them (operator/agent decides).
+//
+// Enabled per-installation via `harness pack add post-merge-gate`. The
+// `full` init template wires it with `enabled: false` (opt-in — a fresh,
+// higher-risk gate; see templates.ts for the rationale), unlike
+// branch-protection's default-enabled precedent.
+//
+// Claude Code only in v1 (no Codex adapter): both hooks match on the
+// `Bash` tool name and classify by command text, a mechanism that has
+// no established Codex-adapter parity yet (mirrors `solution-acceptance`,
+// which ships with no Codex variant either). `resolve()` warns if wired
+// under `runtime: "codex"`.
+import { z } from "zod";
+import { PolicyUxSchema } from "../../schema/policies.js";
+import { DEFAULT_RUNTIME } from "../runtime.js";
+import { CURATED_MUTATION_BASH_RE, ESCAPE_GIT_BASH_RE, ESCAPE_HARNESS_BASH_RE, GH_MERGE_SUCCESS_RE, GH_PR_MERGE_BASH_RE, MERGED_TAG_PREFIX, PACK_NAME, } from "./post-merge-gate-runtime.js";
+export { PACK_NAME };
+/**
+ * Zod schema for this pack's `config:` block. Strict by design so
+ * typo'd keys fail loud at lint time (mirrors sibling packs). `ux` is
+ * the only operator-tunable key today — the curated mutation list and
+ * escape allowlist are fixed in v1 (03-decisions.md); a config override
+ * for either can land as a follow-up if operators need it.
+ */
+export const configSchema = z
+    .object({
+    ux: PolicyUxSchema.optional(),
+})
+    .strict();
+/**
+ * Shipped default `config.ux` for this pack. Canonical source for the
+ * `full` init template and `harness pack reseed` (mirrors
+ * branch-protection's `defaultUx`): a future wording fix lands here once
+ * and reaches both a fresh `harness init --template full` and an
+ * operator running `harness pack reseed post-merge-gate` against an
+ * already-installed manifest. `${DEFAULT_BRANCH}` is always populated by
+ * the blocker (falling back to the literal placeholder `<default-branch>`
+ * when it cannot resolve `origin/HEAD`), never left as an unresolved
+ * template var.
+ */
+export function defaultUx() {
+    return {
+        cannot: "You cannot run ${TOOL_NAME} on branch ${BRANCH} yet — its current tip was already merged.",
+        required: [
+            "a branch tip that is not sitting at an already-merged commit (switch off `${BRANCH}`, or move its tip with a new commit)",
+        ],
+        run: [
+            "git switch ${DEFAULT_BRANCH}",
+            "git pull --ff-only",
+            "git branch -d ${BRANCH}  # optional cleanup",
+        ],
+    };
+}
+const HOOK_NAME_PREFIX = `policy-pack:${PACK_NAME}`;
+const PRODUCER_COMMAND = "harness pack hook post-merge-gate-record";
+const BLOCKER_COMMAND = "harness pack hook post-merge-gate";
+function buildHooks() {
+    return [
+        {
+            name: `${HOOK_NAME_PREFIX}:post-tool-use`,
+            event: "PostToolUse",
+            match: "Bash",
+            command: PRODUCER_COMMAND,
+            blocking: false,
+            budget_ms: 5000,
+            description: "Producer: on a `gh pr merge` Bash call that exited 0, write `post-merge-gate:merged:<repo>:<branch>:<sha>` to the evidence ledger. Non-blocking; any failure just leaves the gate silent for that merge.",
+        },
+        {
+            name: `${HOOK_NAME_PREFIX}:pre-tool-use`,
+            event: "PreToolUse",
+            match: "Bash",
+            command: BLOCKER_COMMAND,
+            blocking: "hard",
+            budget_ms: 5000,
+            description: "Blocker: deny curated history-mutating Bash commands (git commit/add/push/merge/rebase/cherry-pick/revert/reset/stash pop|apply, gh pr create/merge) when the current branch tip matches a recorded merged tip. An escape allowlist (git switch/checkout/pull/fetch, git branch -d/-D, git stash list/show, any `harness ...` command) is checked first, unconditionally. Fails open when the ledger is unreachable.",
+        },
+    ];
+}
+function buildInstructions(pack, runtime) {
+    const description = pack.description?.trim() ?? "";
+    return `# Policy Pack: ${PACK_NAME}
+
+> Operator audit copy. This pack denies curated history-mutating Bash
+> commands on a branch whose tip was already merged via \`gh pr merge\`,
+> closing the loop on the "kept working on a merged branch" incident
+> pattern.
+
+## Runtime
+
+${runtime}${runtime === "codex" ? " (UNSUPPORTED — see \"Known gaps\" below; both hooks assume the Claude Code Bash tool surface)" : ""}
+
+## Trigger + signals
+
+1. \`PostToolUse\` producer (\`${PRODUCER_COMMAND}\`, blocking: false) on
+   \`Bash\`: matches \`${GH_PR_MERGE_BASH_RE.source}\` against the command
+   text. Fires only on a CONFIRMED merge, via either of two contracts
+   (dual-contract, payload-reality follow-up — real Claude Code shims
+   have shipped both shapes in the wild):
+   - **Contract A** — \`tool_output.exit_code\` is the number \`0\`.
+   - **Contract B** — \`tool_response\` is present with
+     \`interrupted === false\` AND its \`stdout\`+\`stderr\` contain \`gh pr
+     merge\`'s own past-tense success sentence: \`${GH_MERGE_SUCCESS_RE.source}\`
+     (covers all three merge methods: Squashed / Rebased / plain Merged).
+     Verified against the installed \`gh\` binary (v2.94.0,
+     \`pkg/cmd/pr/merge/merge.go\` lines 369-376): the line is built as
+     \`infof("%s %s pull request %s#%d (%s)", icon, action,
+     ghrepo.FullName(baseRepo), pr.Number, pr.Title)\` — the repo
+     fullname sits between "pull request" and the PR number, GLUED to
+     \`#\` with no space (e.g. \`Squashed and merged pull request
+     owner/repo#65 (title)\`), and \`infof\` writes to \`gh\`'s STDERR,
+     which is why this contract checks the concatenated
+     \`stdout\`+\`stderr\`, not stdout alone.
+   Contract A wins whenever it resolves to ANY definite verdict, success
+   OR failure — a well-formed non-zero \`exit_code\` short-circuits
+   WITHOUT consulting Contract B. Contract B is tried only when Contract
+   A's \`exit_code\` is entirely unresolvable (missing field, wrong
+   shape, or genuinely absent — as verified live against Claude Code
+   2.1.218, whose real PostToolUse Bash payload carries NO \`tool_output\`
+   / no exit-code field at all, only \`tool_response\`; the
+   \`tool_output.exit_code\` shape appears to describe a different,
+   possibly newer, Claude Code contract). Any other shape on either
+   contract writes NO fact; fail-safe against a false "merged" record.
+   On a confirmed match, records
+   \`${MERGED_TAG_PREFIX}:<repo>:<branch>:<sha>[ pr:<n>] at:<iso>\` to the
+   evidence ledger, where \`<sha>\` is the LOCAL branch tip observed right
+   after the merge (the exact commit that got merged — \`gh pr merge\`
+   merges remote-side and does not itself move the local tip). \`<n>\`
+   prefers extraction from the \`gh pr merge\` command itself, falling
+   back to the number captured out of the Contract-B success sentence.
+
+2. \`PreToolUse\` blocker (\`${BLOCKER_COMMAND}\`, blocking: hard) on
+   \`Bash\`: checked in this order —
+   a. **Escape allowlist first, unconditionally** (before any manifest
+      load or ledger query): \`${ESCAPE_GIT_BASH_RE.source}\` OR
+      \`${ESCAPE_HARNESS_BASH_RE.source}\` — always allowed.
+   b. **Curated mutation match**: \`${CURATED_MUTATION_BASH_RE.source}\`
+      — commands that don't match this pass through untouched.
+   c. **Ledger check**: denies only when the current branch tip exactly
+      equals a recorded \`${MERGED_TAG_PREFIX}:<repo>:<branch>:<sha>\` fact
+      for this repo+branch. A new commit moves the tip (gate falls
+      silent — that's legitimate continued work); a recycled branch name
+      has a different tip (no false positive). No freshness window is
+      needed as a result.
+
+## Escape hatches
+
+- **Recovery path** (named in every deny message): \`git switch
+  <default-branch>\`, then \`git pull --ff-only\`, then optionally
+  \`git branch -d <branch>\` to clean up the merged local branch.
+- **Read-only / inspection commands** (\`git switch\`/\`checkout\`,
+  \`pull\`/\`fetch\`, \`branch -d\`/\`-D\`, \`stash list\`/\`show\`, and any
+  \`harness ...\` invocation) always pass, independent of ledger
+  reachability — the gate can never itself become the reason the
+  recovery path is unavailable.
+
+## Known gaps (documented, not attempted in v1)
+
+- **MCP merge path**: \`mcp__agent-tasks__pull_requests_merge\` is NOT a
+  producer trigger. Only the \`gh pr merge\` Bash surface is watched;
+  merges done through the agent-tasks MCP tool leave no
+  \`${MERGED_TAG_PREFIX}\` fact, so the blocker never fires for that
+  branch. Left as a documented gap (spec decision), not silently faked
+  as covered.
+- **Regex-vs-shell-eval residual**: same class of gap as every other
+  \`bash_match\`-style matcher in this codebase (branch-protection,
+  solution-acceptance, the kill-switch deny policies) — a heredoc,
+  \`sh -c\`, \`eval\`, or similarly indirected command defeats the TRIGGER
+  match before either hook ever runs. Not attempted to close here.
+- **Curated scope, not every Bash command**: destructive non-git
+  commands on a just-merged branch (e.g. hand-editing files outside
+  git's own history primitives) are out of v1 scope, mirroring
+  branch-protection's documented scope-cut.
+- **Chained-escape bypass**: escape-first is checked against the WHOLE
+  command string, not per-clause, so a curated mutation chained with an
+  escape verb (e.g. \`git commit -am x && git switch main\`) is fully
+  ALLOWED — the escape match wins for the entire compound command. Same
+  accepted class as the regex-vs-shell-eval residual above (\`eval\`,
+  heredoc, \`sh -c\`); not attempted to close here, and deliberate: the
+  alternative (per-clause splitting) would need a real shell parser.
+- **Inverted trust-boundary residual**: a merged fact written by any
+  means OTHER than the producer (e.g. directly via
+  \`mcp__agent-grounding__ledger_add\`) that happens to exactly match the
+  CURRENT \`repo:branch:sha\` triple denies curated mutations on that
+  branch — recoverable via any escape command or by making a new commit
+  (which moves the tip and the fact no longer matches). A fact for a
+  different \`repo:branch:sha\` triple is inert; this is availability-only
+  (a spurious deny, always escapable), never a privilege the agent gains,
+  consistent with docs/okf/evidence-ledger-trust-boundary.md.
+- **Contract B is coupled to \`gh\`'s current wording**: \`${GH_MERGE_SUCCESS_RE.source}\`
+  matches \`gh\`'s OWN past-tense success sentence, verbatim, as verified
+  against the installed \`gh\` v2.94.0 source
+  (\`pkg/cmd/pr/merge/merge.go\` lines 369-376). A future \`gh\` release
+  that rephrases that sentence makes
+  Contract B silently, FAIL-SAFELY inert on installs that never send
+  \`tool_output.exit_code\` (Contract A stays available wherever it's
+  actually sent) — never a false "merged" record, but the blocker also
+  never fires for that merge. Not attempted to close here (would need a
+  \`gh\` wire-format contract, e.g. \`--json\`, out of this pack's Bash-text
+  matching design). Verification path after upgrading \`gh\`: merge a
+  throwaway PR and check for a fresh \`${MERGED_TAG_PREFIX}\` fact in the
+  evidence ledger.
+- **No Codex adapter**: see "Runtime" above.
+
+## Fail posture
+
+Fails OPEN (allows, with a stderr warning) when the evidence ledger is
+unreachable — deliberately the OPPOSITE of branch-protection's
+fail-closed posture, because without the ledger "merged" and "not
+merged" are indistinguishable, and fail-closed here would block ordinary
+git history work on every branch whenever grounding-mcp hiccups. This
+pack is advisory-strength against a hostile agent, like the other
+\`requires.ledger_tag\`-style gates
+(docs/okf/evidence-ledger-trust-boundary.md).
+
+## Pack metadata
+${description ? `\n> ${description.replace(/\n/g, "\n> ")}\n` : ""}
+- Source: \`builtin\`
+- Pack: \`${PACK_NAME}\`
+- Runtime: \`${runtime}\`
+`;
+}
+export function resolve(pack, runtime = DEFAULT_RUNTIME) {
+    const hooks = buildHooks();
+    const files = [
+        {
+            relativePath: `policy-packs/${PACK_NAME}/instructions.md`,
+            content: buildInstructions(pack, runtime),
+        },
+    ];
+    const warnings = [];
+    if (runtime === "codex") {
+        warnings.push(`policy_packs[${pack.name}]: post-merge-gate has no Codex adapter in v1; hooks are wired assuming the Claude Code Bash tool surface and will not fire correctly under a Codex runtime.`);
+    }
+    return { contribution: { hooks, files }, warnings };
+}
+//# sourceMappingURL=post-merge-gate.js.map

package/dist/policy-packs/builtin/post-merge-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-merge-gate.js","sourceRoot":"","sources":["../../../src/policy-packs/builtin/post-merge-gate.ts"],"names":[],"mappings":"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"}