claude-dev-env 2.7.0 → 2.8.0

package/skills/autoconverge/workflow/converge.contract.test.mjs

@@ -411,8 +411,13 @@ test('the shared verdict-fence builder names the binding-hash command and the ve
     /verification_verdict_store\.py/,
     'expected the verdict-store script that computes the binding hash to be named',
   );
-  assert.match(fenceBuilder, /```verdict/, 'expected the verdict fence to be specified');
-  assert.match(fenceBuilder, /manifest_sha256/, 'expected the verdict fence to carry manifest_sha256');
+  assert.match(fenceBuilder, /buildVerdictFenceTail\(/, 'expected the fence builder to close with the shared fence tail');
+  const renderedFenceTail = loadVerdictFenceTailBuilder()('');
+  assert.match(renderedFenceTail, /```verdict/, 'expected the verdict fence to be specified');
+  assert.ok(
+    renderedFenceTail.includes(VERDICT_FENCE_JSON_LINE),
+    'expected the verdict fence to carry manifest_sha256',
+  );
   assert.match(
     fenceBuilder,
     /gh pr view/,
@@ -425,6 +430,100 @@ test('the shared verdict-fence builder names the binding-hash command and the ve
   );
 });
 
+test('the incomplete-verdict contract sentence is written once and used by both verify paths', () => {
+  const sentenceOccurrences = convergeSource.split(
+    'name that check in prose directly above the fence rather than in findings',
+  ).length - 1;
+  assert.equal(
+    sentenceOccurrences,
+    1,
+    'expected the incomplete-verdict contract sentence to be written exactly once so the two verify paths cannot drift',
+  );
+  assert.match(
+    lensPromptBody('buildVerdictFenceTail'),
+    /VERDICT_FENCE_CONTRACT_SENTENCE/,
+    'expected the shared fence tail to use the one contract sentence',
+  );
+  assert.match(
+    lensPromptBody('buildVerdictFenceSteps'),
+    /buildVerdictFenceTail\(/,
+    'expected the gh-lookup fence builder to reach the contract sentence through the shared fence tail',
+  );
+  assert.match(
+    lensPromptBody('runVerifierTask'),
+    /buildVerdictFenceTail\(/,
+    'expected the hardening-verify prompt to reach the contract sentence through the shared fence tail',
+  );
+});
+
+const VERDICT_FENCE_JSON_LINE = '{"all_pass": true, "findings": [], "manifest_sha256": "<that hash>"}';
+const VERDICT_FENCE_LEAD_IN = 'END your message with a fenced verdict block exactly in this shape';
+
+function countOccurrences(haystack, needle) {
+  return haystack.split(needle).length - 1;
+}
+
+function loadVerdictFenceTailBuilder() {
+  const sentenceMatch = /const VERDICT_FENCE_CONTRACT_SENTENCE =\s*\n?\s*'[^']*'/.exec(convergeSource);
+  assert.notEqual(sentenceMatch, null, 'expected VERDICT_FENCE_CONTRACT_SENTENCE to be declared as one string literal');
+  const builderSource = lensPromptBody('buildVerdictFenceTail');
+  return new Function(
+    `${sentenceMatch[0]}\n${builderSource}\nreturn buildVerdictFenceTail;`,
+  )();
+}
+
+test('the verdict fence recipe is written once — no verify path re-inlines its own copy', () => {
+  assert.equal(
+    countOccurrences(convergeSource, VERDICT_FENCE_JSON_LINE),
+    1,
+    'expected the verdict fence JSON skeleton to be written exactly once so no verify path can drift from the shared recipe',
+  );
+  assert.equal(
+    countOccurrences(convergeSource, VERDICT_FENCE_LEAD_IN),
+    1,
+    'expected the fence lead-in sentence to be written exactly once so no verify path can drift from the shared recipe',
+  );
+  assert.match(
+    lensPromptBody('buildVerdictFenceSteps'),
+    /buildVerdictFenceTail\(/,
+    'expected the gh-lookup binding path to render its fence through the shared tail builder',
+  );
+  assert.match(
+    lensPromptBody('runVerifierTask'),
+    /buildVerdictFenceTail\(/,
+    'expected the hardening-verify path to render its fence through the shared tail builder',
+  );
+});
+
+test('the shared fence tail renders the same fence JSON and contract sentence at every indent', () => {
+  const buildVerdictFenceTail = loadVerdictFenceTailBuilder();
+  const topLevelTail = buildVerdictFenceTail('');
+  const nestedTail = buildVerdictFenceTail('   ');
+  for (const [siteName, renderedTail] of [['top-level', topLevelTail], ['nested', nestedTail]]) {
+    assert.ok(
+      renderedTail.includes(VERDICT_FENCE_JSON_LINE),
+      `expected the ${siteName} fence tail to carry the verdict JSON skeleton`,
+    );
+    assert.ok(
+      renderedTail.includes(VERDICT_FENCE_LEAD_IN),
+      `expected the ${siteName} fence tail to carry the fence lead-in sentence`,
+    );
+    assert.ok(
+      renderedTail.includes('```verdict'),
+      `expected the ${siteName} fence tail to open a verdict fence`,
+    );
+    assert.ok(
+      renderedTail.includes('name that check in prose directly above the fence rather than in findings'),
+      `expected the ${siteName} fence tail to carry the one incomplete-verdict contract sentence`,
+    );
+  }
+  assert.equal(
+    nestedTail,
+    topLevelTail.split('\n').map((eachLine) => `   ${eachLine}`).join('\n'),
+    'expected indent to be the only difference between the two rendered fence tails',
+  );
+});
+
 test('the verdict-fence binding does not self-resolve a cwd via git rev-parse for the manifest hash', () => {
   const fenceBuilder = lensPromptBody('buildVerdictFenceSteps');
   assert.doesNotMatch(
@@ -434,7 +533,7 @@ test('the verdict-fence binding does not self-resolve a cwd via git rev-parse fo
   );
 });
 
-test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids edits', () => {
+test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids editing the tree under verification', () => {
   for (const verifyFunctionName of ['runVerifierTask']) {
     const verifyBody = lensPromptBody(verifyFunctionName);
     assert.match(
@@ -454,8 +553,8 @@ test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and fo
     );
     assert.match(
       verifyBody,
-      /do no edits|make no edits|not edit|no file edits/i,
-      `expected ${verifyFunctionName} to be told to make no edits`,
+      /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
+      `expected ${verifyFunctionName} to forbid editing the tree under verification (a deliberate break off that tree stays allowed)`,
     );
   }
 });
@@ -467,7 +566,7 @@ test('runFixerTask never verifies — verification belongs to the separate verif
   assert.match(fixerBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder for its commit and recovery edits');
 });
 
-test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids edits', () => {
+test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids editing the tree under verification', () => {
   const verifyBody = lensPromptBody('runVerifierTask');
   assert.match(
     verifyBody,
@@ -476,8 +575,8 @@ test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch
   );
   assert.match(
     verifyBody,
-    /do no edits|make no edits|not edit|no file edits/i,
-    'expected the verifier to be told to make no edits',
+    /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
+    'expected the verifier to forbid editing the tree under verification (a deliberate break off that tree stays allowed)',
   );
 });
 
@@ -901,6 +1000,28 @@ test('convergeReadOnlyAgent prepends HEADLESS_READONLY_PREAMBLE and the worktree
   );
 });
 
+test('the read-only destructive pointer scopes its no-edit clause to the tree it reads', () => {
+  const destructivePointer = convergeSource
+    .split('\n')
+    .find((eachLine) => eachLine.includes('Never run a destructive command'));
+  assert.ok(destructivePointer, 'expected the read-only destructive pointer to be declared');
+  assert.match(
+    destructivePointer,
+    /Never run a destructive command/,
+    'expected the destructive-command prohibition to stay absolute',
+  );
+  assert.match(
+    destructivePointer,
+    /no edit to the tree it reads/,
+    'expected the no-edit clause to be scoped to the tree under verification',
+  );
+  assert.doesNotMatch(
+    destructivePointer,
+    /edits nothing/,
+    'expected no blanket edits-nothing wording, which forbids the deliberate break off that tree',
+  );
+});
+
 const taskDispatchers = [
   { name: 'runGitTask', isAsync: false },
   { name: 'runFixerTask', isAsync: false },
@@ -984,6 +1105,7 @@ test('the whole priming spawn-agent family is removed — every dispatcher spawn
 
 test('parseLastVerdictFence returns non-null for a verdict fence with valid JSON', () => {
   const parseModule = new Function(
+    `${functionSource('findLastVerdictFence')}\n` +
     `${functionSource('parseLastVerdictFence')}\n` +
     'return { parseLastVerdictFence };',
   )();
@@ -994,6 +1116,7 @@ test('parseLastVerdictFence returns non-null for a verdict fence with valid JSON
 
 test('parseLastVerdictFence returns null for non-string input', () => {
   const parseModule = new Function(
+    `${functionSource('findLastVerdictFence')}\n` +
     `${functionSource('parseLastVerdictFence')}\n` +
     'return { parseLastVerdictFence };',
   )();
@@ -1003,6 +1126,7 @@ test('parseLastVerdictFence returns null for non-string input', () => {
 
 test('parseLastVerdictFence returns null when no verdict fence is present', () => {
   const parseModule = new Function(
+    `${functionSource('findLastVerdictFence')}\n` +
     `${functionSource('parseLastVerdictFence')}\n` +
     'return { parseLastVerdictFence };',
   )();
@@ -1011,6 +1135,7 @@ test('parseLastVerdictFence returns null when no verdict fence is present', () =
 
 test('parseLastVerdictFence returns null for malformed JSON in the fence', () => {
   const parseModule = new Function(
+    `${functionSource('findLastVerdictFence')}\n` +
     `${functionSource('parseLastVerdictFence')}\n` +
     'return { parseLastVerdictFence };',
   )();

package/skills/autoconverge/workflow/converge.fix-recovery.test.mjs

@@ -255,9 +255,11 @@ test('the round-loop fix-stalled blockers survive the recovery wiring', () => {
 });
 
 const verifyObjectionModule = new Function(
-  `${functionSource('parseLastVerdictFence')}\n` +
+  `${functionSource('findLastVerdictFence')}\n` +
+    `${functionSource('parseLastVerdictFence')}\n` +
     `${constantLine('VERIFY_OBJECTION_FALLBACK')}\n` +
     `${functionSource('renderVerifyObjectionLine')}\n` +
+    `${functionSource('extractPreFenceProse')}\n` +
     `${functionSource('extractVerifyObjection')}\n` +
     'return { extractVerifyObjection, VERIFY_OBJECTION_FALLBACK };',
 )();
@@ -338,6 +340,110 @@ test('extractVerifyObjection falls back when no finding yields usable text', ()
   assert.equal(extractVerifyObjection(transcript), VERIFY_OBJECTION_FALLBACK);
 });
 
+test('the prose reader anchors on the last CLOSED fence, not a stray unterminated marker', () => {
+  const transcript =
+    'check X never showed red\n\n' +
+    '```verdict\n{"all_pass": false, "findings": []}\n```\n\n' +
+    'and here I started to restate it\n\n' +
+    '```verdict';
+  const objection = extractVerifyObjection(transcript);
+  assert.equal(objection, 'check X never showed red');
+  assert.doesNotMatch(objection, /all_pass/, 'expected the verdict body never to be read back as prose');
+});
+
+test('both fence readers locate the fence through the one shared locator', () => {
+  assert.match(
+    functionSource('parseLastVerdictFence'),
+    /findLastVerdictFence\(/,
+    'expected the verdict parser to locate its fence through findLastVerdictFence',
+  );
+  assert.match(
+    functionSource('extractPreFenceProse'),
+    /findLastVerdictFence\(/,
+    'expected the prose reader to locate its fence through findLastVerdictFence, not a second search',
+  );
+  assert.doesNotMatch(
+    functionSource('extractPreFenceProse'),
+    /lastIndexOf\(/,
+    'expected no second fence-search procedure in the prose reader to drift from the parser',
+  );
+});
+
+test('the prose reader and the verdict parser land on the same fence when a later marker carries no newline', () => {
+  const transcript =
+    'check X never showed red\n\n' +
+    '```verdict\n{"all_pass": false, "findings": []}\n```\n\n' +
+    '```verdict {"all_pass": true, "findings": []}```';
+  const objection = extractVerifyObjection(transcript);
+  assert.doesNotMatch(
+    objection,
+    /all_pass/,
+    'expected the prose reader to anchor on the fence the parser read, never to slice a verdict body in as prose',
+  );
+  assert.equal(objection, 'check X never showed red');
+});
+
+test('the prose reader skips a scaffolding-only paragraph above the fence', () => {
+  const transcript =
+    'check X never showed red\n\n' + '## Verdict\n\n' + '```verdict\n{"all_pass": false, "findings": []}\n```';
+  assert.equal(extractVerifyObjection(transcript), 'check X never showed red');
+});
+
+const verifyRecoveryPromptModule = new Function(
+  `${constantLine('VERIFY_OBJECTION_FALLBACK')}\n` +
+    'const prCoordinates = "owner/repo#1";\n' +
+    'const PRE_COMMIT_GATE_STEP = "";\n' +
+    'const EDIT_SCHEMA = {};\n' +
+    'const TIERS = { sonnetMedium: {} };\n' +
+    'const convergeAgent = (spawnPrompt) => spawnPrompt;\n' +
+    `${functionSource('runCodeEditorTask')}\n` +
+    'return { runCodeEditorTask };',
+)();
+
+const { runCodeEditorTask: buildCodeEditorPrompt } = verifyRecoveryPromptModule;
+
+function buildVerifyRecoveryPrompt(verifyTranscript) {
+  return buildCodeEditorPrompt('verify-recover', {
+    objection: extractVerifyObjection(verifyTranscript),
+    head: 'deadbeefcafe',
+    sourceLabel: 'round-1 lens findings',
+    attempt: 1,
+  });
+}
+
+const INCOMPLETE_CHECK_SENTENCE =
+  'This verdict is incomplete: the deliberate break for check_docstring_runon_sentence never showed red, so that gate is unproven rather than failed.';
+
+test('an incomplete verdict carries its named check into the fixer prompt instead of the fallback', () => {
+  const transcript =
+    'I ran the named gates and read the diff against the task text.\n\n' +
+    `${INCOMPLETE_CHECK_SENTENCE}\n\n` +
+    '```verdict\n{"all_pass": false, "findings": [], "manifest_sha256": "0f1e2d"}\n```';
+  const fixerPrompt = buildVerifyRecoveryPrompt(transcript);
+  assert.match(fixerPrompt, /VERIFY-RECOVERY fixer/, 'expected the verify-recovery fixer prompt');
+  assert.ok(
+    fixerPrompt.includes(INCOMPLETE_CHECK_SENTENCE),
+    `expected the fixer prompt to carry the incomplete-check sentence, got:\n${fixerPrompt.slice(0, 600)}`,
+  );
+  assert.doesNotMatch(
+    fixerPrompt,
+    /without a parseable verdict/,
+    'expected the incomplete verdict never to reach the fixer as VERIFY_OBJECTION_FALLBACK',
+  );
+});
+
+test('a genuine code defect still reaches the fixer prompt from findings, unchanged by pre-fence prose', () => {
+  const transcript =
+    `${INCOMPLETE_CHECK_SENTENCE}\n\n` +
+    '```verdict\n{"all_pass": false, "findings": [{"check": "Finding 1", "detail": "boundary still over-blocks"}]}\n```';
+  const fixerPrompt = buildVerifyRecoveryPrompt(transcript);
+  assert.match(fixerPrompt, /1\. Finding 1 — boundary still over-blocks/);
+  assert.ok(
+    !fixerPrompt.includes(INCOMPLETE_CHECK_SENTENCE),
+    'expected findings to keep owning a verdict that names a code defect',
+  );
+});
+
 test('the verify-recover task in runCodeEditorTask is a clean-coder edit step bound to the verifier objection and leaves changes uncommitted', () => {
   const recoverBody = functionSource('runCodeEditorTask');
   assert.match(recoverBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder');

package/skills/autoconverge/workflow/converge.mjs

@@ -68,13 +68,15 @@ const HEADLESS_EDIT_PREAMBLE =
   '- When your run was given a result schema, your final action is always the StructuredOutput call. If the poll budget is spent before the awaited signal arrives, call StructuredOutput with the whole time-out result the step documents — for the Copilot gate, the full down result {sha, clean:false, down:true, findings:[]}, never a bare down flag — rather than ending the turn without a result.\n\n'
 
 const HEADLESS_READONLY_DESTRUCTIVE_POINTER =
-  '- Never run a destructive command (rm -rf, git reset --hard, dd, mkfs, chmod -R, a fork bomb) and never place its literal text in a Bash command: this step reads only and edits nothing, so it needs no destructive command. If a step seems to require one, report it as a blocker rather than running it.\n'
+  '- Never run a destructive command (rm -rf, git reset --hard, dd, mkfs, chmod -R, a fork bomb) and never place its literal text in a Bash command: this step makes no edit to the tree it reads, so it needs no destructive command. If a step seems to require one, report it as a blocker rather than running it.\n'
 
 /**
  * The read-only preamble a review, verify, or utility agent receives: the full
- * edit preamble with the rm-shape-rules bullet dropped, since an agent that edits
- * nothing never runs rm and the shape rules add no value to its prompt. The
- * one-line destructive pointer keeps the escape-hatch guidance in view. The
+ * edit preamble with the rm-shape-rules bullet dropped, since an agent that makes
+ * no edit in the tree it reads never runs rm against that tree, and the one file
+ * it may touch off that tree — a deliberate break at a break site outside it —
+ * is an edit rather than a delete, so the shape rules add no value to its
+ * prompt. The one-line destructive pointer keeps the escape-hatch guidance in view. The
  * derivation reads the single rm-shape bullet out of the edit preamble and swaps
  * the pointer in, so the two preambles share every other clause from one source.
  */
@@ -430,7 +432,7 @@ function runVerifierTask(task, context) {
   if (task === 'fix-verify') {
     const findingsBlock = renderFindingsBlock(context.findings)
     return convergeReadOnlyAgent(
-      `You are the VERIFY step for ${context.findings.length} finding(s) (${context.sourceLabel}) on ${prCoordinates}, HEAD ${context.head}. The edit step left fixes in the working tree, uncommitted. Do NO edits of any kind — verification only; any edit invalidates the verdict you are about to emit.\n\n` +
+      `You are the VERIFY step for ${context.findings.length} finding(s) (${context.sourceLabel}) on ${prCoordinates}, HEAD ${context.head}. The edit step left fixes in the working tree, uncommitted. Make NO edit to the tree under verification — verification only; any edit inside that tree invalidates the verdict you are about to emit.\n\n` +
         `Findings the working-tree fixes must address:\n${findingsBlock}\n\n` +
         `Steps:\n` +
         `1. Resolve the worktree repo root for running tests: REPO=$(git rev-parse --show-toplevel).\n` +
@@ -444,7 +446,7 @@ function runVerifierTask(task, context) {
       ? context.failures.map((each, position) => `${position + 1}. ${each}`).join('\n')
       : 'none reported'
     return convergeReadOnlyAgent(
-      `You are the VERIFY step for the convergence repair on ${prCoordinates}, HEAD ${context.head}. The edit step left its repair in the working tree (a bot-thread fix uncommitted, and/or a rebase onto origin/main), unpushed. Do NO edits of any kind — verification only; any edit invalidates the verdict you are about to emit.\n\n` +
+      `You are the VERIFY step for the convergence repair on ${prCoordinates}, HEAD ${context.head}. The edit step left its repair in the working tree (a bot-thread fix uncommitted, and/or a rebase onto origin/main), unpushed. Make NO edit to the tree under verification — verification only; any edit inside that tree invalidates the verdict you are about to emit.\n\n` +
         `Concerns the working-tree repair must resolve (the gates the convergence check flagged):\n${failureBlock}\n\n` +
         `Steps:\n` +
         `1. Resolve the worktree repo root for running tests: REPO=$(git rev-parse --show-toplevel).\n` +
@@ -454,7 +456,7 @@ function runVerifierTask(task, context) {
     )
   }
   return convergeReadOnlyAgent(
-    `You are the VERIFY step for an environment-hardening change (${context.sourceLabel}) staged in the working tree of ${context.hardeningRepoPath}. The edit step left the hooks/rules edits uncommitted there. Do NO edits of any kind — verification only; any edit invalidates the verdict you are about to emit.\n\n` +
+    `You are the VERIFY step for an environment-hardening change (${context.sourceLabel}) staged in the working tree of ${context.hardeningRepoPath}. The edit step left the hooks/rules edits uncommitted there. Make NO edit to the tree under verification — verification only; any edit inside that tree invalidates the verdict you are about to emit.\n\n` +
       `Concern the working-tree change must resolve: the edited hooks/rules block the code-standard violation classes from the deferred round at Write/Edit time, and a hook change carries a passing test per CODE_RULES.\n\n` +
       `Steps:\n` +
       `1. cd into ${context.hardeningRepoPath}, then resolve its repo root: REPO=$(git rev-parse --show-toplevel).\n` +
@@ -464,11 +466,7 @@ function runVerifierTask(task, context) {
       `   Run exactly:\n` +
       `      "C:\\Python313\\python.exe" "<REPO>/packages/claude-dev-env/hooks/blocking/verification_verdict_store.py" --manifest-hash-for-branch "${context.hardeningBranch}"\n` +
       `   (substitute the REPO path you resolved for the script path). That prints a single 64-char hex hash on stdout — capture it.\n` +
-      `   Then END your message with a fenced verdict block exactly in this shape, on its own, carrying that hash:\n` +
-      "      ```verdict\n" +
-      `      {"all_pass": true, "findings": [], "manifest_sha256": "<that hash>"}\n` +
-      "      ```\n" +
-      `      When verification fails, set all_pass to false and list the unresolved concerns in findings; still include the manifest_sha256. The verdict fence must be the last thing in your message.`,
+      buildVerdictFenceTail('   '),
     { label, phase: 'Converge', agentType: 'code-verifier', ...TIERS.sonnetMedium },
   )
 }
@@ -847,6 +845,29 @@ const HARDENING_COMMIT_SCHEMA = {
   required: ['hardeningPrUrl', 'summary'],
 }
 
+const VERDICT_FENCE_CONTRACT_SENTENCE =
+  'Set all_pass to false when verification fails, and list every code defect you found in findings. When the verdict is incomplete because a check it rests on never showed red, set all_pass to false and name that check in prose directly above the fence rather than in findings. Always include the manifest_sha256. The verdict fence must be the last thing in your message.'
+
+/**
+ * Build the closing fence recipe every verify prompt ends with: the lead-in
+ * sentence, the ```verdict block shape carrying the binding hash, and the
+ * contract sentence. Each verify path resolves the binding hash its own way
+ * and sits at its own nesting depth, so the caller passes the indent its
+ * surrounding prose uses; the fence body itself sits one level deeper.
+ * @param {string} indent leading whitespace the caller's prose sits at
+ * @returns {string} the fence recipe tail for a verify prompt
+ */
+function buildVerdictFenceTail(indent) {
+  const fenceIndent = `${indent}   `
+  return (
+    `${indent}Then END your message with a fenced verdict block exactly in this shape, on its own, carrying that hash:\n` +
+    `${fenceIndent}` + "```verdict\n" +
+    `${fenceIndent}{"all_pass": true, "findings": [], "manifest_sha256": "<that hash>"}\n` +
+    `${fenceIndent}` + "```\n" +
+    `${fenceIndent}${VERDICT_FENCE_CONTRACT_SENTENCE}`
+  )
+}
+
 /**
  * Build the verdict-fence step instructions for a verify agent, binding the
  * surface hash by branch name rather than by a self-resolved cwd. Resolving
@@ -867,11 +888,7 @@ function buildVerdictFenceSteps(prOwner, prRepo, prNumber) {
     `   b. Run exactly:\n` +
     `         "C:\\Python313\\python.exe" "<REPO>/packages/claude-dev-env/hooks/blocking/verification_verdict_store.py" --manifest-hash-for-branch "<that branch>"\n` +
     `      (substitute the REPO path you resolved for the script path, and the branch name for <that branch>). That prints a single 64-char hex hash on stdout — capture it.\n` +
-    `Then END your message with a fenced verdict block exactly in this shape, on its own, carrying that hash:\n` +
-    "   ```verdict\n" +
-    `   {"all_pass": true, "findings": [], "manifest_sha256": "<that hash>"}\n` +
-    "   ```\n" +
-    `   When verification fails, set all_pass to false and list the unresolved concerns in findings; still include the manifest_sha256. The verdict fence must be the last thing in your message.`
+    buildVerdictFenceTail('')
   )
 }
 
@@ -1280,23 +1297,45 @@ function normalizeShaForComparison(sha) {
 }
 
 /**
- * Parse the LAST ```verdict ...``` fenced JSON block from a transcript.
- * Guards against non-string input, iterates all fence matches for the last one,
- * parses the JSON, and returns the object or null on any failure.
+ * Locate the LAST ```verdict ...``` fence in a transcript: the marker, optional
+ * whitespace, a required newline, then a body closed by ```. This is the ONE
+ * definition of "the verdict fence" — the verdict parser and the pre-fence prose
+ * reader both anchor here, so they cannot land on different fences.
+ *
+ * ::
+ *
+ *   ok:   'note\n\n```verdict\n{}\n```'  -> body '{}\n' starting at index 6
+ *   flag: 'note\n\n```verdict {}```'     -> null (no newline after the marker)
+ *
+ * A marker with no newline after it is not a fence, so a later one cannot pull
+ * either reader off the fence the other reads.
+ *
  * @param {string|null|undefined} transcript the agent transcript text
- * @returns {object|null} the parsed verdict object, or null when absent or malformed
+ * @returns {{bodyText: string, startIndex: number}|null} the last fence, or null when there is none
  */
-function parseLastVerdictFence(transcript) {
+function findLastVerdictFence(transcript) {
   if (typeof transcript !== 'string') return null
   const fencePattern = /```verdict\s*\n([\s\S]*?)```/g
-  let lastFenceBody = null
+  let lastFence = null
   let eachMatch
   while ((eachMatch = fencePattern.exec(transcript)) !== null) {
-    lastFenceBody = eachMatch[1]
+    lastFence = { bodyText: eachMatch[1], startIndex: eachMatch.index }
   }
-  if (lastFenceBody === null) return null
+  return lastFence
+}
+
+/**
+ * Parse the LAST ```verdict ...``` fenced JSON block from a transcript.
+ * Guards against non-string input, takes the fence findLastVerdictFence locates,
+ * parses the JSON, and returns the object or null on any failure.
+ * @param {string|null|undefined} transcript the agent transcript text
+ * @returns {object|null} the parsed verdict object, or null when absent or malformed
+ */
+function parseLastVerdictFence(transcript) {
+  const lastFence = findLastVerdictFence(transcript)
+  if (lastFence === null) return null
   try {
-    return JSON.parse(lastFenceBody)
+    return JSON.parse(lastFence.bodyText)
   } catch {
     return null
   }
@@ -1343,14 +1382,57 @@ function renderVerifyObjectionLine(eachFinding) {
   return stringifiedFinding === '{}' ? null : stringifiedFinding
 }
 
+/**
+ * Read the prose paragraph the verifier wrote directly above its last verdict
+ * fence. A verdict that is incomplete — a check it rests on never showed red —
+ * is not a code defect, so the fence contract puts that reason here rather than
+ * in findings; this reader is how the reason survives into the re-fix step.
+ *
+ * Anchors through findLastVerdictFence, the single locator parseLastVerdictFence
+ * reads its JSON from, so both readers see the same fence by construction rather
+ * than by two searches that happen to agree: a stray marker after the real fence
+ * — unterminated, or closed but carrying no newline after the marker — moves
+ * neither reader. A candidate paragraph carrying only markdown scaffolding (a
+ * heading, a fence delimiter) is skipped, since handing the fixer a heading is
+ * worse than the generic fallback the caller keeps.
+ *
+ * ::
+ *
+ *   'ran the gates\n\ncheck X never showed red\n\n```verdict\n{}\n```'
+ *     -> 'check X never showed red'
+ *   '```verdict\n{}\n```'  -> null
+ *
+ * @param {string|null|undefined} verifyTranscript the verifier transcript text
+ * @returns {string|null} the last prose paragraph above the final fence, or null when there is none
+ */
+function extractPreFenceProse(verifyTranscript) {
+  const lastFence = findLastVerdictFence(verifyTranscript)
+  if (lastFence === null) return null
+  const proseParagraphs = verifyTranscript
+    .slice(0, lastFence.startIndex)
+    .split(/\n\s*\n/)
+    .map((eachParagraph) => eachParagraph.trim())
+    .filter((eachParagraph) =>
+      eachParagraph
+        .split('\n')
+        .some((eachLine) => {
+          const trimmedLine = eachLine.trim()
+          return trimmedLine.length > 0 && !trimmedLine.startsWith('#') && !trimmedLine.startsWith('```') && /[A-Za-z]/.test(trimmedLine)
+        }),
+    )
+  return proseParagraphs.length === 0 ? null : proseParagraphs[proseParagraphs.length - 1]
+}
+
 /**
  * Pull the verifier's stated objections out of a failed verify transcript so the
  * re-fix step knows what the verdict rejected. Reads the last fenced verdict JSON
  * (the same block verdictPassed reads) and renders each finding through
- * renderVerifyObjectionLine into a numbered list. A missing fence, a parse
- * failure, an empty findings list, or a findings list where no entry yields
- * usable text falls back to a generic re-read instruction, so the re-fix step
- * always receives actionable text.
+ * renderVerifyObjectionLine into a numbered list. When findings yields no usable
+ * line the verdict is an incomplete one rather than a code-defect one, so the
+ * prose paragraph above the fence — where the fence contract puts the unshown-red
+ * check — carries the objection instead. A missing fence, a parse failure, or an
+ * empty findings list with no prose above the fence falls back to a generic
+ * re-read instruction, so the re-fix step always receives actionable text.
  * @param {string|null|undefined} verifyTranscript the failed verifier transcript text
  * @returns {string} a human-readable block of the verifier's objections
  */
@@ -1361,7 +1443,7 @@ function extractVerifyObjection(verifyTranscript) {
   const renderedObjections = allObjections
     .map((eachFinding) => renderVerifyObjectionLine(eachFinding))
     .filter((eachLine) => eachLine !== null)
-  if (renderedObjections.length === 0) return VERIFY_OBJECTION_FALLBACK
+  if (renderedObjections.length === 0) return extractPreFenceProse(verifyTranscript) || VERIFY_OBJECTION_FALLBACK
   return renderedObjections.map((eachLine, position) => `${position + 1}. ${eachLine}`).join('\n')
 }
 

package/skills/codex-review/scripts/codex_review_scripts_constants/codex_usage_probe_constants.py

@@ -22,10 +22,6 @@ WINDOWS_OS_NAME = "nt"
 WINDOWS_COMMAND_SHELL = "cmd"
 WINDOWS_COMMAND_SHELL_RUN_FLAG = "/c"
 ALL_WINDOWS_SCRIPT_SUFFIXES = (".cmd", ".bat")
-WINDOWS_TASKKILL_COMMAND = "taskkill"
-WINDOWS_TASKKILL_FORCE_FLAG = "/F"
-WINDOWS_TASKKILL_TREE_FLAG = "/T"
-WINDOWS_TASKKILL_PID_FLAG = "/PID"
 
 JSONRPC_VERSION = "2.0"
 JSONRPC_KEY_ID = "id"