claude-dev-env 2.7.0 → 2.7.1

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

@@ -258,6 +258,7 @@ const verifyObjectionModule = new Function(
   `${functionSource('parseLastVerdictFence')}\n` +
     `${constantLine('VERIFY_OBJECTION_FALLBACK')}\n` +
     `${functionSource('renderVerifyObjectionLine')}\n` +
+    `${functionSource('extractPreFenceProse')}\n` +
     `${functionSource('extractVerifyObjection')}\n` +
     'return { extractVerifyObjection, VERIFY_OBJECTION_FALLBACK };',
 )();
@@ -338,6 +339,78 @@ 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('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` +
@@ -468,7 +470,7 @@ function runVerifierTask(task, context) {
       "      ```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.`,
+      `      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.`,
     { label, phase: 'Converge', agentType: 'code-verifier', ...TIERS.sonnetMedium },
   )
 }
@@ -871,7 +873,7 @@ function buildVerdictFenceSteps(prOwner, prRepo, prNumber) {
     "   ```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.`
+    `   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.`
   )
 }
 
@@ -1343,14 +1345,61 @@ 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 on the same fence parseLastVerdictFence reads — the last CLOSED
+ * verdict fence, not the last bare marker — so a stray unterminated marker after
+ * the real fence can never make this read the verdict body itself as prose. 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) {
+  if (typeof verifyTranscript !== 'string') return null
+  const fenceMarker = '```verdict'
+  let lastFenceStart = verifyTranscript.lastIndexOf(fenceMarker)
+  while (lastFenceStart !== -1 && !verifyTranscript.slice(lastFenceStart + fenceMarker.length).includes('```')) {
+    lastFenceStart = verifyTranscript.lastIndexOf(fenceMarker, lastFenceStart - 1)
+  }
+  if (lastFenceStart === -1) return null
+  const proseParagraphs = verifyTranscript
+    .slice(0, lastFenceStart)
+    .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 +1410,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/grok-spawn/SKILL.md

@@ -125,7 +125,6 @@ Shape:
       "tool_profile": "readonly",
       "timeout_seconds": 600,
       "is_repo_only": true,
-      "max_turns": 8,
       "agent_name": null
     }
   ]
@@ -141,11 +140,14 @@ Shape:
 | `prompt_parts` | Ordered absolute paths to part files |
 | `cwd` | Working directory for that worker |
 | `tool_profile` | `readonly` or `build` |
-| `timeout_seconds` | Per-worker timeout (default 600) |
+| `timeout_seconds` | Per-worker timeout (default 600, ceiling 5400). A spec asking for more is refused |
 | `is_repo_only` | Readonly only: when true, also pass `--disable-web-search` |
-| `max_turns` | Turn cap (default 8) |
 | `agent_name` | Optional `--agent` name, or `null` |
 
+Workers run with no turn cap. The timeout is the only bound on a worker's
+length, and a worker that hits it is killed with its whole process tree and
+reported as `timeout`.
+
 Put the spec file under the run state directory (or any path you pass to
 `--spec`).
 

package/skills/grok-spawn/reference/flag-profiles.md

@@ -20,10 +20,12 @@ The headless runner always passes:
 | `--cwd` | Worker `cwd` from the batch spec |
 | `--output-format` | `json` |
 | `--always-approve` | present (auto-approve tool runs) |
-| `--max-turns` | Worker `max_turns` (default `8`) |
 | `--leader-socket` | Unique per-worker socket path under the run state dir |
 | `--debug-file` | Unique per-worker debug log (batch launcher adds this) |
 
+The runner passes no `--max-turns`. Worker length is bounded by the per-worker
+timeout alone. The preflight ping keeps its own single-turn cap.
+
 Optional:
 
 | Flag | When |