@rosthq/cli 0.7.101 → 0.7.102

package/dist/index.js

@@ -57536,15 +57536,17 @@ ${usage()}
   let heartbeatSucceeded = false;
   let failed = false;
   let activeSessions = 0;
+  const activeTurnExecutionIds = /* @__PURE__ */ new Set();
   do {
     const detectedCapabilities = await detectCapabilities(cliVersion, env, homeDir);
     const capabilities = capabilitiesForConfiguredRuntime(detectedCapabilities, config2.runtime);
     const localRuntime = config2.execute ? effectiveExecutionRuntime(config2.runtime, capabilities) : null;
     try {
-      const heartbeat = await post2(fetchImpl, options.appUrl, "/api/runner/heartbeat", {
+      const heartbeat = await post2(fetchImpl, options.appUrl, "/api/runner/heartbeat", buildHeartbeatBody({
         capabilities,
-        telemetry: detectTelemetry(capabilities, env, activeSessions, cliVersion)
-      }, state.runner_secret);
+        telemetry: detectTelemetry(capabilities, env, activeSessions, cliVersion),
+        activeTurnExecutionIds: [...activeTurnExecutionIds]
+      }), state.runner_secret);
       if (heartbeat.status !== 200) {
         options.io.stderr.write(`heartbeat ${heartbeat.status}: ${redactForLog(JSON.stringify(heartbeat.json))}
 `);
@@ -57563,10 +57565,11 @@ ${usage()}
           intervalMs: config2.heartbeatMs,
           capabilities,
           io: options.io,
-          telemetry: () => detectTelemetry(capabilities, env, activeSessions, cliVersion)
+          telemetry: () => detectTelemetry(capabilities, env, activeSessions, cliVersion),
+          activeTurnIds: () => [...activeTurnExecutionIds]
         });
         try {
-          await claimAndExecute(fetchImpl, options.appUrl, state, config2, options.io, localRuntime);
+          await claimAndExecute(fetchImpl, options.appUrl, state, config2, options.io, localRuntime, activeTurnExecutionIds);
         } finally {
           stopTurnHeartbeat();
           activeSessions = Math.max(0, activeSessions - 1);
@@ -57579,27 +57582,61 @@ ${usage()}
     }
     beat += 1;
     if (!config2.once) {
-      await waitForNextHeartbeat(fetchImpl, options.appUrl, state, config2, options.io, localRuntime);
+      await waitForNextHeartbeat(
+        fetchImpl,
+        options.appUrl,
+        state,
+        config2,
+        options.io,
+        localRuntime,
+        capabilities,
+        () => detectTelemetry(capabilities, env, activeSessions, cliVersion),
+        activeTurnExecutionIds
+      );
     }
   } while (!config2.once);
   return heartbeatSucceeded && !failed ? 0 : 1;
 }
-async function waitForNextHeartbeat(fetchImpl, appUrl2, state, config2, io, runtime) {
+async function waitForNextHeartbeat(fetchImpl, appUrl2, state, config2, io, runtime, capabilities, telemetry, activeTurnExecutionIds) {
   const deadline = Date.now() + config2.heartbeatMs;
-  while (Date.now() < deadline) {
-    const intervalMs = Math.min(config2.interactiveClaimMs, deadline - Date.now());
-    await sleep3(intervalMs);
-    if (!runtime || Date.now() >= deadline) {
-      continue;
-    }
-    try {
-      await claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime, { interactiveOnly: true });
-    } catch (error51) {
-      io.stderr.write(`transient runner error (continuing): ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}
+  const stopWait = runtime ? startTurnHeartbeat({
+    fetchImpl,
+    appUrl: appUrl2,
+    secret: state.runner_secret,
+    intervalMs: config2.heartbeatMs,
+    capabilities,
+    io,
+    telemetry,
+    activeTurnIds: () => [...activeTurnExecutionIds]
+  }) : null;
+  try {
+    while (Date.now() < deadline) {
+      const intervalMs = Math.min(config2.interactiveClaimMs, deadline - Date.now());
+      await sleep3(intervalMs);
+      if (!runtime || Date.now() >= deadline) {
+        continue;
+      }
+      try {
+        await claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime, activeTurnExecutionIds, { interactiveOnly: true });
+      } catch (error51) {
+        io.stderr.write(`transient runner error (continuing): ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}
 `);
+      }
     }
+  } finally {
+    stopWait?.();
   }
 }
+function buildHeartbeatBody(input) {
+  const body = {
+    capabilities: input.capabilities,
+    telemetry: input.telemetry
+  };
+  if (input.activeTurnExecutionIds.length > 0) {
+    body.active_turn_execution_ids = input.activeTurnExecutionIds;
+  }
+  return body;
+}
 function startTurnHeartbeat(deps) {
   let stopped = false;
   let inFlight = false;
@@ -57613,10 +57650,11 @@ function startTurnHeartbeat(deps) {
     timeout.unref?.();
     void (async () => {
       try {
-        const response = await post2(deps.fetchImpl, deps.appUrl, "/api/runner/heartbeat", {
+        const response = await post2(deps.fetchImpl, deps.appUrl, "/api/runner/heartbeat", buildHeartbeatBody({
           capabilities: deps.capabilities,
-          telemetry: deps.telemetry()
-        }, deps.secret, controller.signal);
+          telemetry: deps.telemetry(),
+          activeTurnExecutionIds: deps.activeTurnIds()
+        }), deps.secret, controller.signal);
         if (!stopped && response.status !== 200) {
           deps.io.stderr.write(`turn heartbeat ${response.status}: ${redactForLog(JSON.stringify(response.json))}
 `);
@@ -58077,7 +58115,7 @@ async function post2(fetchImpl, appUrl2, pathName, body, token, signal) {
   }
   return { status: response.status, json: json2 };
 }
-async function claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime, options = {}) {
+async function claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime, activeTurnIds, options = {}) {
   const claimStartedAt = (/* @__PURE__ */ new Date()).toISOString();
   const claimed = await post2(
     fetchImpl,
@@ -58097,7 +58135,7 @@ async function claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime,
   });
   const turnExecution = claimed.json.turn_execution;
   if (claimed.status === 200 && turnExecution && typeof turnExecution === "object") {
-    await executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, {
+    await executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, activeTurnIds, {
       kind: "turn_execution",
       idField: "turn_execution_id",
       item: turnExecution,
@@ -58111,7 +58149,7 @@ async function claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime,
   if (claimed.status !== 200 || !workOrder || typeof workOrder !== "object") {
     return;
   }
-  await executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, {
+  await executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, activeTurnIds, {
     kind: "work_order",
     idField: "work_order_id",
     item: workOrder,
@@ -58120,7 +58158,7 @@ async function claimAndExecute(fetchImpl, appUrl2, state, config2, io, runtime,
     logRef: (id) => `runner-local:${id}`
   });
 }
-async function executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, input) {
+async function executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtime, ledger, activeTurnIds, input) {
   const id = input.item.id;
   if (typeof id !== "string") {
     return;
@@ -58129,79 +58167,88 @@ async function executeClaimedUnit(fetchImpl, appUrl2, state, config2, io, runtim
   if (started.status !== 200) {
     throw new Error(`${claimedUnitLabel(input.kind)} start failed ${started.status}: ${redactForLog(JSON.stringify(started.json))}`);
   }
-  const turnRuntime = runtimeForClaimedUnit(input.item, runtime, input.kind);
-  const result = turnRuntime ? await runLocalTurn({ fetchImpl, appUrl: appUrl2, state, config: config2, io, ledger }, input.item, turnRuntime, input.kind) : {
-    ok: false,
-    summary: `Runner runtime ${runtime} cannot execute requested ${String(input.item.brain ?? "unknown")} turn.`
-  };
-  if (input.kind === "turn_execution" && turnRuntime === "claude") {
-    try {
-      if (result.ok && result.claudeSessionId) {
-        await persistClaudeSessionId(config2.stateFile, state, input.item, result.claudeSessionId);
-      } else if (!result.ok && result.resumedFromSessionId) {
-        await clearClaudeSessionId(config2.stateFile, state, input.item);
-      }
-    } catch (error51) {
-      io.stderr.write(`resume cache update failed (continuing): ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}
+  if (input.kind === "turn_execution") {
+    activeTurnIds.add(id);
+  }
+  try {
+    const turnRuntime = runtimeForClaimedUnit(input.item, runtime, input.kind);
+    const result = turnRuntime ? await runLocalTurn({ fetchImpl, appUrl: appUrl2, state, config: config2, io, ledger }, input.item, turnRuntime, input.kind) : {
+      ok: false,
+      summary: `Runner runtime ${runtime} cannot execute requested ${String(input.item.brain ?? "unknown")} turn.`
+    };
+    if (input.kind === "turn_execution" && turnRuntime === "claude") {
+      try {
+        if (result.ok && result.claudeSessionId) {
+          await persistClaudeSessionId(config2.stateFile, state, input.item, result.claudeSessionId);
+        } else if (!result.ok && result.resumedFromSessionId) {
+          await clearClaudeSessionId(config2.stateFile, state, input.item);
+        }
+      } catch (error51) {
+        io.stderr.write(`resume cache update failed (continuing): ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}
 `);
+      }
     }
-  }
-  const reportBody = {
-    status: result.ok ? "succeeded" : "failed",
-    // Cap to the result route's summary limit (see capResultSummary / RESULT_SUMMARY_MAX). A
-    // real turn summary can exceed it; without the cap the server's Zod `.max()` 400s the
-    // report, and because the loop treats a throw as "transient (continuing)" the phase
-    // zombies in `running` until its lease grace. Truncating keeps a successful turn a success.
-    summary: capResultSummary(result.summary),
-    log_ref: input.logRef(id),
-    model: (turnRuntime ?? runtime) === "codex" ? "codex-cli" : "claude-cli",
-    // DER-1915: token usage lifted from the claude JSON envelope (extractClaudeUsage), sent for
-    // BOTH kinds when present — never defaulted to 0 (see RunnerTurnResult.inputTokens/outputTokens).
-    // Both result routes (work-orders and turn-executions) accept these snake_case fields.
-    ...result.inputTokens != null ? { input_tokens: result.inputTokens } : {},
-    ...result.outputTokens != null ? { output_tokens: result.outputTokens } : {},
-    // Artifact-bearing result fields (T1.5) — only sent when the harness produced them, so
-    // the result route's `.strict()` schema still accepts a plain read-status report.
-    ...result.prUrl ? { pr_url: result.prUrl } : {},
-    ...result.branch ? { branch: result.branch } : {},
-    ...result.commitSha ? { commit_sha: result.commitSha } : {},
-    ...result.evidence && result.evidence.length > 0 ? { evidence: result.evidence } : {},
-    ...result.changedPaths && result.changedPaths.length > 0 ? { changed_paths: result.changedPaths } : {},
-    // DER-1352 (T1.8): the merge-turn postcondition. Only sent when the harness GET-verified the PR
-    // merged on GitHub — the driver's completion writer marks the changeset merged + writes the
-    // decisions row ONLY on this. Gated on result.ok so a failed turn can never carry it.
-    ...result.ok && result.merged === true ? { merged: true } : {},
-    ...result.ok && result.merged === true && result.mergedCommitSha ? { merged_commit_sha: result.mergedCommitSha } : {},
-    // DER-1331 (T1.9): the step ledger + the model's (already redacted, bounded) transcript.
-    // Only the work-orders result route accepts these today (turn-executions is a separate,
-    // narrower endpoint — T1.9 scope); its Zod schema strips unrecognized keys on a non-strict
-    // parse either way, so sending them there is harmless, just unused.
-    ...input.kind === "work_order" ? { step_ledger: ledger.entries() } : {},
-    ...input.kind === "work_order" && result.transcript ? { transcript: result.transcript } : {},
-    // DER-1371: the planner's structured decomposition — only sent when the model produced one.
-    ...result.planArtifact ? { plan_artifact: result.planArtifact } : {}
-  };
-  const reported = await postResultWithRetries(fetchImpl, appUrl2, input.resultPath(id), reportBody, state.runner_secret);
-  if (reported.status !== 200) {
-    if (reported.status >= 400 && reported.status < 500) {
-      const fallback = await post2(fetchImpl, appUrl2, input.resultPath(id), {
-        status: "failed",
-        summary: capResultSummary(
-          `Runner result rejected by server (${reported.status}). Original outcome: ${result.ok ? "succeeded" : "failed"}. ${redactForLog(JSON.stringify(reported.json))}`
-        ),
-        log_ref: input.logRef(id),
-        model: (turnRuntime ?? runtime) === "codex" ? "codex-cli" : "claude-cli"
-      }, state.runner_secret);
-      if (fallback.status === 200) {
-        io.stdout.write(`${input.idField}=${id} status=failed (result rejected ${reported.status}; reported terminal failure)
+    const reportBody = {
+      status: result.ok ? "succeeded" : "failed",
+      // Cap to the result route's summary limit (see capResultSummary / RESULT_SUMMARY_MAX). A
+      // real turn summary can exceed it; without the cap the server's Zod `.max()` 400s the
+      // report, and because the loop treats a throw as "transient (continuing)" the phase
+      // zombies in `running` until its lease grace. Truncating keeps a successful turn a success.
+      summary: capResultSummary(result.summary),
+      log_ref: input.logRef(id),
+      model: (turnRuntime ?? runtime) === "codex" ? "codex-cli" : "claude-cli",
+      // DER-1915: token usage lifted from the claude JSON envelope (extractClaudeUsage), sent for
+      // BOTH kinds when present — never defaulted to 0 (see RunnerTurnResult.inputTokens/outputTokens).
+      // Both result routes (work-orders and turn-executions) accept these snake_case fields.
+      ...result.inputTokens != null ? { input_tokens: result.inputTokens } : {},
+      ...result.outputTokens != null ? { output_tokens: result.outputTokens } : {},
+      // Artifact-bearing result fields (T1.5) — only sent when the harness produced them, so
+      // the result route's `.strict()` schema still accepts a plain read-status report.
+      ...result.prUrl ? { pr_url: result.prUrl } : {},
+      ...result.branch ? { branch: result.branch } : {},
+      ...result.commitSha ? { commit_sha: result.commitSha } : {},
+      ...result.evidence && result.evidence.length > 0 ? { evidence: result.evidence } : {},
+      ...result.changedPaths && result.changedPaths.length > 0 ? { changed_paths: result.changedPaths } : {},
+      // DER-1352 (T1.8): the merge-turn postcondition. Only sent when the harness GET-verified the PR
+      // merged on GitHub — the driver's completion writer marks the changeset merged + writes the
+      // decisions row ONLY on this. Gated on result.ok so a failed turn can never carry it.
+      ...result.ok && result.merged === true ? { merged: true } : {},
+      ...result.ok && result.merged === true && result.mergedCommitSha ? { merged_commit_sha: result.mergedCommitSha } : {},
+      // DER-1331 (T1.9): the step ledger + the model's (already redacted, bounded) transcript.
+      // Only the work-orders result route accepts these today (turn-executions is a separate,
+      // narrower endpoint — T1.9 scope); its Zod schema strips unrecognized keys on a non-strict
+      // parse either way, so sending them there is harmless, just unused.
+      ...input.kind === "work_order" ? { step_ledger: ledger.entries() } : {},
+      ...input.kind === "work_order" && result.transcript ? { transcript: result.transcript } : {},
+      // DER-1371: the planner's structured decomposition — only sent when the model produced one.
+      ...result.planArtifact ? { plan_artifact: result.planArtifact } : {}
+    };
+    const reported = await postResultWithRetries(fetchImpl, appUrl2, input.resultPath(id), reportBody, state.runner_secret);
+    if (reported.status !== 200) {
+      if (reported.status >= 400 && reported.status < 500) {
+        const fallback = await post2(fetchImpl, appUrl2, input.resultPath(id), {
+          status: "failed",
+          summary: capResultSummary(
+            `Runner result rejected by server (${reported.status}). Original outcome: ${result.ok ? "succeeded" : "failed"}. ${redactForLog(JSON.stringify(reported.json))}`
+          ),
+          log_ref: input.logRef(id),
+          model: (turnRuntime ?? runtime) === "codex" ? "codex-cli" : "claude-cli"
+        }, state.runner_secret);
+        if (fallback.status === 200) {
+          io.stdout.write(`${input.idField}=${id} status=failed (result rejected ${reported.status}; reported terminal failure)
 `);
-        return;
+          return;
+        }
       }
+      throw new Error(`${claimedUnitLabel(input.kind)} result failed ${reported.status}: ${redactForLog(JSON.stringify(reported.json))}`);
     }
-    throw new Error(`${claimedUnitLabel(input.kind)} result failed ${reported.status}: ${redactForLog(JSON.stringify(reported.json))}`);
-  }
-  io.stdout.write(`${input.idField}=${id} status=${result.ok ? "succeeded" : "failed"}
+    io.stdout.write(`${input.idField}=${id} status=${result.ok ? "succeeded" : "failed"}
 `);
+  } finally {
+    if (input.kind === "turn_execution") {
+      activeTurnIds.delete(id);
+    }
+  }
 }
 var RESULT_REPORT_RETRY_ATTEMPTS = 4;
 var RESULT_REPORT_RETRY_BASE_DELAY_MS = 500;