@sabaiway/agent-workflow-kit 14.33.0 → 14.34.0

package/tools/hide-footprint.mjs

@@ -14,9 +14,9 @@
 // Decisions (plan D1–D16): one managed fence, re-derived wholesale → re-run is byte-identical (zero
 // diff); tracked → ASK; present-but-untracked high-risk (generic names) → ASK; everything else → HIDE;
 // asks are excluded from the block unless opted in via `--include` (an asks-only, traversal/glob-free
-// path). Add-local-first, then DETECT + REPORT the residual legacy global block — removal is the
-// explicit, ASK-gated `--remove-global` (prints a restorable backup), never a default (an arbitrary
-// host's OTHER hidden repo may rely on the same root-anchored global lines). Windows is supported (text
+// path). Add-local-first, then DETECT + REPORT the residual legacy global block — the hide never writes
+// the global file; removal is the `--remove-global` mode alone, the advisor's footprint-global item
+// (prints a restorable backup; another of the host's hidden repos may rely on the same lines). Windows is supported (text
 // edit; forward-slash patterns; CRLF preserved via EOL detection). Dependency-free, Node >= 22.
 
 import {
@@ -90,10 +90,13 @@ const canonicalize = (pattern) => {
 // canonicalize alone misses glob children, so the consented line would be dropped → a silent un-hide.
 const recognizeHideRule = (pattern) => canonicalize(pattern) ?? (matchesKnownGlob(pattern) ? normalizeSlashes(pattern) : null);
 
-// Slash-tolerant membership in the HISTORICAL global set.
-const historicalMatch = (pattern) => {
+// The historical lines any repository's own ignore may carry: a removal plan needs one kit-specific line besides them.
+const GENERIC_GLOBAL_PATHS = new Set(['/AGENTS.md', '/CLAUDE.md', '/docs/ai/', '/docs/plans/', '/.claude/skills/']);
+
+// Slash-tolerant membership in a global path set (the HISTORICAL one by default).
+const historicalMatch = (pattern, set = HISTORICAL_GLOBAL_PATHS) => {
   const p = normalizeSlashes(pattern);
-  return HISTORICAL_GLOBAL_PATHS.has(p) || HISTORICAL_GLOBAL_PATHS.has(`${p}/`) || (p.endsWith('/') && HISTORICAL_GLOBAL_PATHS.has(p.slice(0, -1)));
+  return set.has(p) || set.has(`${p}/`) || (p.endsWith('/') && set.has(p.slice(0, -1)));
 };
 
 // ── EOL + line model ────────────────────────────────────────────────────────────
@@ -144,8 +147,8 @@ const defaultGit = (args, { cwd, env }) => {
 const runGit = (deps, dir, args) => (deps.git ?? defaultGit)(args, { cwd: dir, env: deps.env ?? process.env });
 
 const fsOf = (deps = {}) => ({
-  readFile: deps.readFile ?? ((p) => readFileSync(p, 'utf8')),
-  writeFile: deps.writeFile ?? ((p, c) => writeFileSync(p, c, 'utf8')),
+  readFile: deps.readFile ?? ((p, encoding = 'utf8') => readFileSync(p, encoding)),
+  writeFile: deps.writeFile ?? ((p, c, encoding = 'utf8') => writeFileSync(p, c, encoding)),
   stat: deps.stat ?? statSync,
   readdir: deps.readdir ?? readdirSync,
 });
@@ -362,45 +365,60 @@ const globalExcludesPath = (deps, dir, home) => {
   if (r.status === 1) return null; // unset = NORMAL "nothing to migrate" (not a STOP)
   if (r.status !== 0) throw stop(`git config --get core.excludesFile failed (exit ${r.status}): ${r.stderr.trim()}`);
   const p = r.stdout.trim();
-  return p ? expandTilde(p, home) : null;
+  return p ? resolve(dir, expandTilde(p, home)) : null;
 };
 
-// Detect + REPORT a residual legacy global block; remove ONLY contiguous recognized runs (header +
-// historical paths) and ONLY when removeGlobal — printing the removed lines as a restorable backup.
-export const migrateFromGlobal = (deps, dir, { home, removeGlobal, dryRun }) => {
-  const fsx = fsOf(deps);
-  const gp = globalExcludesPath(deps, dir, home);
-  if (!gp) return { found: false, source: null, removedLines: [], action: 'none' };
-  let content;
+// The pure core over the global file read as latin1: each recognised legacy line goes with its own
+// terminator and every other byte stays; null without one kit-specific line among them.
+export const globalRemovalOf = (text) => {
+  const parts = text.split(/(\r\n|\n|\r)/);
+  const removedLines = [];
+  let after = '';
+  let specific = false;
+  for (let i = 0; i < parts.length; i += 2) {
+    const t = parts[i].trim();
+    const pattern = lineToPattern(parts[i]);
+    const marker = isLegacyGlobalHeader(t) || isAd013Comment(t);
+    if (marker || (pattern && historicalMatch(pattern))) {
+      removedLines.push(parts[i]);
+      specific ||= marker || !historicalMatch(pattern, GENERIC_GLOBAL_PATHS);
+    } else after += parts[i] + (parts[i + 1] ?? '');
+  }
+  return specific ? { removedLines, after } : null;
+};
+
+// The one answer the hide's kept line, the advisor's probe, the danger check and --remove-global read.
+export const planGlobalRemoval = (deps, root, { home }) => {
+  const source = globalExcludesPath(deps, root, home);
+  if (!source) return null;
+  let before;
   try {
-    content = fsx.readFile(gp);
+    before = fsOf(deps).readFile(source, 'latin1');
   } catch (err) {
-    if (err && err.code === 'ENOENT') return { found: false, source: gp, removedLines: [], action: 'none' };
-    throw stop(`cannot read global excludes ${gp} (${err.code ?? 'fs error'})`);
+    if (err && err.code === 'ENOENT') return null;
+    throw stop(`cannot read global excludes ${source} (${err.code ?? 'fs error'})`);
   }
-  const eol = detectEol(content);
-  const lines = splitLines(content);
-  const recognized = (raw) => {
-    const t = raw.trim();
-    if (isLegacyGlobalHeader(t) || isAd013Comment(t)) return true;
-    const pat = lineToPattern(raw);
-    return pat ? historicalMatch(pat) : false;
-  };
-  const kept = [];
-  const removed = [];
-  let i = 0;
-  while (i < lines.length) {
-    if (recognized(lines[i])) {
-      while (i < lines.length && recognized(lines[i])) { removed.push(lines[i]); i += 1; }
-    } else {
-      kept.push(lines[i]);
-      i += 1;
-    }
+  const removal = globalRemovalOf(before);
+  return removal && { source, before, ...removal };
+};
+
+// Detect + REPORT a residual legacy global block; the hide never writes the global file.
+export const migrateFromGlobal = (deps, dir, { home }) => {
+  const plan = planGlobalRemoval(deps, dir, { home });
+  if (!plan) return { found: false, source: null, removedLines: [], action: 'none' };
+  return { found: true, source: plan.source, removedLines: plan.removedLines, action: 'kept' };
+};
+
+// The --remove-global mode: no exclude file read, no local block written; a refused write is the lane's STOP.
+const removeGlobal = (opts, deps) => {
+  const plan = planGlobalRemoval(deps, resolve(opts.dir ?? process.cwd()), { home: deps.home ?? os.homedir() });
+  if (!plan || opts.dryRun) return { plan, action: plan ? 'would-remove' : 'none' };
+  try {
+    fsOf(deps).writeFile(plan.source, plan.after, 'latin1');
+  } catch (err) {
+    throw stop(`cannot write the global excludes ${plan.source} (${err?.code ?? err?.message ?? err}) — the block stays`);
   }
-  if (removed.length === 0) return { found: false, source: gp, removedLines: [], action: 'none' };
-  if (!removeGlobal) return { found: true, source: gp, removedLines: removed, action: 'kept' };
-  if (!dryRun) fsx.writeFile(gp, joinLines(kept, eol));
-  return { found: true, source: gp, removedLines: removed, action: 'removed', backup: removed.join('\n') };
+  return { plan, action: 'removed' };
 };
 
 // ── --include validation (D4 — only an asks[] path; no traversal/glob) ───────────
@@ -452,9 +470,9 @@ export const hideFootprint = (opts = {}, deps = {}) => {
   const fenceBodyLines = fence.state === 'ok' ? lines.slice(fence.startIdx + 1, fence.endIdx) : [];
   const after = fence.state === 'ok' ? lines.slice(fence.endIdx + 1) : [];
 
-  // ── unhide (D12): drop our fence; report/remove the residual global block ──────
+  // ── unhide (D12): drop our fence; report the residual global block ──────
   if (opts.unhide) {
-    const global = migrateFromGlobal(deps, dir, { home, removeGlobal: opts.removeGlobal, dryRun });
+    const global = migrateFromGlobal(deps, dir, { home });
     const newLines = [...before, ...after];
     const newContent = joinLines(newLines, eol);
     const changed = newContent !== content;
@@ -520,8 +538,8 @@ export const hideFootprint = (opts = {}, deps = {}) => {
     throw stop(`hide verification failed — these were written but are not hidden by the project-local exclude: ${notHidden.map((v) => v.path).join(', ')}`);
   }
 
-  // ── then detect/report (or remove) the residual legacy global block (D6) ───────
-  const global = migrateFromGlobal(deps, dir, { home, removeGlobal: opts.removeGlobal, dryRun });
+  // ── then detect + report the residual legacy global block (D6) ─────────────────
+  const global = migrateFromGlobal(deps, dir, { home });
 
   const action = !changed ? 'noop' : fence.state === 'ok' ? 'updated' : 'created';
   return {
@@ -545,29 +563,29 @@ export const hideFootprint = (opts = {}, deps = {}) => {
 
 // ── CLI ───────────────────────────────────────────────────────────────────────────
 
-const USAGE = `usage: hide-footprint [--dir <project>] [--reconcile] [--include=<path>]... [--keep-global | --remove-global] [--unhide] [--dry-run] [--help]
+const USAGE = `usage: hide-footprint [--dir <project>] [--reconcile] [--include=<path>]... [--unhide] [--dry-run] [--help]
+       hide-footprint --remove-global [--dir <project>] [--dry-run]
 
   --dir <project>     the target project (default: cwd)
   --reconcile         upgrade mode — infer visibility first; write zero bytes when VISIBLE, ASK when AMBIGUOUS
   --include=<path>    opt a surfaced ASK path into the hidden set (only an asks[] path; no glob/traversal)
-  --keep-global       keep + report the residual legacy machine-global block (DEFAULT)
-  --remove-global     remove the recognized legacy machine-global block (prints a restorable backup)
-  --unhide            remove the project-local managed block (residual global only with --remove-global)
+  --remove-global     its own mode: remove the recognized legacy machine-global block (prints a restorable backup)
+  --unhide            remove the project-local managed block
   --dry-run           print the plan; change nothing
   --help, -h          this help
 
-Writes ONE managed block in the PROJECT-LOCAL .git/info/exclude (never the machine-global excludes).
+Writes ONE managed block in the PROJECT-LOCAL .git/info/exclude; a residual legacy machine-global block is
+kept and reported, and only --remove-global (the advisor's footprint-global item) removes it.
 Tracked files are never silently un-tracked — the tool prints the \`git rm --cached\` it will not run.`;
 
 const parseArgs = (argv) => {
-  const out = { dir: undefined, reconcile: false, include: [], removeGlobal: false, keepGlobal: false, unhide: false, dryRun: false, help: false, bad: null };
+  const out = { dir: undefined, reconcile: false, include: [], removeGlobal: false, unhide: false, dryRun: false, help: false, bad: null };
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === '--help' || a === '-h') out.help = true;
     else if (a === '--dry-run') out.dryRun = true;
     else if (a === '--reconcile') out.reconcile = true;
     else if (a === '--unhide') out.unhide = true;
-    else if (a === '--keep-global') out.keepGlobal = true;
     else if (a === '--remove-global') out.removeGlobal = true;
     else if (a === '--dir') {
       const next = argv[i + 1];
@@ -580,15 +598,22 @@ const parseArgs = (argv) => {
       else { out.include.push(next); i += 1; }
     } else out.bad = `unknown argument: ${a}`;
   }
-  if (out.keepGlobal && out.removeGlobal) out.bad = '--keep-global and --remove-global are mutually exclusive';
+  if (out.removeGlobal && !out.bad && (out.reconcile || out.unhide || out.include.length)) out.bad = '--remove-global is its own mode — it cannot be combined with --reconcile, --unhide or --include';
   return out;
 };
 
 const fmtGlobal = (g) => {
-  if (!g || g.action === 'none' || g.action === 'skipped') return [];
-  if (g.action === 'kept') return [`  • residual legacy machine-global block in ${g.source} (${g.removedLines.filter((l) => l.trim() && !l.trim().startsWith('#')).length} path line(s)) — KEPT + reported; pass --remove-global to remove (with a printed backup)`];
-  if (g.action === 'removed') return [`  • removed the legacy machine-global block from ${g.source} (backup of ${g.removedLines.length} line(s) printed below)`, ...g.removedLines.map((l) => `      | ${l}`)];
-  return [];
+  if (!g || g.action !== 'kept') return [];
+  return [`  • residual legacy machine-global block in ${g.source} (${g.removedLines.filter((l) => l.trim() && !l.trim().startsWith('#')).length} path line(s)) — KEPT + reported; the advisor's footprint-global item removes it (with a printed backup)`];
+};
+
+const formatRemoval = ({ plan, action }, dryRun) => {
+  const lines = [dryRun ? 'hide-footprint — DRY RUN (no changes)' : 'hide-footprint'];
+  if (action === 'none') return [...lines, '  • no legacy machine-global block to remove'].join('\n');
+  const n = plan.removedLines.length;
+  lines.push(action === 'removed' ? `  • removed the legacy machine-global block from ${plan.source} (backup of ${n} line(s) printed below)`
+    : `  • would remove the legacy machine-global block from ${plan.source} (${n} line(s)):`);
+  return [...lines, ...plan.removedLines.map((l) => `      | ${l}`)].join('\n');
 };
 
 export const formatReport = (r, dryRun) => {
@@ -624,10 +649,11 @@ export const main = (argv = process.argv.slice(2), deps = {}) => {
   if (args.help) { log(USAGE); return 0; }
   if (args.bad) { errlog(args.bad); errlog(USAGE); return 2; }
   try {
-    const result = hideFootprint(
-      { dir: args.dir, dryRun: args.dryRun, reconcile: args.reconcile, include: args.include, removeGlobal: args.removeGlobal, unhide: args.unhide },
-      deps,
-    );
+    if (args.removeGlobal) {
+      log(formatRemoval(removeGlobal({ dir: args.dir, dryRun: args.dryRun }, deps), args.dryRun));
+      return 0;
+    }
+    const result = hideFootprint({ dir: args.dir, dryRun: args.dryRun, reconcile: args.reconcile, include: args.include, unhide: args.unhide }, deps);
     log(formatReport(result, args.dryRun));
     return 0;
   } catch (err) {

package/tools/init-project.mjs

@@ -216,7 +216,7 @@ const previewQueue = async (context, queue) => {
     }
     context.print(result.stdout);
     const tuple = result.stdout.match(/--apply\s+(\S+)/)?.[1];
-    const facts = { ...context.facts, tuple };
+    const facts = { ...context.facts, env: context.spawnEnv, tuple };
     let checkDigest = null;
     if (laneOf(item.variant) === LANE_HARNESS) {
       try {

package/tools/recommendations.mjs

@@ -75,16 +75,19 @@ import { CHECKER_CLAIM, INITIAL_ADOPTION_REASON, SOURCE_SIZE_GATE_ID, classifySo
 // The declared-path resolution + segment containment this item's convergence lane shares with the
 // autonomy render's allowWrite degrade — ONE leaf, so the two answers cannot drift.
 import { resolveDeclaredDir, dirCovers, isResolvableDeclaredEntry } from './declared-paths.mjs';
-import { resolveGitHooksPath } from './commit-guard.mjs';
+import { readPreCommitState } from './git-hooks.mjs';
+export { resolveGitHooksPath, readPreCommitState, canonicalGuardLineRe, INSTALLER_MARKER_RE } from './git-hooks.mjs';
 import { loadConfig } from './orchestration-config.mjs';
 import { homeRelative } from './bridge-state-dirs.mjs';
 import { sandboxEnabled, HOST_HONORS_QUALIFIER } from './bridge-wiring.mjs';
 import { assertContainedRealPath } from './fs-safe.mjs';
 import { nearestExistingDir, worktreesGrantDir, worktreesGrantHoldsHome } from './worktrees.mjs';
-import { preflightCheapAgents, EXECUTOR_VEHICLE } from './cheap-agents.mjs';
+import { preflightCheapAgents, writeCheapAgents, EXECUTOR_VEHICLE } from './cheap-agents.mjs';
+import { ATTRIBUTION_KEY, LEGACY_ATTRIBUTION_KEY, attributionHidesText, effectiveAttribution, readAttributionChoice, wrongTypedKey } from './attribution.mjs';
+import { planGlobalRemoval } from './hide-footprint.mjs';
 import { NODE_EVIDENCE, NODE_EVIDENCE_SCRIPTS, probeNodeEvidence } from './node-evidence.mjs';
 // The vehicle READINESS comes from the read-only half — the same survey `recipes` and `status` read.
-import { surveyExecutorVehicle, readExecutorPosture, executorTemplate, readStamp, readFsDeps, WORKFLOW_STAMP, EXPECTED_WORKFLOW_VERSION } from './cheap-agents-read.mjs';
+import { surveyExecutorVehicle, readExecutorPosture, executorBodyDiffers, executorTemplate, readStamp, readFsDeps, WORKFLOW_STAMP, EXPECTED_WORKFLOW_VERSION } from './cheap-agents-read.mjs';
 // The ack store's path, keys, lane registry, fingerprint and guarded reader live in their own leaf
 // (contract: kit/ack-store) — `status` reads the same store, and a second copy is what drifts.
 import {
@@ -194,6 +197,12 @@ export const SEVERITIES = Object.freeze({
   // names the subagent carrier over a vehicle that cannot carry it — a configured declaration that
   // is broken, which is what attention means.
   'executor-vehicle': SEVERITY_ATTENTION,
+  // A hand edit of the placed executor is not a broken declaration — the vehicle still carries — so
+  // re-deriving it is an offer.
+  'executor-vehicle.differing': SEVERITY_OPTIONAL,
+  // The AGENTS.md block is a configured choice the harness does not honour.
+  attribution: SEVERITY_ATTENTION,
+  'footprint-global': SEVERITY_OPTIONAL,
   'family-freshness': SEVERITY_ATTENTION,
   'adr-store-migration': SEVERITY_ATTENTION,
   'sandbox-masks': SEVERITY_OPTIONAL,
@@ -278,6 +287,9 @@ export const WHATS = Object.freeze({
   'mcp-channel.differing': 'an "{server}" MCP entry is already declared here and DIFFERS from the registration this kit copy would write',
   agents: '{n} bundled subagent vehicle(s) not placed (Claude Code) — {ro} read-only, {ex} the full-tool executor; the apply PREVIEWS first',
   'executor-vehicle': '{n} slot(s) configured subagent but the executor vehicle is {state}{reason} — every such slot runs solo until it is usable',
+  'executor-vehicle.differing': 'the placed executor vehicle differs from the body derived from docs/ai/vehicles.json — a hand edit stands until it is re-derived',
+  attribution: 'AGENTS.md says attribution off but .claude/settings.json does not hide the harness trailer and PR text',
+  'footprint-global': 'legacy kit ignore line(s) sit in {file} — they ignore kit paths in every repository here',
   'family-freshness': '{parts}',
   'adr-store-migration': 'still on the retired 3-tier ADR layout — {shape}',
   'sandbox-masks': '{n} sandbox mask(s) clutter git status — the managed exclude block is absent or stale',
@@ -343,6 +355,8 @@ export const BENEFITS = Object.freeze({
   'mcp-channel': 'velocity — path facts and literal searches arrive as typed tool calls whose arguments are JSON fields, never a shell string',
   agents: 'cost and quiet — cheap-model mechanical work, no shell on a read-only vehicle (no prompt flood); the executor carries slices you verify',
   'executor-vehicle': 'carrier readiness — a slot you configured subagent dispatches the subagent it names instead of silently running solo',
+  attribution: 'attribution — the harness adds no Co-Authored-By trailer, PR text or session link, as your AGENTS.md block requires',
+  'footprint-global': 'hygiene — the legacy machine-global excludes stop ignoring kit paths in every other repository on this host',
   'family-freshness': 'currency — placed family members carry the latest shipped fixes and features',
   'adr-store-migration': 'durability — every decision becomes its own file with a generated navigator, instead of one hand-rotated pile',
   'sandbox-masks': 'zero clutter — a mask git ignores through the block leaves git status; a mount-only one leaves git add -A and the review fingerprint too',
@@ -352,6 +366,10 @@ export const BENEFITS = Object.freeze({
   'jev-connect': 'decisions — a typed choice with a confidence in under a second for your code and the agent\'s scripts, once for every project here',
   'jev-skill': 'the TypeSafe skill for Claude Code, Codex and Antigravity CLI, one pinned verified copy per agent root, from one command you run',
 });
+// The one arm whose gain differs from its base item's (BENEFITS stays keyed by item key).
+export const VARIANT_BENEFITS = Object.freeze({
+  'executor-vehicle.differing': 'carrier fidelity — the placed executor runs the model and effort docs/ai/vehicles.json names, not a hand edit',
+});
 
 // ── the CLOSED opt-in capability registry (OPT-IN-SHIPS-INVISIBLE) ──────────────────────────────
 // 3.14.0 shipped a capability with every surface an AGENT reads and NO advisor entry, so `upgrade`
@@ -388,6 +406,8 @@ export const OPT_IN_CAPABILITIES = Object.freeze([
   { id: 'read-lane', mode: 'hook', advisorKey: 'read-lane' },
   { id: 'commit-guard', mode: 'commit-guard', advisorKey: 'commit-guard' },
   { id: 'enforcement', mode: 'bootstrap', advisorKey: 'enforcement' },
+  { id: 'attribution', mode: 'bootstrap', advisorKey: 'attribution' },
+  { id: 'footprint-global', mode: 'bootstrap', advisorKey: 'footprint-global' },
   { id: 'state-block', mode: 'state-block-guard', advisorKey: 'state-block' },
   { id: 'sandbox-masks', mode: 'sandbox-masks', advisorKey: 'sandbox-masks' },
   { id: 'mcp-channel', mode: 'mcp', advisorKey: 'mcp-channel' },
@@ -890,27 +910,11 @@ const probeSourceSize = ({ root, deps, add, skip }) => {
 // alike; an UNMANAGED hook is a loud skip naming the user's own step (never an overwrite offer); a
 // non-final-capable declaration gets NO offer (an armed guard over a matrix that cannot mint a
 // receipt would block every commit).
-const INSTALLER_MARKER_RE = /:install-git-hooks\.mjs$/m;
-const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-// Convergence needs the EXACT canonical armed line the installer writes — full-line anchored on
-// the kit's OWN resolved guard path. A commented-out line or a lookalike path (fake-commit-guard)
-// must never read as armed (that would suppress the offer and leave commits unguarded).
-const canonicalGuardLineRe = () => new RegExp(`^node "${escapeRe(toolPath('commit-guard.mjs'))}" --check$`, 'm');
-// The one reader of git's pre-commit: whose hook it is, and whether the canonical guard line arms it.
-export const readPreCommitState = (root, deps = {}) => {
-  const hooksPath = (deps.gitHooksPath ?? resolveGitHooksPath)(root);
-  if (hooksPath === null) return { state: 'no-hooks-dir', armed: false };
-  const path = join(hooksPath, 'pre-commit');
-  const hook = (() => {
-    try {
-      if (readsAbsent(deps, path)) return null;
-      return String((deps.readFile ?? readFileSync)(path, 'utf8'));
-    } catch {
-      return null;
-    }
-  })();
-  if (hook === null) return { state: 'absent', armed: false };
-  return { state: INSTALLER_MARKER_RE.test(hook) ? 'managed' : 'unmanaged', armed: canonicalGuardLineRe().test(hook) };
+// The advisor asks git under its own process env; only the commit-guard apply passes the installer's.
+const readHookState = (root, deps) => {
+  const hook = readPreCommitState(root, { ...deps, env: undefined });
+  if (hook.state === 'unreadable') throw new Error(`${hook.path} is unreadable (${hook.code}) — the pre-commit hook cannot be judged`);
+  return hook;
 };
 const formsApply = (variant, root) => consoleArgv(variant, { toolsDir: HERE, root }).apply.map(q).join(' ');
 const probeCommitGuard = ({ root, deps, add, skip }) => {
@@ -931,7 +935,7 @@ const probeCommitGuard = ({ root, deps, add, skip }) => {
       skip('commit-guard', new Error(enforcementAdmits(root, deps) ? COMMIT_GUARD_INSTALLER_VIA_ITEM : COMMIT_GUARD_INSTALLER_OWN_STEP));
       return;
     }
-    const { state, armed } = readPreCommitState(root, deps);
+    const { state, armed } = readHookState(root, deps);
     if (armed || state === 'no-hooks-dir') return; // armed (managed or not), or not a git tree — converged
     if (state === 'unmanaged') {
       skip('commit-guard', new Error(COMMIT_GUARD_UNMANAGED_HOOK));
@@ -977,7 +981,7 @@ const enforcementOffer = (root, deps) => {
     if (readEnforcementNode(destination, lstat) === null) continue;
     throw new Error(`${destination} already exists; the enforcement copy would clobber it`);
   }
-  if (readPreCommitState(root, deps).state === 'unmanaged') throw new Error(ENFORCEMENT_UNMANAGED_HOOK);
+  if (readHookState(root, deps).state === 'unmanaged') throw new Error(ENFORCEMENT_UNMANAGED_HOOK);
   return true;
 };
 
@@ -1125,16 +1129,31 @@ const writerBlock = (root, deps) => {
   }
 };
 
+const HIDDEN_AGENTS_FOLLOW_UP = (root) => `hidden-mode deployments only: after the apply, run node ${q(toolPath('hide-footprint.mjs'))} --dir ${q(root)} --reconcile so the placed .claude/agents/ stays invisible to git status`;
+
 const probeExecutorVehicle = ({ root, deps, add, skip }) => {
+  if (renderBrokenExecutor({ root, deps, add, skip })) return;
+  try {
+    if (!executorBodyDiffers(root, deps)) return;
+    const plan = writeCheapAgents({ cwd: root, dryRun: true }, deps);
+    if (!plan.stampOk) throw new Error(`run /agent-workflow-kit upgrade first (deployment stamp ${plan.stamp ?? 'none'}, expected ${EXPECTED_WORKFLOW_VERSION})`);
+    add('executor-vehicle', WHATS['executor-vehicle.differing'], formsApply('executor-vehicle.differing', root),
+      'executor-vehicle.differing', HIDDEN_AGENTS_FOLLOW_UP(root));
+  } catch (err) {
+    skip('executor-vehicle', err);
+  }
+};
+
+const renderBrokenExecutor = ({ root, deps, add, skip }) => {
   try {
     // The VALIDATED reader, as probeReviewRecipe uses it: a schema-invalid config is a stated skip,
     // never an item computed over a shape nothing accepted.
     const { config } = loadConfig(root, deps.readFile ?? readFileSync, deps.lstat ?? lstatSync);
     const configured = Object.entries(ACTIVITIES).flatMap(([activity, def]) =>
       Object.keys(def.slots).filter((slot) => config?.[activity]?.[slot] === 'subagent'));
-    if (configured.length === 0) return;
+    if (configured.length === 0) return false;
     const survey = (deps.surveyVehicle ?? surveyExecutorVehicle)(root, deps);
-    if (!VEHICLE_BROKEN_STATES.includes(survey.state)) return;
+    if (!VEHICLE_BROKEN_STATES.includes(survey.state)) return false;
     const reason = safeLine(survey.reason ?? '');
     const { posture, reason: settingsReason } = readExecutorPosture(root, deps);
     const stamp = readStamp(join(root, WORKFLOW_STAMP), readFsDeps(deps));
@@ -1147,7 +1166,7 @@ const probeExecutorVehicle = ({ root, deps, add, skip }) => {
     const blocked = writerBlock(root, deps);
     if (blocked) preconditions.push(`${blocked} — fix that`);
     const room = templateBudget(WHATS['executor-vehicle']) - String(configured.length).length - survey.state.length - 2;
-    add(
+    return add(
       'executor-vehicle',
       fillTemplate(WHATS['executor-vehicle'], {
         n: configured.length,
@@ -1158,10 +1177,11 @@ const probeExecutorVehicle = ({ root, deps, add, skip }) => {
       // frontmatter or read-only tools included), so those states need no precondition; every precondition above is a refusal the apply would meet.
       `node ${q(toolPath('cheap-agents.mjs'))} --apply --cwd ${q(root)}`,
       'executor-vehicle',
-      `${preconditions.length ? `precondition: ${preconditions.join('; ')}; ` : ''}hidden-mode deployments only: after the apply, run node ${q(toolPath('hide-footprint.mjs'))} --dir ${q(root)} --reconcile so the placed .claude/agents/ stays invisible to git status`,
+      `${preconditions.length ? `precondition: ${preconditions.join('; ')}; ` : ''}${HIDDEN_AGENTS_FOLLOW_UP(root)}`,
     );
   } catch (err) {
     skip('executor-vehicle', err);
+    return false;
   }
 };
 
@@ -1314,7 +1334,7 @@ const readReadLaneToggle = (root, deps) => {
 // D3: the risk-marked keys — every key here has a per-item posture note in the mode doc, surfaced
 // at the consent moment; the static contract test asserts EXACT bidirectional coverage
 // (risk-marked keys == mode-doc note keys — a dropped note goes red, not silent).
-export const RISK_NOTED_KEYS = Object.freeze(['bridge-tier', 'read-lane', 'worktrees-dir', 'adr-store-migration', 'gates-inert', 'source-size', 'gate-hook', 'mcp-channel', 'spec-adoption', 'enforcement', 'profile-gap', 'jev-connect', 'jev-skill']);
+export const RISK_NOTED_KEYS = Object.freeze(['bridge-tier', 'read-lane', 'worktrees-dir', 'adr-store-migration', 'gates-inert', 'source-size', 'gate-hook', 'mcp-channel', 'spec-adoption', 'enforcement', 'profile-gap', 'jev-connect', 'jev-skill', 'attribution', 'footprint-global']);
 
 // The feature-spec layer's adoption state (contract: kit/spec-adoption). The canon lets a plan cite
 // zero governing specs while a project adopts the layer, and nothing ever said whether adoption had
@@ -1564,9 +1584,48 @@ export const probeProfileGaps = ({ root, deps, add, skip }) => {
   }
 };
 
+// The attribution item by its table (spec init-project, part in-session-writes): a choice of off the
+// effective settings do not honour; the writer's preflight runs before it renders, so no rendered check always exits 3.
+const probeAttribution = ({ root, deps, add, skip }) => {
+  try {
+    if (readAttributionChoice(root, deps) !== 'off') return;
+    const project = readSettingsFile(join(root, SETTINGS_FILE), { ...deps, cwd: root }).data;
+    const local = readSettingsFile(join(root, SETTINGS_LOCAL_FILE), { ...deps, cwd: root }).data;
+    const effective = effectiveAttribution(project, local);
+    if (attributionHidesText(effective)) return;
+    preflightVelocityProfile({ cwd: root }, deps);
+    for (const [file, data] of [[SETTINGS_FILE, project], [SETTINGS_LOCAL_FILE, local]]) {
+      const wrong = wrongTypedKey(data);
+      if (wrong) throw new Error(`${file}: ${wrong} — the attribution item cannot judge it`);
+    }
+    const setsText = (value) => value !== null && typeof value === 'object' && ['commit', 'pr'].some((key) => Object.hasOwn(value, key));
+    const localKey = Object.hasOwn(local ?? {}, ATTRIBUTION_KEY) && !attributionHidesText({ [ATTRIBUTION_KEY]: local[ATTRIBUTION_KEY] }) ? ATTRIBUTION_KEY
+      : local?.[LEGACY_ATTRIBUTION_KEY] === true && !setsText(effective[ATTRIBUTION_KEY]) ? LEGACY_ATTRIBUTION_KEY : null;
+    if (localKey) throw new Error(`${SETTINGS_LOCAL_FILE} sets ${localKey} so the harness adds its text — a local-scope override is your own edit`);
+    add('attribution', WHATS.attribution, formsApply('attribution', root));
+  } catch (err) {
+    skip('attribution', err);
+  }
+};
+
+// The leftover machine-global block: the one plan the hide reports and the --remove-global mode removes,
+// asked of git under the home the advisor was given.
+const probeFootprintGlobal = ({ root, deps, add, skip }) => {
+  try {
+    const home = deps.home ?? deps.jevHost?.home ?? homedir();
+    const plan = (deps.planGlobalRemoval ?? planGlobalRemoval)({ env: { ...process.env, HOME: home }, home }, root, { home });
+    if (plan === null) return;
+    const file = truncatedTo(plan.source, templateBudget(WHATS['footprint-global']));
+    add('footprint-global', fillTemplate(WHATS['footprint-global'], { file }), formsApply('footprint-global', root));
+  } catch (err) {
+    skip('footprint-global', err);
+  }
+};
+
 // ── assembly (frozen presentation order) ─────────────────────────────────────────────────────────
 const PROBES = Object.freeze([
   probeVelocityItems,
+  probeAttribution,
   probeAutonomyItems,
   probeSandboxProvision,
   probeReviewRecipe,
@@ -1582,6 +1641,7 @@ const PROBES = Object.freeze([
   probeFamilyFreshness,
   probeAdrStore,
   probeMasksItem,
+  probeFootprintGlobal,
   probeWorktreesDir,
   probeMcpChannel,
   probeSpecAdoption,
@@ -1629,7 +1689,7 @@ export const buildRecommendations = ({ cwd, deps = {} } = {}) => {
       home: deps.jevHost?.home ?? deps.home ?? '',
       platform: deps.jevHost?.platform ?? deps.platform,
     });
-    items.push({ key, variant, severity: SEVERITIES[variant], lane: laneOf(variant), what, benefit: BENEFITS[key],
+    items.push({ key, variant, severity: SEVERITIES[variant], lane: laneOf(variant), what, benefit: VARIANT_BENEFITS[variant] ?? BENEFITS[key],
       check: slot?.check ?? null, apply: slot?.apply ?? apply, detail });
     return true;
   };

package/tools/upgrade-runlist.mjs

@@ -40,7 +40,7 @@ export const UPGRADE_RUNLIST = Object.freeze([
       'note-refreshed',
       'refreshed',
       'regenerated',
-      're-derived',
+      'pending',
       'already-current',
       'customized-preserved',
       'malformed-preserved',

package/tools/write-lanes.mjs

@@ -38,6 +38,9 @@ export const VARIANT_LANES = Object.freeze({
   'mcp-channel.differing': LANE_HARNESS,
   agents: LANE_HARNESS,
   'executor-vehicle': LANE_HARNESS,
+  'executor-vehicle.differing': LANE_HARNESS,
+  attribution: LANE_HARNESS,
+  'footprint-global': LANE_HARNESS,
   'family-freshness': LANE_USER,
   'adr-store-migration': LANE_CHAT,
   'sandbox-masks': LANE_CHAT,
@@ -142,6 +145,10 @@ const FORMS = Object.freeze({
     ['--replace', '--cwd', '<root>'], ['--replace', '--apply', '--cwd', '<root>'], MCP_WRITES),
   agents: AGENT_FORM,
   'executor-vehicle': AGENT_FORM,
+  'executor-vehicle.differing': AGENT_FORM,
+  attribution: createForm('attribution.mjs', ['--cwd', '<root>'], ['--apply', '--cwd', '<root>'], SETTINGS_WRITES),
+  'footprint-global': createForm('hide-footprint.mjs',
+    ['--remove-global', '--dry-run', '--dir', '<root>'], ['--remove-global', '--dir', '<root>'], [], false, null, true),
   'sandbox-provision.installable': createForm('autonomy-doctor.mjs', [], ['--apply', '<tuple>'], [], true,
     (facts, argv) => 'your own step (a sudo install; the doctor prints the --apply line to run next) — '
       + `${TERMINAL_STEP}cd ${quoteArg(facts.root)} && ${formatCommand(argv.preview)}`),