@botbuddy/cli 1.37.0 → 1.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.37.0",
+  "version": "1.38.0",
   "description": "BotBuddy — Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/lane-status.mjs

@@ -0,0 +1,22 @@
+// BOT-1319 — report a phase to the BotBuddy lefthook lane wrapper that may be
+// running this command (botbuddy-web `scripts/log-test-run.mjs`, the same file
+// protocol as `scripts/lib/lane-status.mjs`). The wrapper exports
+// $BOTBUDDY_LANE_STATUS_FILE and turns each atomic rewrite into one lifecycle
+// progress event, so a lane parked here for Docker capacity shows as
+// `waiting · queued_for_capacity` instead of as silent test time. Unset outside a
+// wrapped lane → no-op. Never throws.
+
+import { renameSync, writeFileSync } from "node:fs";
+
+export function writeLaneStatus(status, env = process.env) {
+  const path = env.BOTBUDDY_LANE_STATUS_FILE;
+  if (!path) return false;
+  try {
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ ...status, at: new Date().toISOString() }));
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/stack.mjs

@@ -21,6 +21,7 @@
 //     labelled fallback for when no Helper is available: it runs `supabase start`/
 //     `stop` itself and self-activates/finalizes via the fallback MCP tools.
 
+import { writeLaneStatus } from "./lane-status.mjs";
 import { spawn, spawnSync } from "child_process";
 import { readFileSync, realpathSync } from "fs";
 import { open, unlink, readFile } from "fs/promises";
@@ -1497,6 +1498,7 @@ export async function cmdUp(opts, {
   machineUuidFn = machineUuid,
   assertIsolated = validateLocalExecTarget,
   refreshAuth = refreshRejectedCacheAuth,
+  reportLaneStatus = writeLaneStatus,
   waitCapacity = defaultWaitCapacity,
 } = {}) {
   let slot;
@@ -1641,6 +1643,9 @@ export async function cmdUp(opts, {
   const reusedExisting = state === "active";
 
   if (state === "queued") {
+    // BOT-1319: a wrapped lefthook lane records this park as waiting for capacity.
+    const where = [d.queue_position != null ? `queue position ${d.queue_position}` : null, d.host_key ? `on ${d.host_key}` : null].filter(Boolean).join(" ");
+    reportLaneStatus({ phase: "waiting", reason: "queued_for_capacity", detail: where || "host at capacity" });
     if (opts.noWait) {
       return emitResult(buildReceipt({ command: "up", outcome: "queued", lease_id: leaseId, state, host_key: d.host_key, slot, queued: true, queue_position: d.queue_position, holders: d.holders }), opts, EXIT.QUEUED);
     }
@@ -1651,6 +1656,7 @@ export async function cmdUp(opts, {
     if (parked.error) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: parked.error }), opts, EXIT.BACKEND);
     state = parked.state || "provisioning";
   }
+  reportLaneStatus({ phase: "testing", reason: "provisioning" });
 
   // Reach `active`: local-exec provisions itself; otherwise wait for the Helper.
   if (state !== "active") {

package/src/telemetry-outbox.mjs

@@ -323,11 +323,19 @@ export async function createTelemetryOutbox({
     try { imported = JSON.parse(await readFile(legacyImportPath, "utf8")); } catch { /* first migration */ }
     let names = [];
     try { names = (await readdir(legacyDirectory)).filter((name) => name.endsWith(".json")); } catch (error) { if (error?.code === "ENOENT") return { imported: 0, skipped: 0 }; throw error; }
+    // BOT-1319: the test-ingest reporter archives what it posted under reported/
+    // before the next hook can recover it; a summary whose lifecycle was degraded
+    // is still eligible there (others under reported/ were already counted).
+    let archived = [];
+    try { archived = (await readdir(join(legacyDirectory, "reported"))).filter((name) => name.endsWith(".json")); } catch { /* none archived */ }
+    const entries = [
+      ...names.sort().map((name) => ({ name, file: join(legacyDirectory, name), archived: false })),
+      ...archived.sort().map((name) => ({ name, file: join(legacyDirectory, "reported", name), archived: true })),
+    ];
     let added = 0;
     let skipped = 0;
-    for (const name of names.sort()) {
+    for (const { name, file, archived: fromArchive } of entries) {
       if (added >= maxReceipts || Date.now() >= deadline) break;
-      const file = join(legacyDirectory, name);
       let raw;
       try { raw = await readFile(file, "utf8"); } catch { skipped += 1; continue; }
       const fingerprint = hash(`${name}\0${raw}`);
@@ -335,13 +343,30 @@ export async function createTelemetryOutbox({
       let summary;
       try { summary = JSON.parse(raw); } catch { skipped += 1; continue; }
       if (!summary || typeof summary !== "object" || typeof summary.runner !== "string") { skipped += 1; continue; }
+      if (fromArchive && summary.lifecycle?.telemetry !== "degraded") continue;
+      // BOT-1319: the lane wrapper (and anything nested in a wrapped lane) stamps
+      // `lifecycle` when a canonical execution already carries this run. Importing
+      // it too would count the same run twice; record it as seen and move on. A
+      // wrapper summary stamped `telemetry: "degraded"` never reached the outbox
+      // durably, so it stays eligible and imports like a historical summary.
+      const lifecycle = summary.lifecycle;
+      if (lifecycle && typeof lifecycle === "object" && (lifecycle.owned_by || lifecycle.telemetry === "durable")) {
+        imported[fingerprint] = { name, imported_at: now().toISOString(), lifecycle: true };
+        skipped += 1;
+        continue;
+      }
       const sourceRunId = `legacy-${fingerprint.slice(0, 32)}`;
       const started = typeof summary.started_at === "string" ? summary.started_at : now().toISOString();
       const finished = typeof summary.finished_at === "string" ? summary.finished_at : now().toISOString();
-      const passed = summary.verdict === "pass" || summary.exit_code === 0;
-      const context = { repo: repository, environment: "local", runner: summary.runner, phase: passed ? "complete" : "failed", health: "uninstrumented" };
+      // An explicit skip (BOT-1319 wrapper, verdict "skip", exit 0) is never green.
+      const isSkip = summary.verdict === "skip";
+      const passed = !isSkip && (summary.verdict === "pass" || summary.exit_code === 0);
+      const context = { repo: repository, environment: "local", runner: summary.runner, phase: passed || isSkip ? "complete" : "failed", health: "uninstrumented", ...(isSkip ? { skipped: 1 } : {}) };
+      const terminal = isSkip
+        ? { outcome: "canceled", diagnostic: { code: "skipped", category: "skip", message: String(summary.skipped_reason ?? "skipped").slice(0, 500) } }
+        : { outcome: passed ? "passed" : "failed" };
       await append({ schema_version: 1, action: "start", producer_kind: "hook", source_run_id: sourceRunId, attempt: 1, producer_event_id: `${sourceRunId}:start`, producer_sequence: 0, occurred_at: started, context });
-      await append({ schema_version: 1, action: "terminal", producer_kind: "hook", source_run_id: sourceRunId, attempt: 1, producer_event_id: `${sourceRunId}:terminal`, producer_sequence: 1, occurred_at: finished, context, outcome: passed ? "passed" : "failed" });
+      await append({ schema_version: 1, action: "terminal", producer_kind: "hook", source_run_id: sourceRunId, attempt: 1, producer_event_id: `${sourceRunId}:terminal`, producer_sequence: 1, occurred_at: finished, context, ...terminal });
       imported[fingerprint] = { name, imported_at: now().toISOString() };
       added += 1;
     }