@renzrollon/interlock 1.1.1 → 1.2.0

package/workflows/ship.js

@@ -148,6 +148,10 @@ const pingExtra = { type: PING_AGENT, tools: PING_TOOLS }
 
 const WORK = '.claude/ship'
 const RESULTS = `${WORK}/results.json`
+// Where the CLI keeps the exact bytes it last printed (LAST_STEP_PATH in
+// lib/run.mjs). Named here only so a halt can point a reader at it; this script
+// cannot read a file.
+const LAST_STEP = `${WORK}/last-step.json`
 
 // The runtime caps a run at 1000 agents. This is that ceiling, named so nobody
 // mistakes it for policy: it is NOT a bound on the loop, and it is deliberately
@@ -262,6 +266,11 @@ const {
 
 let steps = 0
 let resolvedChange = changeArg || '(unresolved)'
+// Why the last relay produced no step, when it did not. A relay's copy that
+// fails to parse used to vanish into a generic halt, and the only way to learn
+// it had been a 23 KB step retyped with two brackets missing was to dig the
+// relay's transcript out by hand.
+let relayFailure = ''
 
 /** A control-plane ping: mechanical, cheap, and never asked to decide anything. */
 const ping = (name, prompt, schema) => agent(prompt, { label: name, schema, ...pingExtra })
@@ -275,7 +284,8 @@ const ping = (name, prompt, schema) => agent(prompt, { label: name, schema, ...p
  */
 async function spawnOne(s) {
   const result = await agent(BOOTSTRAP(s.label, s.promptPath, s.promptSha256), {
-    label: s.label,
+    // Shown as its title; every record below still names it by its label.
+    label: s.title || s.label,
     type: s.type,
     tools: s.tools,
     ...(s.model ? { model: s.model } : {}),
@@ -287,13 +297,25 @@ async function spawnOne(s) {
       properties: { ...(s.schema.properties || {}), briefing: { type: 'string' } }
     }
   })
+  // No result at all is what `agent()` resolves to when the runtime stopped the
+  // agent, the API failed unrecoverably, or a usage limit ended it outside an
+  // interactive session. The host was the cause, so it is named as the host —
+  // reporting it as an unacknowledged briefing would send the reader to the
+  // briefing. Still a null result, which the recorder treats as a failed task.
+  if (result === null || result === undefined) {
+    banners.push(
+      `AGENT RETURNED NO RESULT: ${s.label} — the runtime stopped it, the API failed, or a usage limit ` +
+        `ended it; the step is recorded as failed`
+    )
+    return null
+  }
   // Fail closed on an unacknowledged briefing. An agent that did not read its
   // instructions did not do this task, whatever it reports about it — and a
   // silently under-instructed worker is exactly the failure prompt integrity
   // exists to catch. So it is a null result with a named reason, which the
   // recorder already treats as a failed task, rather than a warning beside a
   // result that gets counted.
-  const ack = result && typeof result.briefing === 'string' ? result.briefing.trim() : ''
+  const ack = typeof result.briefing === 'string' ? result.briefing.trim() : ''
   if (ack !== s.promptSha256) {
     banners.push(
       `BRIEFING NOT ACKNOWLEDGED: ${s.label} reported ${ack || '(nothing)'} for a briefing whose ` +
@@ -333,8 +355,10 @@ async function cli(argv, results, extraWrites = []) {
   const quote = a => (/[^\w@%+=:,./-]/.test(String(a)) ? `'${String(a).replace(/'/g, `'\\''`)}'` : String(a))
   const command =
     `interlock ${argv.map(quote).join(' ')}${results === undefined ? '' : ` --results ${RESULTS}`} --json`
+  // Shown with the subcommand it relays (`cli-12 · run next`), so a stalled
+  // relay can be read off the progress view; `label` stays what errors name.
   const relayed = await ping(
-    label,
+    `${label} · ${argv.slice(0, 2).join(' ')}`,
     `You are a mechanical relay for one command. Do not interpret it, and do not do the work it ` +
       `describes.\n\n` +
       (writeLines ? `${writeLines}\n\n` : '') +
@@ -348,14 +372,28 @@ async function cli(argv, results, extraWrites = []) {
       properties: { cliStdout: { type: 'string' }, action: { type: 'string' } }
     }
   )
-  if (relayed && typeof relayed.cliStdout === 'string') {
+  let problem
+  if (!relayed) {
+    problem = 'the relay returned nothing'
+  } else if (typeof relayed.cliStdout !== 'string') {
+    problem = 'the relay returned no cliStdout'
+  } else {
     try {
       const parsed = JSON.parse(relayed.cliStdout)
       if (parsed && typeof parsed.action === 'string') return parsed
-    } catch {
+      problem = `${relayed.cliStdout.length} relayed chars parsed but carry no "action"`
+    } catch (err) {
       // stdout was not JSON. Nothing is inferred from that: the caller stops.
+      // What is kept is WHY — V8's message carries the failing position when it
+      // has one — so the halt says what broke instead of that something did.
+      problem =
+        `${relayed.cliStdout.length} relayed chars do not parse as JSON ` +
+        `(${(err && err.message) || String(err)})`
     }
   }
+  relayFailure =
+    `${label} (interlock ${argv.slice(0, 2).join(' ')}): ${problem} — ` +
+    `the CLI's own bytes are in ${LAST_STEP}`
   return null
 }
 
@@ -376,67 +414,44 @@ if (tddModeConflict) {
   )
 }
 
-// The environment probe. Everything it asks about is a property of THIS HOST —
-// whether haiku is reachable, whether the graph was built, whether a test
-// profile exists, whether model routing is overridden — so it is asked here and
-// carried to the close as a host banner, rather than being something the CLI
-// could have found out for itself.
+// The environment probe. It asks only what is a property of THIS HOST's shell —
+// whether the effort level is overridden — and creates the working directory.
+// Whether the graph was built and whether a test profile exists are NOT asked:
+// `run start` locates both itself, root first and then the state home, and
+// raises their banners (ship/run-program). Two probes of one file in two places
+// is how a driver and the CLI would disagree about whether it exists. The
+// model-routing variables are not asked either: `run start` reads them from its
+// own environment, together with the host's version, and decides the banners
+// and the ping model itself.
 const probed = await ping(
   'validate',
   `Report this environment. Change nothing, and do not start any work.\n\n` +
-    `Run: test -f .claude/graph/graph.json && echo yes || echo no\n` +
-    `Report yes as hasGraph:true, no as hasGraph:false with a one-line graphReason.\n\n` +
-    `Run: test -f .claude/testing/profile.json && echo yes || echo no\n` +
-    `Report it as hasTestProfile.\n\n` +
-    `Run: printenv CLAUDE_CODE_SUBAGENT_MODEL\n` +
-    `If it prints a value, report it as subagentModelOverride. If it is unset the command exits ` +
+    `Run: printenv CLAUDE_CODE_EFFORT_LEVEL\n` +
+    `If it prints a value, report it as effortLevelOverride. If it is unset the command exits ` +
     `non-zero and prints nothing — that is the normal case, so leave the field out rather than ` +
     `reporting an empty string.\n\n` +
-    `Then run: printenv CLAUDE_CODE_USE_BEDROCK; printenv AWS_BEDROCK\n` +
-    `If subagentModelOverride is set, leave haikuAvailable out — routing is already overridden.\n` +
-    `If either Bedrock variable prints a non-empty value other than 0 or false, report ` +
-    `haikuAvailable:false. Bedrock accounts often cannot reach haiku and a failed ping halts the loop.\n` +
-    `Otherwise report haikuAvailable:true. When unsure, haikuAvailable:false so pings inherit ` +
-    `the session model rather than hard-failing.\n\n` +
     `Then create the working directory ${WORK}/.`,
   {
     type: 'object',
     properties: {
-      hasGraph: { type: 'boolean' },
-      graphReason: { type: 'string' },
-      hasTestProfile: { type: 'boolean' },
-      subagentModelOverride: { type: 'string' },
-      haikuAvailable: { type: 'boolean' }
+      effortLevelOverride: { type: 'string' }
     }
   }
 )
 
-if (probed && probed.hasGraph === false) {
-  banners.push(
-    `GRAPH UNAVAILABLE: ${probed.graphReason || 'never built'} — implementer and reviewer agents fall back to grep and will be slower`
-  )
-}
-if (probed && probed.hasTestProfile === false) {
-  banners.push('NO TEST PROFILE: run /interlock:fix-tests --reconfigure once')
-}
-// CLAUDE_CODE_SUBAGENT_MODEL overrides both the session model and the per-agent
-// model a step asks for, so when it is set the planner's tier ladder — the opus
-// clamp, the haiku pings — is not in effect and the run costs whatever that
-// model costs. Nothing here can prevent that; it is the user's environment. But
-// a summary claiming no degradation while the entire model ladder was bypassed
-// is exactly the silence the banner block exists to remove.
-const subagentModel =
-  probed && typeof probed.subagentModelOverride === 'string'
-    ? probed.subagentModelOverride.trim()
+// The effort override. CLAUDE_CODE_EFFORT_LEVEL outranks both the session's effort
+// and every per-agent effort a step asks for, so while it is set the plan's
+// per-step effort is not in effect. It is the operator's environment and is
+// never stripped; it is bannered so the summary cannot claim otherwise.
+const effortLevel =
+  probed && typeof probed.effortLevelOverride === 'string'
+    ? probed.effortLevelOverride.trim()
     : ''
-if (subagentModel) {
+if (effortLevel) {
   banners.push(
-    `MODEL ROUTING OVERRIDDEN: CLAUDE_CODE_SUBAGENT_MODEL=${subagentModel} — every agent runs on ` +
-      `that model, so the per-tier assignment in the plan is not in effect`
+    `EFFORT ROUTING OVERRIDDEN: CLAUDE_CODE_EFFORT_LEVEL=${effortLevel} — every agent runs at ` +
+      `that effort, so the per-step effort in the plan is not in effect`
   )
-} else if (probed && probed.haikuAvailable === true) {
-  // Mutate rather than rebind — `ping` closes over the object.
-  pingExtra.model = 'haiku'
 }
 
 // --- the loop ---------------------------------------------------------------
@@ -462,6 +477,13 @@ let step = await cli([
   'workflow'
 ])
 
+// The control-plane ping model `run start` decided from the host's version and
+// environment. Forwarded, never decided here: when the step names none — an
+// override is in force, or a Bedrock account may not reach haiku — every later
+// relay inherits the session model. Mutate rather than rebind: `ping` closes
+// over the object.
+if (step && typeof step.pingModel === 'string' && step.pingModel) pingExtra.model = step.pingModel
+
 while (step && step.then) {
   if (steps > RUNAWAY_BACKSTOP) {
     return await stop(`the interpreter exceeded the runtime's agent ceiling (${RUNAWAY_BACKSTOP})`)
@@ -488,7 +510,9 @@ while (step && step.then) {
 }
 
 if (!step) {
-  return await stop('the run program returned no step — the CLI relay could not be read')
+  if (relayFailure) banners.push(`RELAY UNREADABLE: ${relayFailure}`)
+  return await stop('the run program returned no step — the CLI relay could not be read' +
+    (relayFailure ? `: ${relayFailure}` : ''))
 }
 
 // The last argv was `run close`, so `step` IS the close: its summary and its