@julioborges/gantry 0.1.0 → 1.0.3

package/.agents/skills/gantry/SKILL.md

@@ -28,6 +28,34 @@ Before a Run, resolve these values once and pass them as `args` to every referen
    `<repoRoot>/.gantry/config.json` when present. A missing repository policy is valid.
 4. `paths` comes from `common.resolve_workflow_paths(repoRoot, scopeSlug)`. Prompts receive paths, not
    repository-specific literals.
+5. `caveman` comes from resolving repository preference `policy["caveman"]` and host availability
+   via `caveman.resolve_activation(policy, harness=hostHarness, root=repoRoot, warned=args.cavemanWarned)`.
+   When active, the coordinating agent, planning roles (Requirement Critic, research, Planner, Plan Critic)
+   and round roles (Implementer, Reviewer, Critic, optional Learner) across all initial calls, retries,
+   review fixes and correction passes receive concise phrasing instructions for conversational messages
+   and summaries along with supported external-skill access, while all Specs, draft Issues, code,
+   documentation, lesson candidates, PR descriptions, Result Contracts, exact commands, exact errors,
+   acceptance criteria and verification evidence retain full detail. If enabled in policy but unavailable
+   in the host environment, emit at most one actionable warning per Run with installation guidance and
+   continue with normal behavior without claiming live token savings; a disabled preference does not load
+   the skill. The manual harness-neutral path carries the same instructions.
+6. `roles` comes from resolving repository defaults under `policy["execution"]["roles"]` overlaid by
+   optional Run and Issue overrides via `execution.resolve_roles()`. Preflight validates that every selected
+   combination is supported, executable, meets minimum installed harness version requirements, and authenticated
+   (via `execution.preflight_validate()`), refusing to start implementation when validation fails. Derived roles
+   (`requirement-critic`, `plan-critic`, `learner` inheriting from `critic`, and `research` from `plan`) adopt
+   parent defaults unless explicitly set. Bounded native harness invocations execute roles across Codex CLI,
+   Claude Code, OpenCode, and Antigravity (`agy --print`) while the Host Harness retains coordination. External
+   results pass `result.py` contract validation, missing or invalid results trigger Protocol Failure handling,
+   unsupported installed versions are rejected, Critic verification fails visibly on permission or tool limitations,
+   selection identity is honestly recorded in the Run log, and native or configured automatic model fallback
+   is detected and rejected. Runtime execution failures preserve work and pause the affected Issue separately
+   from Critic refutations and protocol failures; independent Issues integrate serially, while the next round
+   waits for explicit recovery without automatic fallback or retry. Explicit Issue-role replacements are
+   validated and recorded via `role.changed`, leave saved repository defaults and running agents unchanged, and
+   preserve spent correction budgets. Run log selection (`role.selected`) and change (`role.changed`) events
+   record requested and effective selection evidence without command outputs or credentials. Model strength
+   guidance between roles is advisory and does not block valid cross-family selections.
 
 Run the standard-library workflow scripts as `python3 <skillDir>/scripts/<script>.py`. `common.py` provides
 the shared Markdown parser and policy resolution; its `--json` path prints the resolved portable runtime.
@@ -123,7 +151,9 @@ Every script provides `--help`, and data-producing paths support `--json`.
   and Spec axes, one review fix pass, then a fresh adversarial Critic. The Critic alone can establish a
   complete delivery. Its refutation consumes at most the correction budget.
 - A multi-Issue round uses one isolated worktree and branch per implementer. Integrate accepted branches
-  serially, run gates after every merge, and stop on a failed integration gate. Create and identify each
+  serially, run gates after every merge, and stop on a failed integration gate. When an Issue execution fails,
+  pause that Issue, preserve its worktree and branch, allow independent accepted Issues to integrate, and block
+  the next round until explicit validated recovery. Create and identify each
   Issue branch through the `git.issueBranch` policy template (default
   `{prefix}{spec}-{number:02d}`), rendered by `common.issue_branch(policy, issue)`.
 - Only after Critic acceptance, green gates and a clean worktree may the orchestrator run
@@ -163,4 +193,5 @@ command's stdin, not appended to the command line. Every recorded Run event goes
   critic and mandatory operator stop.
 - `reference/round-workflow.md` — TDD implementation, two-axis review, adversarial Critic and serial
   integration contract.
+- `docs/role-execution.md` — cross-harness execution, model discovery, role overrides, and failure recovery.
 - `templates/` — default Spec, PRD and Issue structures.

package/.agents/skills/gantry/capabilities/antigravity.json

@@ -0,0 +1,15 @@
+{
+  "tier": "compatible",
+  "hooks": true,
+  "structured_output": true,
+  "worktree_isolation": true,
+  "per_role_model": true,
+  "parallel_round": true,
+  "skills_path": ".agents/skills",
+  "hook_events": ["PreToolUse", "PostToolUse"],
+  "payload_fields": ["tool_name", "tool_input", "session_id"],
+  "models": {
+    "gemini-3.8-flash-medium": {"contextWindow": 1000000},
+    "gemini-3.1-pro-high": {"contextWindow": 1000000}
+  }
+}

package/.agents/skills/gantry/hooks/antigravity.hooks.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 \".agents/skills/gantry/scripts/guard.py\" PreToolUse --json"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 \".agents/skills/gantry/scripts/guard.py\" PostToolUse --json"
+          }
+        ]
+      }
+    ]
+  }
+}

package/.agents/skills/gantry/reference/plan-workflow.md

@@ -82,6 +82,16 @@ const targetText = t.kind === 'goal' ? `the goal "${t.goal}" (new slug: ${t.slug
   : t.kind === 'issue' ? `the Issue at ${t.issuePath} (Spec ${t.specPath})`
   : `the Spec at ${t.specPath} (slug ${t.slug})`
 
+const cavemanState = A.caveman || { active: false, preference: false, scope: 'none' }
+const cavemanActive = Boolean(cavemanState && cavemanState.active)
+if (cavemanState && cavemanState.warning) {
+  if (typeof log === 'function') log(cavemanState.warning)
+  cavemanState.warned = true
+}
+const cavemanInstruction = cavemanActive
+  ? 'Caveman lite is active: use concise phrasing for conversational messages and summaries. Specs, draft Issues, persisted role results, exact errors, commands, and acceptance criteria retain full detail.'
+  : ''
+
 async function validateSpecBeforePlanning() {
   if (t.kind === 'goal') return null
   const specPath = t.specPath || paths.specPath
@@ -138,17 +148,38 @@ async function validRoleResult(role, result) {
 }
 
 async function requestRole(role, prompt, options) {
+  const selection = (options && options.selection) || (A.roles && A.roles[role])
+  const hostHarness = A.hostHarness || 'claude-code'
+  if (selection && selection.harness && selection.harness !== hostHarness) {
+    const cwd = (options && options.cwd) || A.repoRoot
+    const selectionJson = JSON.stringify(selection)
+    const agentPrompt = cavemanActive ? `${prompt}\n\n${cavemanInstruction}` : prompt
+    const cmd = `python3 "${scripts}/execution.py" dispatch --role "${role}" --cwd ${shellQuote(cwd)} --selection '${selectionJson.replaceAll("'", "'\\''")}'`
+    const res = await runCommand(cmd, { cwd: A.repoRoot, input: agentPrompt })
+    if (res && res.exitCode === 0) {
+      try {
+        return JSON.parse(res.stdout)
+      } catch (e) {
+        return null
+      }
+    }
+    return null
+  }
   const native = A.structuredOutput === true
-  const result = await agent(prompt, {
+  const agentPrompt = cavemanActive ? `${prompt}\n\n${cavemanInstruction}` : prompt
+  const agentOptions = {
     ...options,
+    ...(cavemanActive ? { skills: (options.skills || []).concat(cavemanState.skill_path || 'caveman'), caveman: true } : {}),
     ...(native ? { schema: await roleSchema(role) } : {}),
-  })
+  }
+  const result = await agent(agentPrompt, agentOptions)
   if (await validRoleResult(role, result)) return result
-  const retry = await agent(`${prompt}\nYour prior result was invalid. Return the complete ${role} result contract.`, {
-    ...options,
+  const retryPrompt = `${agentPrompt}\nYour prior result was invalid. Return the complete ${role} result contract.`
+  const retryOptions = {
+    ...agentOptions,
     label: `${options.label}:retry`,
-    ...(native ? { schema: await roleSchema(role) } : {}),
-  })
+  }
+  const retry = await agent(retryPrompt, retryOptions)
   return (await validRoleResult(role, retry)) ? retry : null
 }
 
@@ -282,14 +313,21 @@ and budgets as structured output.`
 }
 
 phase('Research')
+const researchPrompt = (text) => (cavemanActive ? `${text}\n\n${cavemanInstruction}` : text)
+const researchOptions = (opts) => ({
+  ...opts,
+  phase: 'Research',
+  model: A.models.plan,
+  ...(cavemanActive ? { skills: (opts.skills || []).concat(cavemanState.skill_path || 'caveman'), caveman: true } : {}),
+})
 const research = await parallel([
-  () => agent(`Survey ${A.repoRoot}: conventions, current code/tests, ${paths.context}, and ${paths.adrs}.
-Return facts and paths for the Planner.`, { label: 'research:codebase', phase: 'Research', model: A.models.plan }),
-  () => agent(`Read ${t.specPath || paths.specPath}, ${paths.decisions}, and the relevant repository documents.
-Return owned and consumed contracts, settled decisions, and the testing seam.`, { label: 'research:spec', phase: 'Research', model: A.models.plan }),
-  () => agent(`Read ${paths.exemplarIssue} and ${paths.issueTracker}. Run
-\`python3 ${scripts}/frontier.py --scope frontier --json\`. Return the exact Issue format and frontier facts.`,
-    { label: 'research:format', phase: 'Research', model: A.models.plan }),
+  () => agent(researchPrompt(`Survey ${A.repoRoot}: conventions, current code/tests, ${paths.context}, and ${paths.adrs}.
+Return facts and paths for the Planner.`), researchOptions({ label: 'research:codebase' })),
+  () => agent(researchPrompt(`Read ${t.specPath || paths.specPath}, ${paths.decisions}, and the relevant repository documents.
+Return owned and consumed contracts, settled decisions, and the testing seam.`), researchOptions({ label: 'research:spec' })),
+  () => agent(researchPrompt(`Read ${paths.exemplarIssue} and ${paths.issueTracker}. Run
+\`python3 ${scripts}/frontier.py --scope frontier --json\`. Return the exact Issue format and frontier facts.`),
+    researchOptions({ label: 'research:format' })),
 ])
 
 phase('Plan')
@@ -379,5 +417,5 @@ async function approvePlan() {
 }
 
 const approved = await approvePlan()
-return { target: t, structuralValidation, requirementReview, plan, critique, awaitingOperatorApproval: !approved, approved }
+return { target: t, structuralValidation, requirementReview, plan, critique, caveman: cavemanState, awaitingOperatorApproval: !approved, approved }
 ```

package/.agents/skills/gantry/reference/round-workflow.md

@@ -166,6 +166,16 @@ const budget = Number.isInteger(requestedBudget) && requestedBudget >= 0
 const runLogEnabled = Boolean(A.runId && A.unitId)
 const stateRootFlag = A.stateRoot ? ` --state-root '${String(A.stateRoot).replaceAll("'", "'\\''")}'` : ''
 
+const cavemanState = A.caveman || { active: false, preference: false, scope: 'none' }
+const cavemanActive = Boolean(cavemanState && cavemanState.active)
+if (cavemanState && cavemanState.warning) {
+  if (typeof log === 'function') log(cavemanState.warning)
+  cavemanState.warned = true
+}
+const cavemanInstruction = cavemanActive
+  ? 'Caveman lite is active: use concise phrasing for conversational messages and summaries. Code, documentation, lesson candidates, PR descriptions, Result Contracts, exact commands, exact errors, acceptance criteria, and verification evidence retain full detail.'
+  : ''
+
 function canonical(value) {
   if (Array.isArray(value)) return value.map(canonical)
   if (value && typeof value === 'object') {
@@ -302,6 +312,104 @@ async function roleSchema(role) {
   return JSON.parse(result.stdout)
 }
 
+function resolveRoleForIssue(issueRef, role, options) {
+  if (options && options.selection) return options.selection
+  if (issueRef && A.issueRoleReplacements && A.issueRoleReplacements[issueRef] && A.issueRoleReplacements[issueRef][role]) {
+    return A.issueRoleReplacements[issueRef][role]
+  }
+  if (issueRef && A.issueRoles && A.issueRoles[issueRef] && A.issueRoles[issueRef][role]) {
+    return A.issueRoles[issueRef][role]
+  }
+  const roleKey = role === 'implementer' ? 'implement' : role === 'reviewer' ? 'review' : role
+  if (A.roles && (A.roles[role] || A.roles[roleKey])) {
+    return A.roles[role] || A.roles[roleKey]
+  }
+  if (A.models && (A.models[role] || A.models[roleKey])) {
+    return { harness: A.hostHarness || 'claude-code', model: A.models[role] || A.models[roleKey] }
+  }
+  return null
+}
+
+async function logRoleSelected(issueRef, role, selection) {
+  const isSelectionConfigured = Boolean(A.roles || A.issueRoles || A.issueRoleReplacements || A.recordRoleSelection)
+  if (!runLogEnabled || !selection || !issueRef || !isSelectionConfigured) return
+  await appendRunEvent('role.selected', issueRef, undefined, {
+    role,
+    issue: issueRef,
+    requested: selection,
+    effective: selection,
+    evidence: { source: 'role_selection' },
+  })
+}
+
+// Check for unresolved execution failures
+let unresolvedFailures = Array.isArray(A.unresolvedFailures) ? [...A.unresolvedFailures] : []
+if (unresolvedFailures.length === 0 && runLogEnabled && !isFirstRound) {
+  try {
+    const unresCheck = await runCommand(
+      `python3 "${scripts}/execution.py" unresolved-failures '${A.unitId}' '${A.runId}'${stateRootFlag} --json`,
+      { cwd: A.repoRoot },
+    )
+    if (unresCheck && unresCheck.exitCode === 0) {
+      unresolvedFailures = JSON.parse(unresCheck.stdout)
+    }
+  } catch (e) {}
+}
+
+if (unresolvedFailures.length > 0) {
+  const remainingUnresolved = []
+  for (const failure of unresolvedFailures) {
+    const replacement = resolveRoleForIssue(failure.issue, failure.role, null)
+    const hasReplacement = Boolean(
+      replacement &&
+      ((A.issueRoles && A.issueRoles[failure.issue] && A.issueRoles[failure.issue][failure.role]) ||
+       (A.issueRoleReplacements && A.issueRoleReplacements[failure.issue] && A.issueRoleReplacements[failure.issue][failure.role]))
+    )
+    if (hasReplacement) {
+      const repJson = JSON.stringify(replacement)
+      const valCmd = `python3 "${scripts}/execution.py" validate-replacement --issue "${failure.issue}" --role "${failure.role}" --selection '${repJson.replaceAll("'", "'\\''")}' --cwd ${shellQuote(A.repoRoot)} --json`
+      const valRes = await runCommand(valCmd, { cwd: A.repoRoot })
+      let valid = false
+      if (valRes && valRes.exitCode === 0) {
+        try {
+          const parsed = JSON.parse(valRes.stdout)
+          valid = parsed.valid === true
+        } catch (e) {}
+      }
+      if (!valid) {
+        return {
+          round: A.round,
+          blocked: true,
+          nextRoundBlocked: true,
+          reason: 'invalid_role_replacement',
+          error: `Invalid replacement selection for ${failure.issue} role ${failure.role}`,
+          results: [],
+        }
+      }
+      await appendRunEvent('role.changed', failure.issue, undefined, {
+        role: failure.role,
+        issue: failure.issue,
+        previous: failure.selection || { harness: 'unknown' },
+        requested: replacement,
+        effective: replacement,
+        evidence: { source: 'explicit_recovery' },
+      })
+    } else {
+      remainingUnresolved.push(failure)
+    }
+  }
+  if (remainingUnresolved.length > 0) {
+    return {
+      round: A.round,
+      blocked: true,
+      nextRoundBlocked: true,
+      reason: 'unresolved_execution_failure',
+      unresolvedFailures: remainingUnresolved,
+      results: [],
+    }
+  }
+}
+
 async function validRoleResult(role, result) {
   if (!result) return false
   if (A.structuredOutput === true) return true
@@ -312,18 +420,62 @@ async function validRoleResult(role, result) {
   return Boolean(validation && validation.exitCode === 0)
 }
 async function requestRole(role, prompt, options) {
+  const issueRef = options && options.issueRef
+  const selection = resolveRoleForIssue(issueRef, role, options)
+  const hostHarness = A.hostHarness || 'claude-code'
+  if (options && options.executionUnavailable) {
+    return { executionUnavailable: true, error: options.error || 'Role execution unavailable' }
+  }
+  if (selection && selection.harness && selection.harness !== hostHarness) {
+    const cwd = (options && options.cwd) || A.repoRoot
+    const selectionJson = JSON.stringify(selection)
+    const agentPrompt = cavemanActive ? `${prompt}\n\n${cavemanInstruction}` : prompt
+    const cmd = `python3 "${scripts}/execution.py" dispatch --role "${role}" --cwd ${shellQuote(cwd)} --selection '${selectionJson.replaceAll("'", "'\\''")}'`
+    const res = await runCommand(cmd, { cwd: A.repoRoot, input: agentPrompt })
+    if (res && res.exitCode === 0) {
+      try {
+        return JSON.parse(res.stdout)
+      } catch (e) {
+        return null
+      }
+    }
+    if (res && res.exitCode === 2) {
+      return null
+    }
+    return { executionUnavailable: true, error: (res && res.stderr) || 'Harness execution failed' }
+  }
   const native = A.structuredOutput === true
   const schema = native ? await roleSchema(role) : null
-  const result = await agent(prompt, {
+  const agentPrompt = cavemanActive ? `${prompt}\n\n${cavemanInstruction}` : prompt
+  const agentOptions = {
     ...options,
+    ...(cavemanActive ? { skills: (options.skills || []).concat(cavemanState.skill_path || 'caveman'), caveman: true } : {}),
     ...(schema ? { schema } : {}),
-  })
+  }
+  let result
+  try {
+    result = await agent(agentPrompt, agentOptions)
+  } catch (err) {
+    return { executionUnavailable: true, error: String(err && err.message ? err.message : err) }
+  }
+  if (result && result.executionUnavailable) {
+    return { executionUnavailable: true, error: result.error || 'Execution unavailable' }
+  }
   if (await validRoleResult(role, result)) return result
-  const retry = await agent(`${prompt}\nYour prior result was invalid. Return the complete ${role} result contract.`, {
-    ...options,
+  const retryPrompt = `${agentPrompt}\nYour prior result was invalid. Return the complete ${role} result contract.`
+  const retryOptions = {
+    ...agentOptions,
     label: `${options.label}:retry`,
-    ...(schema ? { schema } : {}),
-  })
+  }
+  let retry
+  try {
+    retry = await agent(retryPrompt, retryOptions)
+  } catch (err) {
+    return { executionUnavailable: true, error: String(err && err.message ? err.message : err) }
+  }
+  if (retry && retry.executionUnavailable) {
+    return { executionUnavailable: true, error: retry.error || 'Execution unavailable' }
+  }
   return (await validRoleResult(role, retry)) ? retry : null
 }
 
@@ -500,13 +652,20 @@ refutations, gateResult, gateFailures and decisionsForOperator as structured out
 async function implement(issue, feedback, previous) {
   const assigned = await implementationLocation(issue, previous)
   if (!assigned) return null
+  const selection = resolveRoleForIssue(issue.ref, 'implementer', null)
+  await logRoleSelected(issue.ref, 'implementer', selection)
   const options = {
     label: `implement:${issue.ref}`, phase: 'Implement', model: A.models.implement, cwd: assigned.worktree,
+    issueRef: issue.ref, selection,
+    ...(A.issueExecutionUnavailable && A.issueExecutionUnavailable[issue.ref] === 'implementer' ? { executionUnavailable: true } : {}),
   }
   await markRunIn(assigned.worktree)
   await appendRunEvent('phase.started', issue.ref, 'Implement', { worktree: assigned.worktree })
   await appendRunEvent('subagent.started', issue.ref, 'Implement', { role: 'implementer' })
   const result = await requestRole('implementer', implementPrompt(issue, feedback, assigned), options)
+  if (result && result.executionUnavailable) {
+    return { executionUnavailable: true, role: 'implementer', error: result.error, worktree: assigned.worktree, branch: assigned.branch }
+  }
   await appendRunEvent('subagent.stopped', issue.ref, 'Implement', { role: 'implementer', result })
   await appendRunEvent('phase.finished', issue.ref, 'Implement', { worktree: assigned.worktree })
   return result && result.worktree === assigned.worktree && result.branch === assigned.branch ? result : null
@@ -517,11 +676,19 @@ const results = await pipeline(
   issue => implement(issue, null, null),
   async (impl, issue) => {
     if (!impl) return null
+    if (impl.executionUnavailable) return impl
+    const selection = resolveRoleForIssue(issue.ref, 'reviewer', null)
+    await logRoleSelected(issue.ref, 'reviewer', selection)
     await appendRunEvent('phase.started', issue.ref, 'Review', { worktree: location(impl) })
     await appendRunEvent('subagent.started', issue.ref, 'Review', { role: 'reviewer' })
     const review = await requestRole('reviewer', reviewPrompt(issue, impl), {
       label: `review:${issue.ref}`, phase: 'Review', model: A.models.review, cwd: location(impl),
+      issueRef: issue.ref, selection,
+      ...(A.issueExecutionUnavailable && A.issueExecutionUnavailable[issue.ref] === 'reviewer' ? { executionUnavailable: true } : {}),
     })
+    if (review && review.executionUnavailable) {
+      return { executionUnavailable: true, role: 'reviewer', error: review.error, impl }
+    }
     await appendRunEvent('subagent.stopped', issue.ref, 'Review', { role: 'reviewer', result: review })
     await appendRunEvent('phase.finished', issue.ref, 'Review', {})
     if (review) {
@@ -536,10 +703,42 @@ const results = await pipeline(
     if (!reviewed) {
       return { impl: null, implementerFailed: true, failedImpl: impl, review, reviewFix: true }
     }
+    if (reviewed.executionUnavailable) return reviewed
     return { impl: reviewed, review, reviewFix: Boolean(review && review.blocking.length) }
   },
   async (state, issue) => {
     if (!state) return { ref: issue.ref, outcome: 'implementer_failed' }
+    if (state.executionUnavailable) {
+      const impl = state.impl
+      const worktree = (impl && impl.worktree) || state.worktree || issueWorktreePath(issue)
+      const branch = (impl && impl.branch) || state.branch || await configuredIssueBranch(issue)
+      const corrections = state.corrections || 0
+      await appendRunEvent('issue.paused', issue.ref, state.role === 'reviewer' ? 'Review' : state.role === 'implementer' ? 'Implement' : 'Critic', {
+        role: state.role || 'critic',
+        reason: 'execution_unavailable',
+        worktree,
+        error: state.error || 'Role execution unavailable',
+      })
+      return {
+        ref: issue.ref,
+        issuePath: issue.path,
+        outcome: 'paused',
+        status: 'paused',
+        reason: 'execution_unavailable',
+        executionUnavailable: true,
+        role: state.role || 'critic',
+        error: state.error || 'Role execution unavailable',
+        worktree,
+        branch,
+        commits: (impl && impl.commits) || [],
+        corrections,
+        reviewFix: state.reviewFix,
+        review: state.review,
+        verdict: null,
+        decisions: (impl && impl.decisions) || [],
+        blockers: (impl && impl.blockers) || [],
+      }
+    }
     if (state.implementerFailed) {
       return {
         ref: issue.ref, outcome: 'implementer_failed',
@@ -557,11 +756,42 @@ const results = await pipeline(
     let corrections = prior && Number.isInteger(prior.correctionsSpent) ? prior.correctionsSpent : 0
     let accepted = false
     for (let attempt = 1; ; attempt += 1) {
+      const selection = resolveRoleForIssue(issue.ref, 'critic', null)
+      await logRoleSelected(issue.ref, 'critic', selection)
       await appendRunEvent('phase.started', issue.ref, 'Critic', { attempt, worktree: location(impl) })
       await appendRunEvent('subagent.started', issue.ref, 'Critic', { role: 'critic', attempt })
       verdict = await requestRole('critic', criticPrompt(issue, impl, state.review, attempt), {
         label: `critic:${issue.ref}#${attempt}`, phase: 'Critic', model: A.models.critic, cwd: location(impl),
+        issueRef: issue.ref, selection,
+        ...(A.issueExecutionUnavailable && A.issueExecutionUnavailable[issue.ref] === 'critic' ? { executionUnavailable: true } : {}),
       })
+      if (verdict && verdict.executionUnavailable) {
+        await appendRunEvent('issue.paused', issue.ref, 'Critic', {
+          role: 'critic',
+          reason: 'execution_unavailable',
+          worktree: location(impl),
+          error: verdict.error || 'Critic execution unavailable',
+        })
+        return {
+          ref: issue.ref,
+          issuePath: issue.path,
+          outcome: 'paused',
+          status: 'paused',
+          reason: 'execution_unavailable',
+          executionUnavailable: true,
+          role: 'critic',
+          error: verdict.error || 'Critic execution unavailable',
+          worktree: impl.worktree,
+          branch: impl.branch,
+          commits: impl.commits,
+          corrections,
+          reviewFix: state.reviewFix,
+          review: state.review,
+          verdict: null,
+          decisions: (impl.decisions) || [],
+          blockers: (impl.blockers) || [],
+        }
+      }
       await appendRunEvent('subagent.stopped', issue.ref, 'Critic', { role: 'critic', attempt, result: projectCriticResult(verdict) })
       await appendRunEvent('phase.finished', issue.ref, 'Critic', { attempt })
       if (!verdict) {
@@ -589,6 +819,33 @@ const results = await pipeline(
           blockers: impl.blockers || [],
         }
       }
+      if (corrected.executionUnavailable) {
+        await appendRunEvent('issue.paused', issue.ref, 'Implement', {
+          role: 'implementer',
+          reason: 'execution_unavailable',
+          worktree: location(corrected),
+          error: corrected.error || 'Implementer execution unavailable',
+        })
+        return {
+          ref: issue.ref,
+          issuePath: issue.path,
+          outcome: 'paused',
+          status: 'paused',
+          reason: 'execution_unavailable',
+          executionUnavailable: true,
+          role: 'implementer',
+          error: corrected.error || 'Implementer execution unavailable',
+          worktree: corrected.worktree || impl.worktree,
+          branch: corrected.branch || impl.branch,
+          commits: impl.commits,
+          corrections,
+          reviewFix: state.reviewFix,
+          review: state.review,
+          verdict,
+          decisions: [...(impl.decisions || []), ...(verdict.decisionsForOperator || [])],
+          blockers: impl.blockers || [],
+        }
+      }
       corrections += 1
       impl = corrected
     }
@@ -693,15 +950,16 @@ if (integrationStopped) {
     round: A.round, reason: cancelReason && cancelReason.reason,
   })
 }
-const candidates = A.isLastRound ? await learn() : []
-if (!integrationStopped && A.isLastRound) {
+const hasPaused = deliveries.some(d => d.outcome === 'paused')
+const candidates = (A.isLastRound && !hasPaused) ? await learn() : []
+if (!integrationStopped && A.isLastRound && !hasPaused) {
   await appendRunEvent('run.finished', undefined, undefined, { round: A.round })
 }
-if (integrationStopped || A.isLastRound) {
+if (integrationStopped || (A.isLastRound && !hasPaused)) {
   await unmarkRun()
 }
 let prOffer = null
-if (!integrationStopped && A.isLastRound) {
+if (!integrationStopped && A.isLastRound && !hasPaused) {
   const completed = deliveries.filter(d => d.outcome === 'done')
   if (completed.length > 0) {
     const ghCheck = await runCommand('gh --version', { cwd: A.repoRoot })
@@ -747,7 +1005,15 @@ if (!integrationStopped && A.isLastRound) {
     }
   }
 }
-return { round: A.round, date: A.date, results: deliveries, ...(A.isLastRound ? { candidates, prOffer } : {}) }
+return {
+  round: A.round,
+  date: A.date,
+  results: deliveries,
+  caveman: cavemanState,
+  nextRoundBlocked: hasPaused || integrationStopped,
+  ...(hasPaused ? { pausedIssues: deliveries.filter(d => d.outcome === 'paused') } : {}),
+  ...(A.isLastRound && !hasPaused ? { candidates, prOffer } : {}),
+}
 ```
 
 The Workflow returns `done` only after serial integration (when isolated), a passing post-integration

package/.agents/skills/gantry/scripts/budget.py

@@ -76,15 +76,56 @@ def declared_models(capabilities_dir: Path) -> dict[str, tuple[str, int]]:
     return models
 
 
-def estimate(issue_path: Path, model: str, root: Path, capabilities_dir: Path) -> dict:
+def resolve_model_metadata(
+    model: str,
+    capabilities_dir: Path,
+    catalog_path: Path | None = None,
+) -> tuple[str, int]:
+    """Resolve model harness and context window from capabilities or discovered catalog."""
+    models = declared_models(capabilities_dir)
+    if model in models:
+        return models[model]
+
+    if catalog_path and catalog_path.is_file():
+        try:
+            catalog = json.loads(catalog_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ConfigurationError(f"invalid catalog JSON in {catalog_path}: {exc}") from exc
+
+        raw_models = catalog.get("models", {})
+        details = None
+        harness = catalog.get("harness", "discovered")
+        if isinstance(raw_models, dict) and model in raw_models:
+            details = raw_models[model]
+        elif isinstance(raw_models, list):
+            for m in raw_models:
+                if isinstance(m, dict) and m.get("id") == model:
+                    details = m
+                    break
+
+        if details is not None:
+            window = details.get("contextWindow")
+            if not isinstance(window, int) or isinstance(window, bool) or window <= 0:
+                raise ConfigurationError(f"missing verified context metadata for model {model!r}")
+            harness = details.get("harness", harness)
+            return (harness, window)
+
+    raise ConfigurationError(f"unknown model ID: {model!r}")
+
+
+def estimate(
+    issue_path: Path,
+    model: str,
+    root: Path,
+    capabilities_dir: Path,
+    catalog_path: Path | None = None,
+) -> dict:
     """Build the deterministic initial-package estimate for one Issue."""
     issue = parse_issue(issue_path)
     spec_path = artifact_path(root, "specs", issue.spec).resolve()
     if not spec_path.is_file():
         raise ConfigurationError(f"parent Spec does not exist: {spec_path.relative_to(root)}")
-    models = declared_models(capabilities_dir)
-    if model not in models:
-        raise ConfigurationError(f"unknown model ID: {model!r}")
+    harness, window = resolve_model_metadata(model, capabilities_dir, catalog_path)
     policy = resolve_policy(root)
     share = policy.get("budget", {}).get("contextShare")
     if not isinstance(share, (int, float)) or isinstance(share, bool) or not 0 < share <= 1:
@@ -101,7 +142,6 @@ def estimate(issue_path: Path, model: str, root: Path, capabilities_dir: Path) -
         for path in ordered
     ]
     byte_count = sum(entry["bytes"] for entry in files)
-    harness, window = models[model]
     estimated_tokens = byte_count / 4
     budget_tokens = window * share
     over_budget = estimated_tokens > budget_tokens
@@ -138,7 +178,8 @@ def emit(payload: dict, as_json: bool) -> None:
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("issue", help="Issue path")
-    parser.add_argument("--model", required=True, help="exact model ID declared by a capability")
+    parser.add_argument("--model", required=True, help="exact model ID declared by a capability or catalog")
+    parser.add_argument("--catalog", help="path to discovered model catalog JSON")
     parser.add_argument("--cwd", default=".", help="repository or worktree to inspect")
     parser.add_argument("--json", action="store_true", help="emit machine-readable output")
     args = parser.parse_args()
@@ -149,8 +190,9 @@ def main() -> int:
         emit({"error": f"configuration error: Issue does not exist: {issue_path}"}, args.json)
         return 1
     capabilities = Path(__file__).resolve().parents[1] / "capabilities"
+    catalog_path = Path(args.catalog).resolve() if args.catalog else None
     try:
-        payload = estimate(issue_path, args.model, root, capabilities)
+        payload = estimate(issue_path, args.model, root, capabilities, catalog_path=catalog_path)
     except (ConfigurationError, ValueError) as exc:
         emit({"error": f"configuration error: {exc}"}, args.json)
         return 1