greprag 5.82.1 → 5.83.1

package/dist/commands/merge-guard.js

@@ -22,7 +22,7 @@
  *      plumbing that happens to share a prefix, and `merge-base` is used BY the
  *      provenance check — blocking it would break the gate with the guard.
  *    · only a merge nothing already serialises. A command that takes the lock
- *      itself, ahead of the merge and `&&`-joined to it, is already serialised.
+ *      itself and stops on acquisition failure is already serialised.
  *
  *  Holding the lock yourself is a pass. A peer holding it is the refusal that
  *  matters: it is the exact collision, caught before the merge instead of after.
@@ -51,6 +51,12 @@
  *     trips. Only `&&` earns this: after `;` or `||` the merge still runs when the
  *     acquire failed, so those are refused, and the refusal now says so.
  *
+ *  A THIRD, 2026-10-06 in C:/sift: an acquire run from a linked worktree wrote the
+ *  lock into that worktree's private git dir, so this guard, reading the canonical
+ *  checkout, refused the holder's own merge whatever its shape. Locks now live in the
+ *  repository's shared `.git`, and a chained acquire counts when it writes the same
+ *  lock file this guard reads.
+ *
  *  # adr: adr/deploy-gate-cli.md
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -126,11 +132,11 @@ function shellSegments(command) {
     let start = 0;
     let afterAnd = true;
     for (let match = separator.exec(masked); match; match = separator.exec(masked)) {
-        segments.push({ text: source.slice(start, match.index), afterAnd });
+        segments.push({ text: source.slice(start, match.index), start, afterAnd });
         afterAnd = match[0] === '&&';
         start = match.index + match[0].length;
     }
-    segments.push({ text: source.slice(start), afterAnd });
+    segments.push({ text: source.slice(start), start, afterAnd });
     return segments;
 }
 /** Quote-aware tokens. A quoted run is one token with its quotes removed, so
@@ -297,9 +303,10 @@ function buildMergeGuardReason(held, ownership) {
         '  greprag merge-lock acquire --label "<what you are merging>"',
         '  git merge --ff-only <rebased branch>',
         '  greprag merge-lock release --landed <the merge sha> --label "<what it was>"',
-        'One call works too, as long as the acquire comes first and every step is joined by',
-        '`&&` — that is what stops the merge when someone else holds the lock. A `;` or `||`',
-        'between them runs the merge anyway, so those are refused.',
+        'One call works too when the acquire comes first and failure stops the merge:',
+        'use an `&&` chain, or in PowerShell a try/finally block with an immediate',
+        '`if ($LASTEXITCODE -ne 0) { throw ... }` after acquire. Bare `;` and `||`',
+        'let the merge run after a failed acquire, so those are refused.',
         '`--landed` is what lets the deploy prove YOUR work is in what ships, rather than only',
         'that production serves HEAD. Merging in a worktree instead? That is never blocked.',
     ].join(' ');
@@ -357,7 +364,8 @@ function guardMergeAt(input, segments, mergeAt) {
     // truncating it locally to 8 was a second copy of identity logic waiting to disagree
     // with the one in session-id.ts.
     const ownership = (0, deploy_locks_1.lockOwnership)(held, input.session_id);
-    const chainedLock = takesLockForTarget(segments, mergeAt, cwd, target);
+    const chainedLock = takesLockForTarget(segments, mergeAt, cwd, target)
+        || powerShellTryTakesLock(input.tool_input?.command ?? input.tool_input?.cmd ?? '', segments[mergeAt].start, cwd, target);
     if (ownership !== 'mine' && !chainedLock)
         return denyMerge(input, buildMergeGuardReason(held, ownership));
     // Git owns the final freshness check AT mutation time. Even if master changes
@@ -403,11 +411,88 @@ function takesLockForTarget(segments, mergeAt, cwd, target) {
             return false;
         if (!isMergeLockAcquire(segments[i - 1].text))
             continue;
-        const lockDir = mergeCwd(segments, i - 1, cwd);
-        return (0, deploy_gate_1.normalizePath)(mergeWorktreeRoot([], lockDir) ?? lockDir) === (0, deploy_gate_1.normalizePath)(target);
+        return acquiresTargetLock(mergeCwd(segments, i - 1, cwd), target);
+    }
+    return false;
+}
+/** An acquire run in `dir` serialises a merge into `target` exactly when it writes the
+ *  lock the guard reads for `target`. The lock is repository-wide, so an acquire from a
+ *  linked worktree counts; comparing worktree roots refused that holder on 2026-10-06. */
+function acquiresTargetLock(dir, target) {
+    try {
+        return (0, deploy_gate_1.normalizePath)((0, deploy_locks_1.mergeLockPath)(dir)) === (0, deploy_gate_1.normalizePath)((0, deploy_locks_1.mergeLockPath)(target));
+    }
+    catch {
+        return false;
+    }
+}
+/** PowerShell's `try { acquire; if ($LASTEXITCODE -ne 0) { throw ... }; merge }
+ * finally { release }` is a fail-closed lock sequence too. Inspect only direct
+ * statements in the try body; a bare semicolon or an acquire nested in a branch
+ * must not excuse a merge. */
+function powerShellTryTakesLock(command, mergeStart, cwd, target) {
+    const masked = maskQuoted(command);
+    const tryStart = /(?:^|[;\n])\s*try\s*\{/gi;
+    for (let match = tryStart.exec(masked); match; match = tryStart.exec(masked)) {
+        const open = masked.indexOf('{', match.index);
+        const close = matchingBrace(masked, open);
+        if (close < 0 || mergeStart <= open || mergeStart >= close)
+            continue;
+        const suffix = masked.slice(close + 1);
+        const finallyMatch = /^\s*finally\s*\{/.exec(suffix);
+        if (!finallyMatch || matchingBrace(masked, close + 1 + finallyMatch[0].lastIndexOf('{')) < 0)
+            continue;
+        const statements = powerShellStatements(command, masked, open + 1, close);
+        const mergeIndex = statements.findIndex(s => mergeStart >= s.start && mergeStart < s.end);
+        if (mergeIndex < 2 || mergeGlobalOpts(statements[mergeIndex].text)?.length !== 0)
+            continue;
+        // A location change would make the lock's target ambiguous. The regular
+        // chained-command path already resolves simple cd/Set-Location sequences.
+        if (/(?:^|[;\n])\s*(?:cd|chdir|sl|Set-Location|Push-Location|Pop-Location|pushd|popd)\b/i.test(masked.slice(0, mergeStart)))
+            continue;
+        if (!acquiresTargetLock(cwd, target))
+            continue;
+        for (let i = mergeIndex - 2; i >= 0; i--) {
+            if (!isMergeLockAcquire(statements[i].text))
+                continue;
+            if (/[|&]/.test(maskQuoted(statements[i].text)))
+                continue;
+            if (!/^if\s*\(\s*\$LASTEXITCODE\s*-ne\s*0\s*\)\s*\{\s*throw\b[^{}]*\}\s*$/i.test(statements[i + 1].text.trim()))
+                continue;
+            if (statements.slice(i + 2, mergeIndex).some(s => /\bmerge-lock\s+release\b/i.test(s.text)))
+                continue;
+            return true;
+        }
     }
     return false;
 }
+function matchingBrace(masked, open) {
+    let depth = 0;
+    for (let i = open; i < masked.length; i++) {
+        if (masked[i] === '{')
+            depth++;
+        else if (masked[i] === '}' && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+function powerShellStatements(command, masked, start, end) {
+    const statements = [];
+    let depth = 0;
+    let from = start;
+    for (let i = start; i < end; i++) {
+        if (masked[i] === '{')
+            depth++;
+        else if (masked[i] === '}')
+            depth--;
+        else if (depth === 0 && (masked[i] === ';' || masked[i] === '\n')) {
+            statements.push({ text: command.slice(from, i).trim(), start: from, end: i });
+            from = i + 1;
+        }
+    }
+    statements.push({ text: command.slice(from, end).trim(), start: from, end });
+    return statements.filter(s => s.text);
+}
 function denyMerge(input, reason) {
     return {
         hookSpecificOutput: {

package/dist/commands/parity.js

@@ -80,10 +80,8 @@ const SEED_UNITS = [
     {
         name: 'chip-spawn',
         followers: [
-            { harness: 'claude-code', candidate: '~/.claude/docs/chip-spawn.md' },
             { harness: 'claude-code', candidate: 'packages/cli/skill/templates/chip-spawn.md' },
             { harness: 'codex', candidate: 'packages/cli/skill/templates/codex-chip-spawn.md' },
-            { harness: 'codex', candidate: 'docs/codex-chip-spawn.md' },
             { harness: 'opencode', candidate: null, note: 'no dedicated opencode chip-spawn doc found — chips ride greprag opencode chip + templates/chip-leader-opencode.md covers the leader shape only' },
         ],
     },

package/dist/commands/pipe-wrap.js

@@ -189,13 +189,15 @@ function searchFlagsDisqualify(tokens) {
 }
 /** First non-flag token = the search pattern, sanitized into a crush
  *  `--query` hint: strip quotes, keep word chars/space/dot/dash only
- *  (safe inside double quotes), collapse whitespace, cap at 80 chars. */
+ *  (safe inside double quotes), drop leading dashes, collapse whitespace,
+ *  cap at 80 chars. A hint of `--help` or `-h` would reach the CLI as the help
+ *  flag, which prints help in place of the crushed output (adr/cli-help-dispatch.md). */
 function extractSearchQuery(tokens) {
     for (const tok of tokens) {
         if (tok.startsWith('-'))
             continue;
         const unquoted = tok.replace(/^["']|["']$/g, '');
-        const clean = unquoted.replace(/[^\w\s.-]/g, ' ').replace(/\s+/g, ' ').trim();
+        const clean = unquoted.replace(/[^\w\s.-]/g, ' ').replace(/^[\s-]+/, '').replace(/\s+/g, ' ').trim();
         return clean.slice(0, 80);
     }
     return '';

package/dist/commands/skill-mirror-reminder.js

@@ -18,19 +18,36 @@ function renderEntry(skill) {
 function buildSkillMirrorAnnounce(m, platform) {
     if (!m || m.count <= 0)
         return null;
+    // A hand-kept copy is in the native skill list, so it is not in the trigger
+    // list below, but the harness runs that copy and never sees canon move on.
+    // Name each one; replacing a live copy is the user's call, skill by skill.
+    const cutoverCommand = (0, skill_activation_manifest_1.localCopyCutoverCommand)(platform || '', m.localCopies);
+    const copies = m.localCopies.length === 1 ? 'one mirrored skill' : `${m.localCopies.length} mirrored skills`;
+    const copySection = cutoverCommand ? [
+        '### Hand-Kept Copies',
+        `This harness lists ${copies} from a hand-kept copy instead of an adapter, `
+            + `so it keeps running that copy when the mirrored skill changes: ${m.localCopies.join(', ')}. `
+            + 'Replacing a copy with its adapter is the user\'s call, one skill at a time (the old SKILL.md is backed up first):',
+        '',
+        `    ${cutoverCommand}`,
+        '',
+        'Offer that command when the user asks why a skill behaves out of date, or when you needed one of them this session.',
+        '',
+    ] : [];
     if (m.skills.length === 0) {
-        return '[greprag skills: slash skills are available. '
+        const line = '[greprag skills: slash skills are available. '
             + 'When discussing skills with the user, say use/create/update/refresh `/skill`; '
             + 'keep storage mechanics internal unless diagnosing a failure or the user asks how it works. '
             + 'Use `greprag load <skill>` to read skill instructions.]';
+        return [line, '', ...copySection].join('\n').trimEnd();
     }
-    // The entries this harness does not advertise are exactly the mirrored
-    // skills with no native adapter installed. Name the gap and the one command
-    // that closes it, or it stays invisible until the operator spots it by hand.
-    const installCommand = (0, skill_activation_manifest_1.nativeAdapterInstallCommand)(platform || '', m.skills.map(s => s.skillName));
+    // Mirrored skills with no native package never reach the native skill list.
+    // Name the gap and the one command that closes it, or it stays invisible
+    // until the operator spots it by hand.
+    const installCommand = (0, skill_activation_manifest_1.nativeAdapterInstallCommand)(platform || '', m.missing);
     const gapSection = installCommand ? [
         '### Missing Native Adapters',
-        `${m.skills.length} of these skills are in your GrepRAG mirror but have NO adapter installed in this harness, `
+        `${m.missing.length} of these skills are in your GrepRAG mirror but have NO adapter installed in this harness, `
             + 'so they never appear in the native skill list. Install the adapters once with:',
         '',
         `    ${installCommand}`,
@@ -47,6 +64,7 @@ function buildSkillMirrorAnnounce(m, platform) {
         'When discussing skills with the user, say use/create/update/refresh `/skill`; keep storage mechanics internal unless diagnosing a failure or the user asks how it works.',
         '',
         ...gapSection,
+        ...copySection,
         '### Trigger Rules',
         'If the user names a skill (with or without `/`) OR the request clearly matches a skill\'s description below, '
             + 'you MUST activate that skill for the current turn. Match meaning, not exact keywords.',

package/dist/commands/skill.js

@@ -59,6 +59,7 @@ const project_anchor_1 = require("../project-anchor");
 const skill_mirror_client_1 = require("../skill-mirror-client");
 const skill_landing_1 = require("../skill-landing");
 const skill_staleness_1 = require("../skill-staleness");
+const load_1 = require("./load");
 const CORE_SKILL = 'greprag';
 const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** `--only a,b` / `--only=a,b` / repeated `--only a --only b` → skill names. */
@@ -342,6 +343,7 @@ function forwardedMirrorArgs(args) {
     }
     return parts.join(' ');
 }
+/** Returns whether it wrote: under `check` it only lists the plan, so a caller reports success only on true. */
 function writeSkillPackage(targetDir, files, opts) {
     const target = path.resolve(targetDir);
     if (fs.existsSync(target) && !dirEmpty(target) && !opts.force) {
@@ -357,7 +359,8 @@ function writeSkillPackage(targetDir, files, opts) {
             console.log(`  write ${file.path}`);
         for (const relative of removals)
             console.log(`  remove ${relative}`);
-        return;
+        console.log('Check only: nothing written.');
+        return false;
     }
     fs.mkdirSync(target, { recursive: true });
     for (const relative of removals)
@@ -367,6 +370,7 @@ function writeSkillPackage(targetDir, files, opts) {
         fs.mkdirSync(path.dirname(destination), { recursive: true });
         fs.writeFileSync(destination, file.content.endsWith('\n') ? file.content : file.content + '\n', 'utf8');
     }
+    return true;
 }
 function printSkillMirrorConflict(params) {
     const local = new Map(params.localFiles.map(file => [file.path, file.content]));
@@ -395,8 +399,9 @@ async function runSkillMirrorExport(args) {
         .filter((file) => typeof file.path === 'string' && typeof file.content === 'string');
     if (!files.length)
         throw new Error(`No mirrored files returned for ${name}.`);
-    writeSkillPackage(to, files, { force: args.includes('--force'), check: args.includes('--check'), exact: true });
-    console.log(`Exported ${name} revision ${Number(data.revision || 0)} (${String(data.contentHash || '').slice(0, 12)})`);
+    if (!writeSkillPackage(to, files, { force: args.includes('--force'), check: args.includes('--check'), exact: true }))
+        return;
+    console.log(`Exported ${name} revision ${Number(data.revision || 0)} (${String(data.contentHash || '')})`);
 }
 async function loadMirrorPackage(skill, args) {
     const data = await mirrorApiJson('GET', `/v1/skillmirror/${encodeURIComponent(skill)}${mirrorLookupQuery(args)}`);
@@ -428,7 +433,16 @@ function runEditor(target) {
         throw new Error(`editor exited with status ${result.status}`);
     }
 }
+/** A skill the CLI ships as its own bundle has one canon, the bundle, and
+ *  `greprag load` serves it for that skill's global id. A mirror write under
+ *  its name would land in a row nothing reads. */
+function refuseBundledSkillWrite(skill) {
+    if (!(0, load_1.bundleOwnsSkill)(skill))
+        return;
+    throw new Error(`${skill} ships with the greprag CLI, so its canon is the bundle, not the skill mirror. Edit packages/cli/skill/${skill}/ in the greprag repo.`);
+}
 async function applySkillPackage(params) {
+    refuseBundledSkillWrite(params.skill);
     const hash = (0, skill_mirror_client_1.computeMirrorHash)(params.files);
     const body = {
         files: params.files,
@@ -465,6 +479,7 @@ async function runSkillEdit(args) {
     const skill = args[0];
     if (!skill)
         throw new Error('Usage: greprag skill edit <name> [--dir <dir>] [--no-open] [--force] [--keep]');
+    refuseBundledSkillWrite(skill);
     const explicitDir = getArg(args, '--dir') || getArg(args, '--to');
     const noOpen = args.includes('--no-open');
     const keep = args.includes('--keep') || Boolean(explicitDir);
@@ -476,7 +491,7 @@ async function runSkillEdit(args) {
         force: args.includes('--force') || !explicitDir,
         exact: true,
     });
-    console.log(`Editing ${skill} revision ${loaded.revision} (${loaded.contentHash.slice(0, 12)})`);
+    console.log(`Editing ${skill} revision ${loaded.revision} (${loaded.contentHash})`);
     console.log(`Work dir: ${workDir}`);
     const skipEditor = noOpen || codexHarnessDetected();
     if (skipEditor) {
@@ -498,7 +513,7 @@ async function runSkillEdit(args) {
     }
     await assertCurrentMirrorHash({ skill, expectedHash: loaded.contentHash, localFiles: edited, args });
     const data = await applySkillPackage({ skill, files: edited, expectedHash: loaded.contentHash, args });
-    console.log(`Applied ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(edited)).slice(0, 12)})`);
+    console.log(`Applied ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(edited))})`);
     if (!keep)
         fs.rmSync(workDir, { recursive: true, force: true });
 }
@@ -521,7 +536,7 @@ async function runSkillMirrorApply(args) {
         expectedRevision: expectedRevisionRaw ? Number(expectedRevisionRaw) : undefined,
         args,
     });
-    console.log(`Applied ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(files)).slice(0, 12)})`);
+    console.log(`Applied ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(files))})`);
 }
 function snapshotNameArg(args) {
     const explicit = getArg(args, '--name');
@@ -593,7 +608,8 @@ async function runSkillMirrorSnapshot(args) {
         if (!to)
             throw new Error('Usage: greprag skill mirror snapshot restore <skill> --name <snapshot> --to <dir> [--force] [--check]');
         const files = snapshotPresentFiles(snapshot);
-        writeSkillPackage(to, files, { force: rest.includes('--force'), check: rest.includes('--check'), exact: true });
+        if (!writeSkillPackage(to, files, { force: rest.includes('--force'), check: rest.includes('--check'), exact: true }))
+            return;
         console.log(`Restored snapshot ${name} for ${skill} to ${path.resolve(to)}. Run apply with the expected revision if this should become canon.`);
         return;
     }
@@ -614,7 +630,7 @@ async function runSkillMirrorSnapshot(args) {
         }
         await assertCurrentMirrorHash({ skill, expectedHash, localFiles: files, args: rest });
         const data = await applySkillPackage({ skill, files, expectedHash, args: rest });
-        console.log(`Promoted snapshot ${name} for ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(files)).slice(0, 12)})`);
+        console.log(`Promoted snapshot ${name} for ${skill}: revision ${Number(data.revision || 0)} (${String(data.contentHash || (0, skill_mirror_client_1.computeMirrorHash)(files))})`);
         return;
     }
     throw new Error('Usage: greprag skill mirror snapshot create|list|show|restore|promote <skill> [--name <snapshot>]');

package/dist/commands/skillgain.js

@@ -40,6 +40,11 @@ Gains land automatically at session start as a briefcase (fuse line + focused
 doc) and SELF-APPLY on the skill's next invocation.`;
 async function runSkillGain(args) {
     const sub = args[0];
+    // Help needs no key: anything that is not a verb, a help flag included.
+    if (sub !== 'list' && sub !== 'done' && sub !== 'reject') {
+        console.log(HELP);
+        return;
+    }
     const cfg = getConfig();
     if (!cfg.apiKey) {
         console.error('GREPRAG_API_KEY not set — run `greprag init` first.');
@@ -112,5 +117,4 @@ async function runSkillGain(args) {
         }
         return;
     }
-    console.log(HELP);
 }

package/dist/commands/state-trigger.js

@@ -60,6 +60,7 @@ exports.isFixSpawnDispatch = isFixSpawnDispatch;
 exports.computeBootstrapFriction = computeBootstrapFriction;
 exports.scanKeywords = scanKeywords;
 exports.computeStateValues = computeStateValues;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 /** Stress level enum, encoded numerically so the `state` DSL can threshold it
  *  with gte/lte (0 calm · 1 elevated · 2 high). */
@@ -101,9 +102,25 @@ function isRealUser(rec) {
     }
     return true;
 }
+// adr: adr/stress-target-keying.md
+/** Tools whose input is a CHANGE to a file, not a lookup of it. */
+const WRITE_TOOLS = new Set(['Edit', 'MultiEdit', 'Write', 'NotebookEdit']);
 function toolTargetKey(b) {
     const name = b.name || '';
     const inp = (b.input || {});
+    // A write repeats only when the same change is issued again. Keyed on the
+    // path, every successive edit of one document read as rep + retry, and a
+    // report built across operator prompts paged FRICTION HIGH for turns after
+    // its last real error (paybot-website 02d0ecbf, 2026-10-05). Writes still
+    // reach churn through `writes`, which stays path-keyed.
+    if (WRITE_TOOLS.has(name)) {
+        let body = '';
+        try {
+            body = JSON.stringify(inp);
+        }
+        catch { /* unserializable → empty */ }
+        return `${name}:${crypto.createHash('sha1').update(body).digest('hex').slice(0, 16)}`;
+    }
     let key = (inp.command ?? inp.file_path ?? inp.pattern ?? inp.path);
     if (typeof key !== 'string') {
         try {
@@ -149,6 +166,7 @@ function parseTurns(transcriptPath, maxTurns = 40) {
     const turns = [];
     const pending = new Map();
     let total = 0;
+    let seq = 0;
     let cur = null;
     const flush = () => {
         if (cur) {
@@ -172,7 +190,7 @@ function parseTurns(transcriptPath, maxTurns = 40) {
         if (isRealUser(rec)) {
             flush();
             total++;
-            cur = { proseWords: 0, toolTargets: [], errors: 0, nTools: 0, writes: [], failures: [] };
+            cur = { proseWords: 0, toolTargets: [], errors: 0, nTools: 0, writes: [], failures: [], successes: [] };
             continue;
         }
         if (!cur)
@@ -202,20 +220,25 @@ function parseTurns(transcriptPath, maxTurns = 40) {
         }
         else if (rec.type === 'user') { // tool_result records
             for (const b of blocks(rec)) {
-                if (b && b.type === 'tool_result' && resultIsError(b)) {
+                if (!b || b.type !== 'tool_result')
+                    continue;
+                // The soft regex feeds `errors` (the validated stress feature) only.
+                if (resultIsError(b))
                     cur.errors++;
-                    // A ToolFailure (the bootstrap classifier's input) requires HARD
-                    // evidence the command itself failed — the harness's is_error flag,
-                    // never error-looking output text: a successful `… | grep -i error`
-                    // matches ERROR_RE by construction (false-page a0d1a7e2 2026-07-12).
-                    // The soft regex still feeds `errors` (the validated stress feature).
-                    if (b.is_error !== true)
-                        continue;
-                    const useId = typeof b.tool_use_id === 'string' ? b.tool_use_id : '';
-                    const prior = useId ? pending.get(useId) : null;
-                    if (prior)
-                        cur.failures.push({ ...prior, error: toolResultText(b).slice(0, 500) });
-                }
+                const useId = typeof b.tool_use_id === 'string' ? b.tool_use_id : '';
+                const prior = useId ? pending.get(useId) : null;
+                if (!prior)
+                    continue;
+                seq++;
+                // A ToolFailure (the bootstrap classifier's input) requires HARD
+                // evidence the command itself failed — the harness's is_error flag,
+                // never error-looking output text: a successful `… | grep -i error`
+                // matches ERROR_RE by construction (false-page a0d1a7e2 2026-07-12).
+                // Everything else settled OK — the evidence that clears a signature.
+                if (b.is_error === true)
+                    cur.failures.push({ ...prior, seq, error: toolResultText(b).slice(0, 500) });
+                else
+                    cur.successes.push({ ...prior, seq });
             }
         }
     }
@@ -446,9 +469,20 @@ function commandFamily(command) {
     // Quote-stripped: a tool token inside a quoted payload must not mint the
     // dedupe key — the original incident's fix-spawn argument embedded `node`,
     // colliding with the real failure's family and inflating `repeats` to 2.
+    // Bare `node` keys on the script's BASENAME: `node a.js` and `node b.js` are
+    // different shapes, while `node <typo-dir>/h.js` and `node <dir>/h.js` are one
+    // (the resolved-typo re-fire, sift 65bed6f0 2026-09-18).
     const c = stripQuotedSpans(command).toLowerCase();
-    const m = c.match(/\b(?:npm\s+run\s+\S+|npm\s+\S+|pnpm\s+\S+|yarn\s+\S+|npx\s+\S+|fnm\s+\S+|corepack\s+\S+|turbo\s+\S+|vitest\b|jest\b|tsc\b|node\b)/);
-    return (m?.[0] || c).replace(/\s+/g, ' ').slice(0, 80);
+    const m = c.match(/\b(?:npm\s+run\s+\S+|npm\s+\S+|pnpm\s+\S+|yarn\s+\S+|npx\s+\S+|fnm\s+\S+|corepack\s+\S+|turbo\s+\S+|vitest\b|jest\b|tsc\b|node(?:\s+\S+)?)/);
+    const family = (m?.[0] || c).replace(/\s+/g, ' ');
+    const node = family.match(/^node (\S+)$/);
+    return (node ? `node ${node[1].replace(/\\/g, '/').split('/').pop()}` : family).slice(0, 80);
+}
+/** `run` settled after `failure` in transcript order (turn, then seq). */
+function settledAfter(run, runTurn, failure, failureTurn) {
+    if (runTurn !== failureTurn)
+        return runTurn > failureTurn;
+    return (run.seq ?? -1) > (failure.seq ?? Infinity);
 }
 /** Detect setup/toolchain failures that are likely repairable once for all future
  * sessions. This is deliberately narrower than generic stress: source-code
@@ -468,21 +502,23 @@ function computeBootstrapFriction(turns) {
     if (!failures.length)
         return none;
     const latest = failures[failures.length - 1];
-    // Dispatch suppression: a `greprag fix spawn` that RAN (didn't itself fail)
-    // at/after the latest qualifying failure IS the remedy in motion — the
-    // friction is dispatched, not fresh. Without this the same signature
-    // re-paged every turn it stayed in the window, even after compliance
-    // (incident 250ac565, 2026-07-12). A FAILED spawn never counts — the chip
-    // did not launch. Same-turn spawns suppress too (conservative-quiet: a
-    // recurrence on a later run re-fires, since it postdates the spawn).
+    const latestFamily = commandFamily(latest.failure.command);
+    // A signature lives only until a later SUCCESSFUL run resolves it. Without
+    // this the directive re-paged every turn the failure stayed in the window:
+    // after compliance (incident 250ac565, 2026-07-12) and after the very next
+    // run of the same shape succeeded (sift 65bed6f0, 2026-09-18). Two resolvers:
+    //  - dispatch: a `greprag fix spawn` that RAN at/after the latest failure's
+    //    turn — the remedy is in motion (same-turn spawns count: conservative-quiet);
+    //  - recovery: the same command shape succeeded after the latest failure —
+    //    the toolchain works now, the failure was transient.
+    // A FAILED run never resolves. A recurrence after either re-fires, since the
+    // new failure becomes `latest` and postdates the resolver.
     for (let turn = latest.turn; turn < turns.length; turn++) {
-        const t = turns[turn];
-        const failedCmds = new Set((t.failures || []).map(f => f.command));
-        for (const tg of t.toolTargets || []) {
-            if (!tg.startsWith('Bash:'))
-                continue;
-            const cmd = tg.slice('Bash:'.length);
-            if (isFixSpawnDispatch(cmd) && !failedCmds.has(cmd))
+        for (const s of turns[turn].successes || []) {
+            if (isFixSpawnDispatch(s.command))
+                return none;
+            if (commandFamily(s.command) === latestFamily
+                && settledAfter(s, turn, latest.failure, latest.turn))
                 return none;
         }
     }
@@ -491,7 +527,7 @@ function computeBootstrapFriction(turns) {
         const key = `${f.signal}:${commandFamily(f.failure.command)}`;
         counts.set(key, (counts.get(key) || 0) + 1);
     }
-    const latestKey = `${latest.signal}:${commandFamily(latest.failure.command)}`;
+    const latestKey = `${latest.signal}:${latestFamily}`;
     const repeats = counts.get(latestKey) || 1;
     const strongSingle = latest.signal === 'command-not-found'
         || latest.signal === 'fnm-node-bootstrap'

package/dist/delivery-config.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deliveryProfilePath = deliveryProfilePath;
+exports.draftDeliveryProfile = draftDeliveryProfile;
 exports.resolveDeliveryProfile = resolveDeliveryProfile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -160,6 +161,74 @@ function parseProfile(root, raw) {
         deploySource, releaseSource, errors,
     };
 }
+function git(cwd, command) {
+    try {
+        return (0, proc_1.safeExecSync)(`git ${command}`, {
+            cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true,
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+const PROVIDER_SIGNALS = [
+    ['wrangler.toml', 'Cloudflare Workers/Pages (wrangler)'],
+    ['wrangler.jsonc', 'Cloudflare Workers/Pages (wrangler)'],
+    ['wrangler.json', 'Cloudflare Workers/Pages (wrangler)'],
+    ['Procfile', 'Heroku (Procfile)'],
+    ['app.json', 'Heroku (app.json)'],
+    ['fly.toml', 'Fly.io'],
+    ['vercel.json', 'Vercel'],
+    ['netlify.toml', 'Netlify'],
+    ['Dockerfile', 'Docker image'],
+];
+/** Draft a profile from the repo's own Git facts. Deploy targets stay a stub until a deploy doc exists. */
+// adr: adr/delivery-profile.md
+function draftDeliveryProfile(cwd) {
+    const root = gitRoot(cwd);
+    if (!root)
+        return null;
+    const remotes = git(root, 'remote').split(/\r?\n/).filter(Boolean);
+    const remote = remotes.includes('origin') ? 'origin' : remotes[0] || 'none';
+    const originHead = remote !== 'none' ? git(root, `symbolic-ref --short refs/remotes/${remote}/HEAD`) : '';
+    const branches = git(root, 'branch --format=%(refname:short)').split(/\r?\n/);
+    const defaultBranch = originHead.replace(`${remote}/`, '')
+        || ['main', 'master'].find((b) => branches.includes(b))
+        || git(root, 'branch --show-current') || 'main';
+    const commonDir = git(root, 'rev-parse --path-format=absolute --git-common-dir');
+    const canonicalRoot = (commonDir ? path.dirname(commonDir) : root).replace(/\\/g, '/');
+    const providerSignals = PROVIDER_SIGNALS
+        .filter(([file]) => fs.existsSync(path.join(root, file))).map(([, label]) => label);
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        if (pkg.name && pkg.private !== true)
+            providerSignals.push(`npm package ${pkg.name}`);
+    }
+    catch { /* no package.json */ }
+    const unique = [...new Set(providerSignals)];
+    const hasDeployDoc = fs.existsSync(path.join(root, 'docs', 'deploy.md'));
+    const todo = [];
+    if (remote === 'none')
+        todo.push('no Git remote: delivery is commit-and-merge only until one is added');
+    if (unique.length && !hasDeployDoc) {
+        todo.push('write docs/deploy.md (exact deploy command + production check), then add a deploy block pointing at it');
+    }
+    if (hasDeployDoc) {
+        todo.push('rename the "production" target to match docs/deploy.md; set pushDeploys=true if a push alone ships it');
+    }
+    return {
+        root,
+        providerSignals: unique,
+        todo,
+        profile: {
+            version: 1,
+            git: { defaultBranch, remote, integrationStrategy: 'merge', pushDeploys: false },
+            deploy: hasDeployDoc
+                ? { source: 'docs/deploy.md', canonicalRoot, targets: [{ id: 'production', procedureId: 'deploy:production' }] }
+                : undefined,
+        },
+    };
+}
 // adr: adr/delivery-profile.md
 function resolveDeliveryProfile(cwd) {
     const root = gitRoot(cwd);