@botbuddy/cli 1.64.12 → 1.64.14

package/bin/botbuddy.mjs

@@ -1,8 +1,18 @@
 #!/usr/bin/env node
 import { run } from "../src/commands.mjs";
 import { ensureRunDelivery } from "../src/run-delivery.mjs";
+import { feedbackReminder } from "../src/feedback-reminder.mjs";
+import { writeSync } from "node:fs";
 
 const argv = process.argv.slice(2);
+// Some commands exit directly; observe the final exit once so those paths
+// receive the same stderr-only guidance without changing their exit status.
+process.once("exit", (code) => {
+  const reminder = feedbackReminder(argv, code);
+  if (reminder) {
+    try { writeSync(2, `${reminder}\n`); } catch { /* preserve the original exit status */ }
+  }
+});
 
 // BOT-2600: normal `bb` invocations start the single per-machine delivery process
 // when finished `bb run` commands still have an unsent terminal update. A stat
@@ -15,8 +25,10 @@ const flags = separator === -1 ? argv : argv.slice(0, separator);
 const readOnly = flags.some((flag) => flag === "--help" || flag === "-h")
   || argv[0] === "help"
   || (argv[0] === "stack" && argv[1] === "help")
-  || (argv[0] === "run" && (argv[1] === "inspect" || argv[1] === "help"));
-const delivery = deliveryProcessArgs || readOnly ? Promise.resolve() : ensureRunDelivery().catch(() => {});
+  || (argv[0] === "run" && (argv[1] === "status" || argv[1] === "inspect" || argv[1] === "help"));
+// Feedback must not start unrelated delivery while an agent reports a blocker.
+const feedbackCommand = argv[0] === "feedback";
+const delivery = deliveryProcessArgs || readOnly || feedbackCommand ? Promise.resolve() : ensureRunDelivery().catch(() => {});
 
 delivery.then(() => run(argv)).then((code) => {
   if (typeof code === "number") process.exitCode = code;

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.14",
+  "source_commit": "2bea99f6e692232d6694356e0fc474daebba622e",
+  "source_sha256": "abb141ad30727d4a9f32819a3e26be122ab750a919dfc21f7813d6dbd3bcaaa3",
   "target": "darwin-arm64",
-  "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec"
+  "sha256": "2ee00d7621d20c09863a0dc96f862a99ed10a3557ba15df595e512f433020a7c"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.14",
+  "source_commit": "2bea99f6e692232d6694356e0fc474daebba622e",
+  "source_sha256": "abb141ad30727d4a9f32819a3e26be122ab750a919dfc21f7813d6dbd3bcaaa3",
   "target": "linux-x64",
-  "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d"
+  "sha256": "af268c0f266b387fadc180451ef738760eb95c409c588cc7de62c9ee2b18c8f9"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.14",
+  "source_commit": "2bea99f6e692232d6694356e0fc474daebba622e",
+  "source_sha256": "abb141ad30727d4a9f32819a3e26be122ab750a919dfc21f7813d6dbd3bcaaa3",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec",
+      "sha256": "2ee00d7621d20c09863a0dc96f862a99ed10a3557ba15df595e512f433020a7c",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d",
+      "sha256": "af268c0f266b387fadc180451ef738760eb95c409c588cc7de62c9ee2b18c8f9",
       "mode": "0755"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.64.12",
+  "version": "1.64.14",
   "description": "BotBuddy \u2014 Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/commands.mjs

@@ -10,7 +10,7 @@ import { bootstrapHarnessSession, clearHarnessSession, doctorBootstrapState, for
 import { loadConfig, getConfig, clearConfig, getConfigPath, SERVER_URL } from "./config.mjs";
 import { resolveOwnerToken, resolveAgentKey, clearOwnerToken } from "./cli-credentials.mjs";
 import { agentProfileKeyLabel } from "./credential-kinds.mjs";
-import { buildAcquireResourcesPayload, LocksUsageError } from "./locks.mjs";
+import { buildAcquireResourcesPayload, LocksUsageError, classifyLockResponse, lockOutcomeLines, unlockOutcomeLines, UNLOCK_QUEUED_USAGE } from "./locks.mjs";
 import { CallUsageError, discoveryUrlFor, formatDiscovery, parseCallArgs } from "./discovery.mjs";
 import { cmdStack } from "./stack.mjs";
 import { cmdManagedAllocation } from "./managed-allocation.mjs";
@@ -18,6 +18,7 @@ import { cmdDocker } from "./docker-hygiene.mjs";
 import { cmdRun } from "./run.mjs";
 import { cmdTest } from "./test-lane.mjs";
 import { cmdEvidence } from "./evidence.mjs";
+import { cmdFeedback } from "./feedback.mjs";
 import { runWait } from "./wait.mjs";
 import { SETUP_BLOCK } from "./setup-block.mjs";
 import { green, red, cyan, dim, bold, die } from "./utils.mjs";
@@ -48,7 +49,7 @@ import { cmdDaemon } from "./daemon/commands.mjs";
 export function shouldCheckForUpdates(argv) {
   const [command] = argv;
   // BOT-1982: nor `test-ingest`, which runs at the tail of every test harness.
-  if (command === "wait" || command === "telemetry" || command === "usage" || command === "test-ingest") return false;
+  if (command === "wait" || command === "feedback" || command === "telemetry" || command === "usage" || command === "test-ingest") return false;
   if (argv.includes("--json")) return false;
   // BOT-2599: `bb doctor --only <check>` runs inside a git pre-push hook; it must
   // stay local and sub-second, so it never consults the npm registry.
@@ -61,7 +62,7 @@ export function shouldCheckForUpdates(argv) {
 // of the same name. MCP tools are snake_case, so no name here can shadow one.
 export const LOCAL_HELP_COMMANDS = Object.freeze([
   "wait", "stack", "pw", "docker", "run", "mcp", "login", "setup", "doctor", "host",
-  "staging-pool", "daemon", "evidence", "usage", "telemetry", "allocation",
+  "staging-pool", "daemon", "evidence", "feedback", "usage", "telemetry", "allocation",
 ]);
 const HELP_WORDS = new Set(["help", "--help", "-h"]);
 
@@ -99,6 +100,9 @@ export async function run(argv, {
   if (command === "bootstrap" && args[0] === "close" && parseBootstrapCloseArgs(args).action !== "close") {
     return bootstrap(args);
   }
+  // Creating or reading local feedback guidance must work even when the
+  // credential store or network is the reason the agent is blocked.
+  if (command === "feedback" && (args[0] === "init" || HELP_WORDS.has(args[0]))) return cmdFeedback(args);
 
   await load();
   if (shouldCheckForUpdates([command, ...args])) await warnStale({ version: VERSION });
@@ -138,6 +142,7 @@ export async function run(argv, {
     }
     case "test": return cmdTest(args);
     case "evidence": return cmdEvidence(args);
+    case "feedback": return cmdFeedback(args);
     case "test-ingest": return cmdTestIngest(args);
     case "wait": return runWait(args);
     case "pw": return runPw(args);
@@ -302,18 +307,28 @@ ${bold("STAGING SIGN-IN")} (BOT-2084)
 ${bold("LOCKS")}
   locks -m [--host name]     Reserve typed local resources, including Playwright MCP lanes
   lock <resource_name> <type>  Acquire one named lock (acquire_lock)
-  unlock <resource_name>     Release one named lock (release_lock)
+                             locks/lock: exit 0 acquired · 2 queued · 1 refused.
+                             Use a resource only after exit 0; queued means another
+                             agent holds it and you are in line for it.
+  unlock <resource_name>     Release one named lock you hold (release_lock); it
+                             does not withdraw a queued request
+  unlock --queued <resource_id> <resource_lock_id>
+                             Withdraw your queued request (ids from the queued
+                             lock result; retire_queued_lock_attempt)
 
 ${bold("DURABLE WORKLOADS")}  (${cyan("bb help run")})
   run --session-id <id> --environment <env> -- <command>
                               Launch a receipt-bearing command under a detached owner
   run --foreground --kind <kind> --environment <env> -- <command>
                               Run locally with a durable lifecycle outbox
+  run status <run_id>        Read status and exact available log or receipt commands
   run inspect|cancel <run_id> Read or stop one command run
   telemetry <status|replay|doctor>
                               Inspect, replay, or gate durable lifecycle delivery
 
 ${bold("EVIDENCE")}  (${cyan("bb help evidence")})
+  feedback init|submit --file <report.json>
+                              Prepare or send a BotBuddy issue report
   evidence require <file>    Record an exact-head evidence disposition → botbuddy/ready
   evidence publish <file>    Publish a local evidence statement → botbuddy/ready check-run
 
@@ -1713,23 +1728,41 @@ export async function cmdMcp(args, {
   die(`Unknown mcp subcommand: ${sub}. Run ${cyan("botbuddy mcp --help")}.`);
 }
 
-function cmdLock(args) {
+// BOT-2994: each lock command returns its exit code (0 acquired · 2 queued ·
+// 1 refused; auth 3 / transport 5 unchanged) and says on stderr what the caller
+// holds. stdout keeps the server's result exactly as before.
+async function finishLock(response, lines) {
+  const outcome = classifyLockResponse(response);
+  for (const line of lines(outcome)) console.error(line);
+  return outcome.exit;
+}
+
+async function cmdLock(args) {
   if (args.length < 2) die("Usage: botbuddy lock <resource_name> <type>");
-  return callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] });
+  return finishLock(await callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] }), lockOutcomeLines);
 }
 
-function cmdLocks(args) {
+async function cmdLocks(args) {
+  let payload;
   try {
-    return callTool("acquire_resources", buildAcquireResourcesPayload(args));
+    payload = buildAcquireResourcesPayload(args);
   } catch (error) {
     if (error instanceof LocksUsageError) die(error.message);
     throw error;
   }
+  return finishLock(await callTool("acquire_resources", payload), lockOutcomeLines);
 }
 
-function cmdUnlock(args) {
+async function cmdUnlock(args) {
+  // BOT-2994: release_lock only releases a lock you HOLD; a queued request is
+  // withdrawn by its exact resource + queued-ledger ids (retire_queued_lock_attempt).
+  if (args[0] === "--queued") {
+    if (args.length !== 3 || !args[1] || !args[2] || args[1].startsWith("-") || args[2].startsWith("-")) die(UNLOCK_QUEUED_USAGE);
+    const response = await callTool("retire_queued_lock_attempt", { resource_id: args[1], resource_lock_id: args[2] });
+    return finishLock(response, (outcome) => unlockOutcomeLines(outcome, { queued: true }));
+  }
   if (!args[0]) die("Usage: botbuddy unlock <resource_name>");
-  return callTool("release_lock", { resource_name: args[0] });
+  return finishLock(await callTool("release_lock", { resource_name: args[0] }), (outcome) => unlockOutcomeLines(outcome));
 }
 
 function cmdTask(args) {

package/src/docker-hygiene.mjs

@@ -10,6 +10,7 @@ import { callToolJson } from "./api.mjs";
 import { acquireStackLock, lockPathForProject, projectIdFromConfig } from "./stack-file-lock.mjs";
 import { VERSION } from "./version.mjs";
 import { machineUuid } from "./machine-id.mjs";
+import { FEEDBACK_GUIDANCE } from "./feedback-reminder.mjs";
 
 export const SCHEMA_VERSION = 1;
 // BOT-2206: preflight applies policy v3's network term (BOT-2202). Docker's built-in
@@ -1311,7 +1312,7 @@ export function cmdDocker(argv) {
     return;
   }
   return runDockerCommand(argv).then((result) => {
-    if (result.json) console.log(JSON.stringify(result.receipt));
+    if (result.json) console.log(JSON.stringify(result.exitCode === EXIT.OK ? result.receipt : { ...result.receipt, feedback_guidance: FEEDBACK_GUIDANCE }));
     else console.log(formatHumanReceipt(result.receipt));
     if (result.exitCode !== EXIT.OK) process.exitCode = result.exitCode;
   });

package/src/feedback-outbox.mjs

@@ -0,0 +1,119 @@
+// Private, bounded retry storage. Never stores credentials; a cached agent and
+// tenant are only a replay fence and are rechecked against whoami at delivery.
+import { chmod, link, lstat, mkdir, open, readdir, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { acquireStackLock } from "./stack-file-lock.mjs";
+import { restrictWindowsAcl, restrictWindowsAclDir } from "./agent-state-fs.mjs";
+import { containsFeedbackSecret } from "./feedback-safety.mjs";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TENANT = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const MAX_ITEMS = 100;
+const MAX_BYTES = 32 * 1024;
+const sensitive = containsFeedbackSecret;
+
+async function directory(root) {
+  const path = join(root, ".botbuddy", "feedback-outbox");
+  await mkdir(path, { recursive: true, mode: 0o700 });
+  const info = await lstat(path);
+  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("outbox_directory_invalid");
+  if (process.platform === "win32") await restrictWindowsAclDir(path);
+  else {
+    await chmod(path, 0o700);
+    if (((await lstat(path)).mode & 0o077) !== 0) throw new Error("outbox_directory_not_private");
+  }
+  return path;
+}
+
+function validRecord(record) {
+  return record && record.schema_version === 1 && typeof record.agent_id === "string" && UUID.test(record.agent_id) && typeof record.tenant === "string" && TENANT.test(record.tenant) &&
+    record.report && typeof record.report === "object" && !Array.isArray(record.report) && typeof record.report.idempotency_key === "string" && UUID.test(record.report.idempotency_key);
+}
+
+async function syncDir(path) {
+  if (process.platform === "win32") return;
+  const handle = await open(path, "r");
+  try { await handle.sync(); } finally { await handle.close(); }
+}
+
+export async function queueFeedback({ root, agentId, tenant, report }) {
+  const record = { schema_version: 1, agent_id: agentId, tenant, created_at: new Date().toISOString(), report };
+  if (!validRecord(record)) throw new Error("outbox_identity_unavailable");
+  if (sensitive(report)) throw new Error("outbox_sensitive_value");
+  const text = `${JSON.stringify(record)}\n`;
+  if (Buffer.byteLength(text) > MAX_BYTES) throw new Error("outbox_report_too_large");
+  const path = await directory(root);
+  const lock = await acquireStackLock(join(path, ".lock"), { timeoutMs: 2000 });
+  try {
+    const final = join(path, `${report.idempotency_key.toLowerCase()}.json`);
+    const names = (await readdir(path)).filter((name) => /^[0-9a-f-]{36}\.json$/i.test(name));
+    if (names.length >= MAX_ITEMS && !names.includes(`${report.idempotency_key.toLowerCase()}.json`)) throw new Error("outbox_full");
+    const temp = join(path, `.${randomUUID()}.tmp`);
+    try {
+      const file = await open(temp, "wx", 0o600);
+      try { await file.writeFile(text); await file.sync(); } finally { await file.close(); }
+      if (process.platform === "win32") await restrictWindowsAcl(temp);
+      else await chmod(temp, 0o600);
+      try { await link(temp, final); }
+      catch (error) {
+        if (error?.code !== "EEXIST") throw error;
+        const existingInfo = await lstat(final);
+        if (!existingInfo.isFile() || existingInfo.isSymbolicLink() || existingInfo.size > MAX_BYTES || (process.platform !== "win32" && (existingInfo.mode & 0o077) !== 0)) throw new Error("outbox_record_invalid");
+        const existing = JSON.parse(await readFile(final, "utf8"));
+        if (!validRecord(existing) || existing.agent_id !== agentId || existing.tenant !== tenant || !isDeepStrictEqual(existing.report, report)) throw new Error("outbox_idempotency_conflict");
+      }
+      await syncDir(path);
+      return { queued: true, idempotency_key: report.idempotency_key, flush_command: "bb feedback flush" };
+    } finally { await unlink(temp).catch(() => {}); }
+  } finally { lock.release(); }
+}
+
+// Caller owns the exclusive lock for the whole bounded replay. Corrupt files
+// are retained, and a successful operation is the only authority to delete.
+export async function withFeedbackOutbox(root, operation) {
+  const path = await directory(root);
+  const lock = await acquireStackLock(join(path, ".lock"), { timeoutMs: 2000 });
+  try {
+    const names = (await readdir(path)).filter((name) => /^[0-9a-f-]{36}\.json$/i.test(name)).sort();
+    return await operation(names.slice(0, 10).map((name) => ({ name, path: join(path, name) })), {
+      more: names.length > 10,
+      read: async (item) => {
+        const info = await lstat(item.path);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_BYTES || (process.platform !== "win32" && (info.mode & 0o077) !== 0)) throw new Error("outbox_record_invalid");
+        const record = JSON.parse(await readFile(item.path, "utf8"));
+        if (!validRecord(record) || sensitive(record.report) || item.name.toLowerCase() !== `${record.report.idempotency_key.toLowerCase()}.json`) throw new Error("outbox_record_invalid");
+        return record;
+      },
+      exportDraft: async (record) => {
+        const final = join(path, `draft-${record.report.idempotency_key.toLowerCase()}.json`);
+        const text = `${JSON.stringify(record.report, null, 2)}\n`;
+        if (Buffer.byteLength(text) > MAX_BYTES) throw new Error("outbox_report_too_large");
+        const temp = join(path, `.${randomUUID()}.tmp`);
+        try {
+          const file = await open(temp, "wx", 0o600);
+          try { await file.writeFile(text); await file.sync(); } finally { await file.close(); }
+          if (process.platform === "win32") await restrictWindowsAcl(temp); else await chmod(temp, 0o600);
+          try { await link(temp, final); } catch (error) {
+            if (error?.code !== "EEXIST") throw error;
+            const info = await lstat(final);
+            if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_BYTES || (process.platform !== "win32" && (info.mode & 0o077) !== 0) || await readFile(final, "utf8") !== text) throw new Error("outbox_draft_conflict");
+          }
+          await syncDir(path);
+          return final;
+        } finally { await unlink(temp).catch(() => {}); }
+      },
+      remove: async (item) => { await unlink(item.path); await syncDir(path); },
+    });
+  } finally { lock.release(); }
+}
+
+export async function hasPendingFeedback(root) {
+  const path = join(root, ".botbuddy", "feedback-outbox");
+  try {
+    const info = await lstat(path);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("outbox_directory_invalid");
+    return (await readdir(path)).some((name) => /^[0-9a-f-]{36}\.json$/i.test(name));
+  } catch (error) { if (error?.code === "ENOENT") return false; throw error; }
+}

package/src/feedback-reminder.mjs

@@ -0,0 +1,16 @@
+export const FEEDBACK_GUIDANCE = Object.freeze({
+  when: "If BotBuddy is blocking your work",
+  init_command: "bb feedback init --file bb-feedback.json",
+  submit_command: "bb feedback submit --file bb-feedback.json",
+  context: "Add your goal, expected and actual outcomes, evidence and why you are blocked. Preserve the original run and the report's idempotency key.",
+});
+let guidanceAlreadyShown = false;
+export function markFeedbackGuidanceShown() { guidanceAlreadyShown = true; }
+
+/** Print only guidance, not an automatic incident classification. A failed
+ * child test, invalid input or ordinary refusal does not prove a BB defect. */
+export function feedbackReminder(argv, code) {
+  if (guidanceAlreadyShown || !Number.isInteger(code) || code === 0 || argv[0] === "feedback" || argv.includes("--json") ||
+      (argv[0] === "run" && ["--worker", "--deliver"].includes(argv[1]))) return null;
+  return `${FEEDBACK_GUIDANCE.when}, run \`${FEEDBACK_GUIDANCE.init_command}\`, add your goal, expected and actual outcomes, evidence and why you are blocked, then run \`${FEEDBACK_GUIDANCE.submit_command}\`. Preserve the original run and the report's idempotency key.`;
+}

package/src/feedback-safety.mjs

@@ -0,0 +1,31 @@
+import { containsSensitive } from "./telemetry-outbox.mjs";
+
+// Only non-secret BB receipt queries are shareable; arbitrary query strings
+// and fragments may contain signed credentials and remain forbidden.
+export function isSafeBotBuddyReceiptUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.origin !== "https://app.bot-buddy.ai" || url.username || url.password || url.hash) return false;
+    const key = url.pathname === "/waits" ? "wait" : url.pathname === "/docker" ? "lease" : null;
+    if (!key || [...url.searchParams.keys()].length !== 1) return false;
+    const id = url.searchParams.get(key);
+    return typeof id === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+  } catch { return false; }
+}
+
+export function containsFeedbackSecret(value) {
+  // This public numeric setting resembles a bb_ credential. Exempt its exact
+  // case-sensitive name only; still scan assigned values and surrounding text.
+  if (typeof value === "string") {
+    value = value.replace(/\\u([0-9a-f]{4})/gi, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
+    return containsSensitive(value.replace(/\bBB_HERMETIC_INTEGRATION_TIMEOUT_SEC\b/g, "PUBLIC_TIMEOUT_SETTING")) ||
+    /-----begin[a-z0-9 ]*private key-----/i.test(value) ||
+    /\\?["'][a-z0-9_-]*(?:password|passwd|token|api[_-]?key|private[_-]?key|secret|authorization|proxy[_-]?authorization|cookie|set[_-]?cookie)[a-z0-9_-]*\\?["']\s*[:=]\s*(?:"[^"]+"|'[^']+'|[^\s,}\]]+)/i.test(value) ||
+    /\b[a-z0-9_-]*(?:password|passwd|token|api[_-]?key|private[_-]?key|secret|authorization|proxy[_-]?authorization|cookie|set[_-]?cookie)[a-z0-9_-]*\s*[:=]\s*(?:"[^"]+"|'[^']+'|[^\s,}\]]+)/i.test(value) ||
+    (!isSafeBotBuddyReceiptUrl(value) && /https?:\/\/[^\s<>"']+[?#][^\s<>"']+/i.test(value)) ||
+    /\b(?:authorization|proxy-authorization|cookie|set-cookie|x-api-key|apikey)\s*:\s*\S+/i.test(value) ||
+    /\blin_api_[a-z0-9_-]{12,}|\bsk-(?:proj-|svcacct-)?[a-z0-9_-]{20,}|\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/i.test(value);
+  }
+  if (Array.isArray(value)) return value.some(containsFeedbackSecret);
+  return value !== null && typeof value === "object" && Object.entries(value).some(([key, item]) => (/^[a-z0-9_-]*(?:password|passwd|token|api[_-]?key|private[_-]?key|secret|authorization|proxy[_-]?authorization|cookie|set[_-]?cookie)[a-z0-9_-]*$/i.test(key) && item != null && item !== "") || containsFeedbackSecret(key) || containsFeedbackSecret(item));
+}

package/src/feedback.integration.fixture.mjs

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { cmdFeedback } from "./feedback.mjs";
+import { cmdRun, OUTCOME_CHANNEL } from "./stack.mjs";
+import { harnessSessionIdFromEnv } from "./agent-state.mjs";
+
+const endpoint = process.argv[2];
+const out = [], errors = [];
+const evidenceLink = "https://app.bot-buddy.ai/waits?wait=485c66f8-c804-4a0f-a49e-2ceaf06344f8";
+const deps = (foreign = false) => ({
+  read: async () => JSON.stringify({ idempotency_key: randomUUID(), kind: "bug", surface: "cli", title: "CLI feedback integration", impact: "slowed", evidence: [{ type: "url", value: evidenceLink }] }),
+  resolveAuth: async () => ({ auth: {} }),
+  call: async (tool, args) => (await fetch(endpoint, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ tool, args, foreign }) })).json(),
+  log: (line) => out.push(line), errorLog: (line) => errors.push(line),
+});
+assert.equal(await cmdFeedback(["submit", "--file", "report.json"], deps()), 0);
+const receipt = JSON.parse(out.pop()), id = receipt.feedback_id;
+assert.equal(receipt.status_command, `bb feedback status --feedback-id ${id}`);
+assert.equal(await cmdFeedback(["status", "--feedback-id", id], deps()), 0);
+const status = JSON.parse(out.pop());
+assert.equal(status.feedback_id, id);
+assert.equal(status.report.evidence[0].value, evidenceLink);
+assert.equal(await cmdFeedback(["updates", "--feedback-id", id], deps()), 0);
+const updates = JSON.parse(out.pop());
+assert.ok(updates.items.length > 0);
+const revision = updates.items[0].revision;
+assert.equal(updates.items[0].acknowledge_command, `bb feedback acknowledge --feedback-id ${id} --revision ${revision}`);
+assert.equal(await cmdFeedback(["acknowledge", "--feedback-id", id, "--revision", String(revision)], deps()), 0);
+assert.equal(JSON.parse(out.pop()).revision, revision);
+assert.equal(await cmdFeedback(["updates", "--feedback-id", id], deps()), 0);
+assert.ok(JSON.parse(out.pop()).items[0].acknowledged_at);
+assert.deepEqual(errors, []);
+assert.equal(await cmdFeedback(["status", "--feedback-id", id], deps(true)), 1);
+assert.match(errors[0], /unavailable/);
+const sourceRun = randomUUID();
+const failure = { exitCode: 6, outcome: "failed", code: "TUNNEL_LOST", parkReason: "tunnel_lost", leaseId: randomUUID(), childExitCode: 143, cleanup: { ok: true }, fenced: false };
+Object.defineProperty(failure, OUTCOME_CHANNEL, { value: { auth: {}, callTool: deps().call }, enumerable: false });
+const originalWrite = process.stdout.write;
+let stackReceipt = "", feedbackMessage = "";
+try {
+  process.stdout.write = (chunk) => { stackReceipt += chunk; return true; };
+  const code = await cmdRun({ repo: "botbuddy-web", ticket: "BOT-1540", runId: sourceRun }, ["true"], { lifecycle: async () => failure, env: { BOTBUDDY_STACK_RUN_OUTCOME: "on" }, feedbackLog: (message) => { feedbackMessage += message; }, markFeedback: () => {} });
+  assert.equal(code, 6);
+} finally { process.stdout.write = originalWrite; }
+assert.equal(JSON.parse(stackReceipt).exit_code, 6);
+assert.equal(JSON.parse(stackReceipt).feedback_recovery.recover_command, "bb feedback recover");
+const capturedId = /bb feedback status --feedback-id ([0-9a-f-]+)/i.exec(feedbackMessage)?.[1];
+assert.ok(capturedId, "stack failure must expose the captured feedback ID");
+assert.ok(feedbackMessage.includes(`bb feedback enrich --feedback-id ${capturedId}`));
+assert.equal(await cmdFeedback(["status", "--feedback-id", capturedId], deps()), 0);
+const auto = JSON.parse(out.pop());
+assert.equal(auto.report.correlation_id, sourceRun);
+assert.equal(auto.capture_state, "needs_context");
+assert.equal(auto.failure_attribution, "exact");
+const duplicateDeps = deps();
+duplicateDeps.read = async () => JSON.stringify({ idempotency_key: randomUUID(), kind: "bug", surface: "stack", title: "A separately drafted report", impact: "blocked", correlation_id: sourceRun });
+const duplicateExit = await cmdFeedback(["submit", "--file", "report.json"], duplicateDeps);
+assert.equal(duplicateExit, 1, `duplicate-source receipt: ${out.at(-1)}`);
+const duplicate = JSON.parse(out.pop());
+assert.equal(duplicate.error, "source_already_reported");
+assert.equal(duplicate.feedback_id, capturedId);
+assert.equal(duplicate.submitted_context_saved, false);
+assert.deepEqual(duplicate.enrich_argv, ["bb", "feedback", "enrich", "--feedback-id", capturedId, "--file", "report.json"]);
+assert.equal(await cmdFeedback(["recover"], deps()), 0);
+assert.equal(JSON.parse(out.pop()).complete, true);
+// Lose the first reply after the real MCP handler commits; the private outbox
+// must replay the same key only after real session whoami confirms its owner.
+const root = await mkdtemp(join(tmpdir(), "bb-feedback-live-replay-"));
+const queueKey = randomUUID(), fixtureToken = "fixture-session-token";
+let dropResponse = true;
+const outboxDeps = {
+  ...deps(), cwd: root, rootFor: async () => root,
+  loadState: async () => ({ agent_id: process.argv[3], tenant: "botbuddy", agent_session_token: fixtureToken, harness_session_id: harnessSessionIdFromEnv() }),
+  resolveAuth: async () => ({ auth: { "x-agent-api-key": fixtureToken }, sessionToken: true }),
+  read: async () => JSON.stringify({ idempotency_key: queueKey, kind: "bug", surface: "cli", title: "Offline replay fixture", impact: "slowed", evidence: [{ type: "url", value: evidenceLink }] }),
+  call: async (tool, args) => {
+    const response = await (await fetch(endpoint, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ tool, args, session: true }) })).json();
+    if (tool === "submit_feedback" && dropResponse) { dropResponse = false; return { ok: false, status: null, error: "lost_reply" }; }
+    return response;
+  },
+};
+assert.equal(await cmdFeedback(["submit", "--file", "report.json"], outboxDeps), 5);
+assert.equal(JSON.parse(out.pop()).queued_locally, true);
+assert.equal(await cmdFeedback(["flush"], outboxDeps), 0);
+assert.equal(JSON.parse(out.pop()).delivered, 1);
+assert.deepEqual(await readdir(join(root, ".botbuddy", "feedback-outbox")), []);
+dropResponse = true;
+const duplicateKey = randomUUID();
+outboxDeps.read = async () => JSON.stringify({ idempotency_key: duplicateKey, kind: "bug", surface: "stack", title: "Queued tunnel report", impact: "blocked", correlation_id: sourceRun });
+assert.equal(await cmdFeedback(["submit", "--file", "report.json"], outboxDeps), 5);
+assert.equal(JSON.parse(out.pop()).queued_locally, true);
+assert.equal(await cmdFeedback(["flush"], outboxDeps), 1);
+const queuedDuplicate = JSON.parse(out.pop());
+assert.equal(queuedDuplicate.error, "source_already_reported");
+assert.equal(queuedDuplicate.feedback_id, capturedId);
+assert.equal(await cmdFeedback(["enrich", "--feedback-id", capturedId, "--file", queuedDuplicate.enrich_argv[6]], outboxDeps), 0);
+out.pop();
+assert.equal(await cmdFeedback(["flush"], outboxDeps), 0);
+assert.equal(JSON.parse(out.pop()).delivered, 1);
+process.stdout.write("feedback CLI round-trip passed\n");