@infinitedusky/indusk-mcp 1.44.0 → 1.44.2

package/extensions/worktree/scripts/preflight.sh

@@ -61,55 +61,19 @@ if [[ ! -f "$CONFIG_FILE" ]]; then
 	exit 1
 fi
 
-# Reject preflighting the trunk — preflight is a feature-branch concept.
-if [[ "$SLUG" == "$REPO" ]]; then
+# One resolution surface — the root and every declared worktrees dir, exact
+# match first, `-<slug>` suffix as fallback, ambiguity refused by name — the
+# same resolver behind `wt` (workbench-trust-fixes, F5). The private root-only
+# scan that stood here could not see a declared worktrees dir and carried its
+# own reserved-name list, already drifted from the shared one.
+WORKTREE_PATH="$(_wt_resolve_target "$SLUG")" || exit 1
+TRUNK_DIR="$(_wt_resolve_trunk_dir "$REPO")" || exit 1
+# Reject preflighting the trunk — preflight is a feature-branch concept. By
+# resolved path: under a declared `path` the trunk's basename is not the name.
+if [[ "$(cd "$WORKTREE_PATH" && pwd -P)" == "$(cd "$TRUNK_DIR" && pwd -P)" ]]; then
 	echo "Error: preflight cannot target the trunk; pick a worktree slug" >&2
 	exit 1
 fi
-
-# Slug resolution (single-pass against workbench root; same as wt.sh).
-_is_reserved_name() {
-	case "$1" in
-		.indusk | .claude | .vscode | .cursor | node_modules | dist | build | .git | .next | scripts | env) return 0 ;;
-		*) return 1 ;;
-	esac
-}
-
-exact_paths=()
-suffix_paths=()
-for entry in "$WORKBENCH_ROOT"/*; do
-	[[ -d "$entry" ]] || continue
-	name="$(basename "$entry")"
-	_is_reserved_name "$name" && continue
-	# Skip the trunk symlink — preflight is for feature worktrees.
-	[[ "$name" == "$REPO" ]] && continue
-	if [[ "$name" == "$SLUG" ]]; then
-		exact_paths+=("$entry")
-	elif [[ "$name" == *"-$SLUG" ]]; then
-		suffix_paths+=("$entry")
-	fi
-done
-
-candidate_paths=()
-if [[ ${#exact_paths[@]} -gt 0 ]]; then
-	candidate_paths=("${exact_paths[@]}")
-elif [[ ${#suffix_paths[@]} -gt 0 ]]; then
-	candidate_paths=("${suffix_paths[@]}")
-fi
-
-if [[ ${#candidate_paths[@]} -eq 0 ]]; then
-	echo "Error: no worktree matching slug '$SLUG' at $WORKBENCH_ROOT" >&2
-	exit 1
-fi
-if [[ ${#candidate_paths[@]} -gt 1 ]]; then
-	echo "Error: multiple worktrees match slug '$SLUG':" >&2
-	for p in "${candidate_paths[@]}"; do
-		printf '  %s\n' "$(basename "$p")" >&2
-	done
-	exit 1
-fi
-
-WORKTREE_PATH="${candidate_paths[0]}"
 WORKTREE_NAME="$(basename "$WORKTREE_PATH")"
 
 # Read preflight[] from config. Each entry: { name, command, when? }.

package/extensions/worktree/scripts/refresh-worktree.sh

@@ -36,7 +36,9 @@ export WORKBENCH_ROOT
 REPO="$(_resolve_workbench_repo "${REPO_ARG:-}")"
 
 SIBLING_PARENT="$(_read_repos_root)"
-CLIENT_ROOT="$SIBLING_PARENT/$REPO"
+# Trunk from CONFIG (declared `path` honored) — workbench-trust-fixes, F5.
+CLIENT_ROOT="$(_wt_resolve_trunk_dir "$REPO")"
+CLIENT_ROOT_REAL="$(cd "$CLIENT_ROOT" && pwd -P)"
 
 CONFIG_FILE="$WORKBENCH_ROOT/.indusk/worktree-configs/${REPO}.json"
 if [[ ! -f "$CONFIG_FILE" ]]; then
@@ -54,8 +56,10 @@ refresh_one() {
 		echo "  SKIP: $slug — directory not found"
 		return 0
 	fi
-	if [[ "$slug" == "$REPO" ]]; then
-		return 0 # trunk symlink, not a worktree
+	# The trunk is excluded by resolved path, not by name — under a declared
+	# `path` its basename need not be the repo name.
+	if [[ "$(cd "$worktree_path" && pwd -P)" == "$CLIENT_ROOT_REAL" ]]; then
+		return 0 # the trunk checkout, not a worktree
 	fi
 	# Check this is actually a git worktree (has a .git file pointing into
 	# the canonical clone's worktrees/ dir).
@@ -65,7 +69,7 @@ refresh_one() {
 	fi
 
 	echo ""
-	echo "Refreshing: $slug"
+	echo "Refreshing: $slug ($worktree_path)"
 
 	local gitdir
 	gitdir="$(cd "$worktree_path" && git rev-parse --git-dir)"
@@ -180,13 +184,17 @@ refresh_one() {
 }
 
 if [[ "$ARG" == "--all" ]]; then
-	echo "Refreshing all worktrees in $WORKBENCH_ROOT (excluding the trunk symlink)..."
-	for d in "$WORKBENCH_ROOT"/*/; do
-		[[ -d "$d" ]] || continue
-		refresh_one "${d%/}"
-	done
+	echo "Refreshing all worktrees in $WORKBENCH_ROOT and its declared worktrees dirs (excluding the trunk)..."
+	while IFS= read -r d; do
+		[[ -n "$d" ]] && refresh_one "$d"
+	done < <(_wt_list_worktree_dirs)
 else
-	refresh_one "$WORKBENCH_ROOT/$ARG"
+	# One resolution surface for a slug — the root and every declared worktrees
+	# dir, exact match first, `-<slug>` suffix as fallback, ambiguity refused by
+	# name — the resolver behind `wt` (workbench-trust-fixes, F5). A slug that
+	# resolves to nothing is an error, not a SKIP that exits 0.
+	target="$(_wt_resolve_target "$ARG")" || exit 1
+	refresh_one "$target"
 fi
 
 echo ""

package/extensions/worktree/scripts/setup-worktree.sh

@@ -66,11 +66,19 @@ if [[ -z "$SIBLING_PARENT" ]]; then
 	exit 1
 fi
 
-CLIENT_ROOT="$SIBLING_PARENT/$REPO"
-if [[ ! -d "$CLIENT_ROOT/.git" ]]; then
-	echo "Error: $CLIENT_ROOT is not a git repo" >&2
+# The trunk checkout from CONFIG — declared `path` honored — through the one
+# resolver `wt` has used since 1.42.0. Building "$SIBLING_PARENT/$REPO" by
+# name failed outright on any repo declared at a path (workbench-trust-fixes, F5).
+CLIENT_ROOT="$(_wt_resolve_trunk_dir "$REPO")"
+if [[ ! -e "$CLIENT_ROOT/.git" ]]; then
+	echo "Error: $CLIENT_ROOT is not a git checkout" >&2
 	exit 1
 fi
+# A declared worktrees location applies whether or not the TS wrapper passed
+# --worktrees-dir — this script is also run directly.
+if [[ -z "$WORKTREES_DIR" ]]; then
+	WORKTREES_DIR="$(_wt_declared_worktrees_dir "$REPO")"
+fi
 
 CONFIG_FILE="$WORKBENCH_ROOT/.indusk/worktree-configs/${REPO}.json"
 if [[ ! -f "$CONFIG_FILE" ]]; then

package/extensions/worktree/templates/worktree-config.template.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "../../config.schema.json",
+	"$schema": "./config.schema.json",
 	"trunk_branch": "main",
 	"base_branch": "main",
 	"post_create": ["pnpm install"],

package/hooks/_hook-paths.js

@@ -4,9 +4,15 @@
  * The 4 hooks (eval-trigger, check-catchup, check-gates, validate-impl-structure)
  * each used to carry their own copy of `findProjectRoot()` that walked up looking
  * for `.indusk/`. In workbench-shaped projects that landed at the workbench root
- * — which is NOT a git repo. Hooks that then tried `git rev-parse` against that
- * path silently bailed. The eval pipeline never fired on numero_workbench for
- * 2 months. See `.indusk/planning/workbench-mode-rail-integrity/`.
+ * — which, before 1.37.0, was not a git repo. Hooks that then tried
+ * `git rev-parse` against that path silently bailed. The eval pipeline never
+ * fired on numero_workbench for 2 months. See
+ * `.indusk/planning/workbench-mode-rail-integrity/`.
+ *
+ * Since versioned-workbench (1.37.0) the root IS a git repo, and the failure
+ * inverted: the walk-up finds the workbench and would attribute a commit to
+ * its history of plan documents. `resolveStateAndGitPaths` refuses that
+ * (workbench-trust-fixes, F2).
  *
  * The fix: hooks need TWO paths, not one.
  *
@@ -139,11 +145,11 @@ function findGitPathFromWorkbenchConfig(statePath) {
 	} catch {
 		return null;
 	}
-	const declared = declaredRepoNames(config);
+	const declared = declaredRepos(config);
 	// Ambiguous: more than one repo could hold this commit. Refuse rather than
 	// attribute it to whichever happens to be declared first.
 	if (declared.length !== 1) return null;
-	const candidate = resolve(statePath, declared[0]);
+	const candidate = resolve(statePath, declared[0].dir);
 	if (!existsSync(candidate)) return null;
 	try {
 		return realpathSync(candidate);
@@ -153,16 +159,18 @@ function findGitPathFromWorkbenchConfig(statePath) {
 }
 
 /**
- * The declared repo names, singular reduced into plural.
+ * The declared repos, singular reduced into plural, each with the directory
+ * its checkout lives in relative to the workbench root.
  *
- * Deliberate port of `readWorkbenchRepos` in `src/lib/worktree/repos.ts` —
- * hooks are plain JS and cannot import the TS module. Change both together.
- * Name-only: the hook never needs remotes.
+ * Deliberate port of `readWorkbenchRepos` + `repoDir` in
+ * `src/lib/worktree/repos.ts` — hooks are plain JS and cannot import the TS
+ * module. Change both together. Name and dir only: the hook never needs
+ * remotes.
  *
  * @param {unknown} config
- * @returns {string[]}
+ * @returns {{ name: string, dir: string }[]}
  */
-function declaredRepoNames(config) {
+function declaredRepos(config) {
 	const worktree = config && typeof config === "object" ? config.worktree : null;
 	if (!worktree || typeof worktree !== "object") return [];
 	const raw = Array.isArray(worktree.repos)
@@ -171,7 +179,7 @@ function declaredRepoNames(config) {
 			? [{ name: worktree.wrapped_repo }]
 			: [];
 	const seen = new Set();
-	const names = [];
+	const repos = [];
 	for (const entry of raw) {
 		if (!entry || typeof entry !== "object") continue;
 		const name = entry.name;
@@ -184,9 +192,34 @@ function declaredRepoNames(config) {
 			!name.includes("\\");
 		if (!clean || seen.has(name)) continue;
 		seen.add(name);
-		names.push(name);
+		// Where the checkout lives: the declared `path`, else the name.
+		// Deliberate port of `repoDir` in `src/lib/worktree/repos.ts` — every
+		// other surface reads a repo at its declared path, and looking it up by
+		// name here returned null (dark) for any repo declared elsewhere (F2).
+		repos.push({ name, dir: usableRelPath(entry.path) ?? name });
+	}
+	return repos;
+}
+
+function declaredRepoNames(config) {
+	return declaredRepos(config).map((r) => r.name);
+}
+
+/** A relative path with no empty, `.` or `..` segment; else null. Port of `isUsableRelPath`. */
+function usableRelPath(value) {
+	if (typeof value !== "string") return null;
+	const v = value.trim();
+	if (v === "" || v.startsWith("/") || v.includes("\\")) return null;
+	if (v.split("/").some((s) => s === "" || s === "." || s === "..")) return null;
+	return v;
+}
+
+function samePath(a, b) {
+	try {
+		return realpathSync(a) === realpathSync(b);
+	} catch {
+		return a === b;
 	}
-	return names;
 }
 
 /**
@@ -211,7 +244,9 @@ export function declaredReposAt(statePath) {
  * Resolve both the InDusk state path and the git path for a given cwd. Either
  * may be null:
  *   - `statePath` is null if no `.indusk/` directory exists in any ancestor.
- *   - `gitPath` is null if `cwd` is not inside any git repo.
+ *   - `gitPath` is null if `cwd` is not inside any git repo — or if the only
+ *     repo found is the workbench itself and the declaration cannot name one
+ *     code repo. Then `refusal` says why, for the caller to surface.
  *
  * The two paths may be the SAME (single-repo mode) or DIFFERENT (workbench mode).
  * Callers must use the right path for the right operation:
@@ -219,11 +254,37 @@ export function declaredReposAt(statePath) {
  *   - Git operations (`git rev-parse --short HEAD`, etc.) → use `gitPath`
  *
  * @param {string} cwd
- * @returns {{ statePath: string | null, gitPath: string | null }}
+ * @returns {{ statePath: string | null, gitPath: string | null, refusal: string | null, attribution: string | null }}
  */
 export function resolveStateAndGitPaths(cwd) {
 	const statePath = findStatePath(cwd);
 	let gitPath = findGitPathFromCwd(cwd);
+	let refusal = null;
+	let attribution = null;
+	// A versioned workbench root IS a git repo, so the walk-up finds it. Its
+	// history is plan documents, and it CAN receive commits (a checkoff, a
+	// brief) — so when the repo found is the workbench itself, the commit may
+	// have gone to it or to the code repo, and the event cannot say which
+	// (`event.cwd` is the session cwd, not the subprocess's). With one repo
+	// declared, whichever has the NEWER HEAD received the commit; a tie or a
+	// missing code repo prefers the code repo, the 1.31.10 behaviour
+	// (workbench-trust-fixes F2, refined by falsification A20 — "never the
+	// workbench" was the wrong invariant). With several declared, refuse. A
+	// flat project declares no repos and keeps gitPath === statePath.
+	if (
+		gitPath &&
+		statePath &&
+		declaredReposAt(statePath).length > 0 &&
+		samePath(gitPath, statePath)
+	) {
+		const workbenchRoot = gitPath;
+		const codeRepo = findGitPathFromWorkbenchConfig(statePath);
+		if (declaredReposAt(statePath).length === 1) {
+			({ gitPath, attribution } = attributeRootCommit(workbenchRoot, codeRepo));
+		} else {
+			gitPath = null;
+		}
+	}
 	if (!gitPath) {
 		// Workbench-mode fallback (1.31.10). When event.cwd is the workbench
 		// root, `git rev-parse` against it fails because the workbench root
@@ -233,6 +294,57 @@ export function resolveStateAndGitPaths(cwd) {
 		// from the workbench root (the dominant operating model on Numero
 		// and any future FDE engagement).
 		gitPath = findGitPathFromWorkbenchConfig(statePath);
+		if (!gitPath) {
+			const names = declaredReposAt(statePath);
+			if (names.length > 1) {
+				refusal =
+					`eval: a commit made from ${cwd} could belong to any of the ${names.length} repos this workbench declares (${names.join(", ")}), ` +
+					"and attributing it to the wrong one is indistinguishable from attributing it right. Refusing to score it. " +
+					"Commit from inside the repo the change lives in, or run the evaluator there.";
+			}
+		}
+	}
+	return { statePath, gitPath, refusal, attribution };
+}
+
+/**
+ * Which repository received a commit made from a session sitting at the
+ * workbench root, when exactly one code repo is declared: the one whose HEAD
+ * is newer. A tie, or a code repo not yet on disk, goes to the code repo — the
+ * 1.31.10 behaviour, and the safer error (a plan-document commit scored as
+ * code is odd; a code commit never scored is a gap in the rail).
+ *
+ * @param {string} workbenchRoot
+ * @param {string | null} codeRepo
+ * @returns {{ gitPath: string, attribution: string }}
+ */
+function attributeRootCommit(workbenchRoot, codeRepo) {
+	if (!codeRepo) {
+		return {
+			gitPath: workbenchRoot,
+			attribution: "the workbench (the one declared repo is not on disk)",
+		};
+	}
+	if (headCommitTime(workbenchRoot) > headCommitTime(codeRepo)) {
+		return {
+			gitPath: workbenchRoot,
+			attribution: "the workbench (newer HEAD than the declared repo)",
+		};
+	}
+	return { gitPath: codeRepo, attribution: "the declared repo (newer or equal HEAD)" };
+}
+
+/** HEAD's committer timestamp (seconds), or -1 when the repo has no commits or is not one. */
+function headCommitTime(dir) {
+	try {
+		const out = execFileSync("git", ["log", "-1", "--format=%ct"], {
+			cwd: dir,
+			encoding: "utf-8",
+			stdio: ["ignore", "pipe", "ignore"],
+		});
+		const n = Number.parseInt(out.trim(), 10);
+		return Number.isFinite(n) ? n : -1;
+	} catch {
+		return -1;
 	}
-	return { statePath, gitPath };
 }

package/hooks/_impl-phases.js

@@ -0,0 +1,88 @@
+/**
+ * The one hook-side walk from an impl body to its phases and checkbox items.
+ *
+ * Deliberate port of the TS phase/item walk in `src/lib/impl-parser.ts` (what
+ * `getPhaseCompletion` reads). Hooks are plain JS and cannot import the TS
+ * module, so the rule lives in two places — this file and that one — and they
+ * must change together.
+ *
+ * Hook-local (`_`-prefixed): imported by hooks, never registered as one, so it
+ * needs no settings entry — but it must exist in `.claude/hooks/` or every
+ * importer dies at load. `globSync("*.js")` copies it on init and update.
+ *
+ * **One definition, shared by `check-gates.js` and `gate-reminder.js`, pinned
+ * by A24.** Each carried its own copy of this walk until workbench-trust-fixes'
+ * cleanup phase; gate-reminder's was the same walk minus the item text, and it
+ * recognized one gate kind fewer. That is the shape `_trajectory-parser.js`
+ * was extracted from — two copies that had already diverged without anything
+ * failing — and the reason this repo extracts hook-side parsers at two rather
+ * than waiting for three.
+ *
+ * Phases are two sequences ordered by document position (`Test Phase N`,
+ * `Build Phase N`; `Phase N` means build phase N). Fenced blocks are content,
+ * not structure: a deferral may carry a test body with checkbox- and
+ * heading-shaped lines. Items under a `Forward Intelligence` heading are
+ * notes, not work, and are excluded.
+ */
+
+import {
+	FORWARD_INTELLIGENCE_HEADING,
+	fencedLineMask,
+	gateHeading,
+	parsePhaseHeading,
+} from "./_impl-headings.js";
+import { stripFrontmatter } from "./_trajectory-parser.js";
+
+const GATE_KINDS = gateHeading("(Verification|OTel|Context|Document)");
+
+/**
+ * @param {string} content — an impl document, with or without frontmatter
+ * @returns {{ kind: "test" | "build", number: number, ordinal: number, name: string,
+ *   items: { checked: boolean, text: string, gate: string }[] }[]}
+ */
+export function parseImplPhases(content) {
+	const lines = stripFrontmatter(content).split("\n");
+	const fenced = fencedLineMask(lines);
+	const phases = [];
+	let currentPhase = null;
+	let currentGateType = "implementation";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (fenced[i]) continue;
+		const phaseMatch = parsePhaseHeading(line);
+		if (phaseMatch) {
+			if (currentPhase) phases.push(currentPhase);
+			currentPhase = {
+				number: phaseMatch.number,
+				kind: phaseMatch.kind,
+				ordinal: phases.length,
+				name: phaseMatch.name,
+				items: [],
+			};
+			currentGateType = "implementation";
+			continue;
+		}
+		// [1] is the phase number, [2] the gate kind — see gateHeading().
+		const gateMatch = line.match(GATE_KINDS);
+		if (gateMatch) {
+			currentGateType = gateMatch[2].toLowerCase();
+			continue;
+		}
+		if (FORWARD_INTELLIGENCE_HEADING.test(line)) {
+			currentGateType = "_fi";
+			continue;
+		}
+		if (currentPhase && currentGateType !== "_fi") {
+			const itemMatch = line.match(/^-\s+\[([ x])\]\s+(.*)/);
+			if (itemMatch) {
+				currentPhase.items.push({
+					checked: itemMatch[1] === "x",
+					text: itemMatch[2].trim(),
+					gate: currentGateType,
+				});
+			}
+		}
+	}
+	if (currentPhase) phases.push(currentPhase);
+	return phases;
+}

package/hooks/check-gates.js

@@ -12,15 +12,8 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { resolveStateAndGitPaths } from "./_hook-paths.js";
-import {
-	FORWARD_INTELLIGENCE_HEADING,
-	fencedLineMask,
-	gateHeading,
-	parsePhaseHeading,
-	phaseExists,
-	phaseOrdinal,
-	phaseSequence,
-} from "./_impl-headings.js";
+import { phaseExists, phaseOrdinal, phaseSequence } from "./_impl-headings.js";
+import { parseImplPhases as parsePhases } from "./_impl-phases.js";
 import { parseTrajectoryFromBody, stripFrontmatter } from "./_trajectory-parser.js";
 
 // Read hook input from stdin
@@ -168,67 +161,7 @@ const WORKFLOW_GATES = Object.fromEntries(
 	]),
 );
 
-// Parse phases from the NEW content (after edit) and OLD content (before edit)
-function parsePhases(content) {
-	// Strip frontmatter
-	const fmMatch = content.match(/^---\n[\s\S]*?\n---\n/);
-	const body = fmMatch ? content.slice(fmMatch[0].length) : content;
-
-	const lines = body.split("\n");
-	// Fenced blocks are content, not structure — a deferral may carry the
-	// deferred test's body, which contains checkbox- and heading-shaped lines.
-	const fenced = fencedLineMask(lines);
-	const phases = [];
-	let currentPhase = null;
-	let currentGateType = "implementation";
-
-	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-		const line = lines[lineIndex];
-		if (fenced[lineIndex]) continue;
-
-		const phaseMatch = parsePhaseHeading(line);
-		if (phaseMatch) {
-			if (currentPhase) phases.push(currentPhase);
-			currentPhase = {
-				number: phaseMatch.number,
-				kind: phaseMatch.kind,
-				// Position in the document — the only thing that orders two
-				// independently-numbered sequences.
-				ordinal: phases.length,
-				name: phaseMatch.name,
-				items: [],
-			};
-			currentGateType = "implementation";
-			continue;
-		}
-
-		// [1] is the phase number, [2] the gate kind — see gateHeading().
-		const gateMatch = line.match(gateHeading("(Verification|OTel|Context|Document)"));
-		if (gateMatch) {
-			currentGateType = gateMatch[2].toLowerCase();
-			continue;
-		}
-
-		// Forward intelligence — skip
-		if (line.match(FORWARD_INTELLIGENCE_HEADING)) {
-			currentGateType = "_fi";
-			continue;
-		}
-
-		if (currentPhase && currentGateType !== "_fi") {
-			const itemMatch = line.match(/^-\s+\[([ x])\]\s+(.*)/);
-			if (itemMatch) {
-				currentPhase.items.push({
-					checked: itemMatch[1] === "x",
-					text: itemMatch[2].trim(),
-					gate: currentGateType,
-				});
-			}
-		}
-	}
-	if (currentPhase) phases.push(currentPhase);
-	return phases;
-}
+// The phase/item walk is shared with gate-reminder.js — one definition, pinned by A24.
 
 /** Name a phase unambiguously: the two sequences share their digits. */
 function phaseLabel(kind, number) {

package/hooks/eval-trigger.js

@@ -91,7 +91,12 @@ if (cliSource !== null || drainPending) {
 // early syslog calls used raw `cwd` and silently created stray `.indusk/`
 // directories inside wrapped repos — exactly the "no lingering app-level
 // state" pattern this plan is fixing.
-const { statePath: resolvedStatePath, gitPath } = resolveStateAndGitPaths(cwd);
+const {
+	statePath: resolvedStatePath,
+	gitPath,
+	refusal: attributionRefusal,
+	attribution,
+} = resolveStateAndGitPaths(cwd);
 const statePath = resolvedStatePath ?? cwd;
 
 if (cliSource !== null || drainPending) {
@@ -156,7 +161,7 @@ const evalConfig = readEvalConfig(statePath);
 
 syslog(
 	statePath,
-	`statePath: ${statePath}, gitPath: ${gitPath ?? "(none)"}, eval.enabled: ${evalConfig.enabled}`,
+	`statePath: ${statePath}, gitPath: ${gitPath ?? "(none)"}, eval.enabled: ${evalConfig.enabled}${attribution ? ` — attributed to ${attribution}` : ""}`,
 );
 
 // Check if eval is disabled
@@ -194,9 +199,10 @@ if (drainPending) {
 }
 
 // Get the current commit ID. Runs against gitPath, not statePath — in
-// workbench mode the two differ (statePath = workbench root, NOT a git repo;
-// gitPath = wrapped repo or worktree). Pre-1.31.7 ran against statePath
-// and bailed on every commit in workbench-shaped projects.
+// workbench mode the two differ (statePath = workbench root, whose own git
+// history is plan documents; gitPath = the declared code repo or a worktree).
+// Pre-1.31.7 ran against statePath and bailed on every commit in
+// workbench-shaped projects; post-1.37.0 it would have scored the workbench.
 let changeId = changeIdArg ?? undefined;
 if (!changeId && gitPath) {
 	try {
@@ -212,6 +218,26 @@ if (!changeId && gitPath) {
 	}
 }
 if (!changeId) {
+	if (!gitPath && attributionRefusal) {
+		// Refuse VISIBLY. system.log is where the eval rail talks to itself; a
+		// commit the evaluator silently declined to score looks, to the
+		// session, exactly like one it scored. stdout JSON is the one channel a
+		// PostToolUse hook has to the model at exit 0 (workbench-trust-fixes,
+		// F2 / A8) — and only there: in CLI and drain modes stdout is a
+		// terminal or a parent process, not the model (falsification A21).
+		syslog(statePath, `refusing to attribute — ${attributionRefusal}`);
+		if (cliSource === null && !drainPending) {
+			console.info(
+				JSON.stringify({
+					hookSpecificOutput: {
+						hookEventName: "PostToolUse",
+						additionalContext: attributionRefusal,
+					},
+				}),
+			);
+		}
+		process.exit(0);
+	}
 	syslog(
 		statePath,
 		gitPath