usebeeline 0.0.50 → 0.0.52

package/dist/usebeeline.mjs

@@ -14141,6 +14141,39 @@ import { basename as basename3, dirname as dirname5, join as join3, relative as
 // apps/body/dist/beeline-skill.js
 import { readFileSync as readFileSync3 } from "node:fs";
 import { resolve as resolve11 } from "node:path";
+
+// packages/api-contract/dist/system-events.js
+var SERVER_EVENT_KINDS = [
+  "joined",
+  "schedule-ran",
+  "corner-opened",
+  "check-passed",
+  "check-failed",
+  "merged",
+  "grant-decided"
+];
+function isServerEventKind(value) {
+  return SERVER_EVENT_KINDS.includes(value);
+}
+var RESUME_KINDS = ["grant-decided"];
+function isResumeKind(value) {
+  return RESUME_KINDS.includes(value);
+}
+
+// packages/api-contract/dist/agent-pairing-code.js
+var CURRENT_AGENT_PAIRING_CODE = /^[0-9A-F]{8}-[0-9A-F]{8}$/;
+var LEGACY_AGENT_PAIRING_CODE = /^BUZZ-(?:[0-9A-F]{8}-[0-9A-F]{8}|[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4})$/;
+function normalizeAgentPairingCode(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const normalized = value.trim().toUpperCase();
+  return isAgentPairingCode(normalized) ? normalized : void 0;
+}
+function isAgentPairingCode(value) {
+  return typeof value === "string" && (CURRENT_AGENT_PAIRING_CODE.test(value) || LEGACY_AGENT_PAIRING_CODE.test(value));
+}
+
+// apps/body/dist/beeline-skill.js
 var USING_BEELINE_SKILL_NAME = "using-beeline";
 var BEELINE_ROOM_CAPABILITIES = [
   "The repository filesystem is read-only in this Room session.",
@@ -14151,7 +14184,7 @@ var BEELINE_ROOM_CAPABILITIES = [
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
   "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent attach_file with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote); it is attached to your reply. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
   "To run something later or repeatedly, call beeline-agent create_schedule (interval in minutes or a 5-field cron, optional maxRuns); list_schedules / delete_schedule manage them.",
-  "To react to things that HAPPEN in this Room rather than only to what is said to you, call beeline-agent subscribe_events with the kinds you want (joined, schedule-ran, corner-opened, check-passed, check-failed, merged); each one then wakes you for a turn. It replaces your list, so send every kind you want - list_event_subscriptions shows the current one. You do this yourself: nobody has to configure it for you.",
+  `To react to things that HAPPEN in this Room rather than only to what is said to you, call beeline-agent subscribe_events with the kinds you want (${SERVER_EVENT_KINDS.join(", ")}); each one then wakes you for a turn. It replaces your list, so send every kind you want - list_event_subscriptions shows the current one. You do this yourself: nobody has to configure it for you. grant-decided carries the grant id and status and resumes the turn that asked for the grant.`,
   "To state something that happened so the Room and other agents can act on it, call beeline-agent emit_event with your own agent:<slug> kind, one sentence, and optionally the agent members to wake. Chains of events are bounded and a refused emit posts nothing.",
   "When repository work is needed, you MUST call beeline-agent open_corner with a name of at most three words - it titles the corner everywhere - and a complete objective of no more than 24 words. The host-governed call is the only way to start write work.",
   "When open_corner succeeds, the server posts the corner card: do not announce or restate the opening. End the turn with nothing more unless the person asked something else.",
@@ -15111,6 +15144,7 @@ async function resolveSharedSkillSources(operatorHome, names) {
     return resolveExplicitSkillSources(operatorHome, names);
   const seen = /* @__PURE__ */ new Set();
   const resolved = [];
+  const skipped = [];
   for (const relativeRoot of OPERATOR_SKILL_SOURCE_DIRS) {
     const sourceRoot = resolve13(operatorHome, relativeRoot);
     const rootStats = await lstat(sourceRoot).catch(() => void 0);
@@ -15122,23 +15156,61 @@ async function resolveSharedSkillSources(operatorHome, names) {
       const candidate = resolve13(sourceRoot, entry);
       try {
         const candidateStats = await lstat(candidate);
-        if (!candidateStats.isDirectory() || candidateStats.isSymbolicLink())
+        if (candidateStats.isSymbolicLink()) {
+          const reason = await realpath(candidate).then(() => "symlinked directory", (error) => isMissingPathError(error) ? "dangling symlink" : "symlinked directory");
+          skipped.push({
+            path: candidate,
+            reason
+          });
+          continue;
+        }
+        if (!candidateStats.isDirectory()) {
+          skipped.push({ path: candidate, reason: "not an ordinary directory" });
           continue;
+        }
         assertContained(sourceRoot, candidate);
         const skillMd = resolve13(candidate, "SKILL.md");
-        const skillStats = await lstat(skillMd);
+        const skillStats = await lstat(skillMd).catch((error) => {
+          if (isMissingPathError(error)) {
+            skipped.push({ path: candidate, reason: "missing SKILL.md" });
+            return void 0;
+          }
+          throw error;
+        });
+        if (!skillStats)
+          continue;
         if (!skillStats.isFile() || skillStats.isSymbolicLink() || skillStats.nlink !== 1) {
-          throw new Error(`shared skill requires an ordinary SKILL.md: ${entry}`);
+          skipped.push({ path: candidate, reason: "SKILL.md is not an ordinary file" });
+          continue;
         }
         seen.add(entry);
         resolved.push({ name: entry, source: candidate });
       } catch (error) {
+        if (isMissingPathError(error)) {
+          skipped.push({ path: candidate, reason: "missing during discovery" });
+          continue;
+        }
         console.warn(`[body] skipping operator skill ${entry}:`, error);
       }
     }
   }
+  logSkippedOperatorSkills(skipped);
   return resolved;
 }
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function logSkippedOperatorSkills(skipped) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const { path, reason } of skipped) {
+    console.warn(`[body] skipping operator skill ${path}: ${reason}`);
+    totals.set(reason, (totals.get(reason) ?? 0) + 1);
+  }
+  for (const [reason, count] of totals) {
+    if (count > 1)
+      console.warn(`[body] ${count} skill entries skipped: ${reason}`);
+  }
+}
 async function resolveExplicitSkillSources(operatorHome, names) {
   const unique = [...new Set(names)];
   for (const name of unique) {
@@ -17411,24 +17483,6 @@ import { join as join6 } from "node:path";
 var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
 var SCHEDULE_RAN_VERB = "ran a schedule for";
 
-// packages/api-contract/dist/system-events.js
-var SERVER_EVENT_KINDS = [
-  "joined",
-  "schedule-ran",
-  "corner-opened",
-  "check-passed",
-  "check-failed",
-  "merged",
-  "grant-decided"
-];
-function isServerEventKind(value) {
-  return SERVER_EVENT_KINDS.includes(value);
-}
-var RESUME_KINDS = ["grant-decided"];
-function isResumeKind(value) {
-  return RESUME_KINDS.includes(value);
-}
-
 // apps/body/dist/monolith-room-turn.js
 function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
   if (isSquireMcpPermissionRequest(request))
@@ -17501,6 +17555,15 @@ function agentReplyMentionIds(text2, roster, authorId) {
       aliases.set(key, entry);
     }
   }
+  for (const member of roster.members) {
+    if (member.identityId === authorId || !member.handle)
+      continue;
+    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
+    const canonical = aliases.get(handle);
+    const legacy = `a_${handle}`;
+    if (canonical && !aliases.has(legacy))
+      aliases.set(legacy, { ...canonical, display: legacy });
+  }
   const mentioned = [];
   for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
     if (ids.size !== 1)
@@ -19502,19 +19565,6 @@ import { chmod as chmod5, mkdir as mkdir14, readFile as readFile10, unlink as un
 import { dirname as dirname10, resolve as resolve22 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
-// packages/api-contract/dist/agent-pairing-code.js
-var CURRENT_AGENT_PAIRING_CODE = /^[0-9A-F]{8}-[0-9A-F]{8}$/;
-var LEGACY_AGENT_PAIRING_CODE = /^BUZZ-(?:[0-9A-F]{8}-[0-9A-F]{8}|[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4})$/;
-function normalizeAgentPairingCode(value) {
-  if (typeof value !== "string")
-    return void 0;
-  const normalized = value.trim().toUpperCase();
-  return isAgentPairingCode(normalized) ? normalized : void 0;
-}
-function isAgentPairingCode(value) {
-  return typeof value === "string" && (CURRENT_AGENT_PAIRING_CODE.test(value) || LEGACY_AGENT_PAIRING_CODE.test(value));
-}
-
 // apps/body/dist/clack-support.js
 import { stdout as stdout2 } from "node:process";
 var FALLBACK_TERMINAL_COLUMNS = 80;
@@ -20820,39 +20870,59 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
 `, { mode: 384 });
   return true;
 }
+function siblingRevertNote(attempt, loadedRelease) {
+  if (!loadedRelease || attempt?.releaseId !== loadedRelease || attempt.status !== "reverted") {
+    return void 0;
+  }
+  return `shared update attempt reverted by sibling ${attempt.revertedBy ?? "unknown"}: ${attempt.failure ?? "no failure recorded"}`;
+}
+function describeOwnProof(proof) {
+  return proof.modelAnswer === "unavailable" ? `this daemon's own probe reached the model boundary without an answer (${proof.modelAnswerReason ?? "no reason recorded"})` : "this daemon's own probe passed";
+}
+function attemptFailureText(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/\s+/g, " ").trim().slice(0, 300);
+}
 async function gateManagedSuccessor(input) {
   try {
     const attempt = await readUpdateAttempt(input.layout);
     const desiredRelease = attempt?.status === "pending" ? attempt.releaseId : void 0;
     if (!desiredRelease || !input.loadedRelease || desiredRelease !== input.loadedRelease) {
-      throw new Error(`successor loaded release ${input.loadedRelease ?? "unknown"}, not the pending desired release`);
+      const reverted = siblingRevertNote(attempt, input.loadedRelease);
+      throw new Error(reverted ? `successor release ${input.loadedRelease} was reverted before this daemon probed it: ${reverted}` : `successor loaded release ${input.loadedRelease ?? "unknown"}, not the pending desired release`);
     }
     const proof = await input.probe();
     if (!await proveLoadedReleaseReady(input.layout, input.runtimeDir, input.loadedRelease, {
       probeId: input.probeId,
       functionalProof: proof
     })) {
-      throw new Error(`successor release ${input.loadedRelease} did not produce functional proof`);
+      const reverted = siblingRevertNote(await readUpdateAttempt(input.layout), input.loadedRelease);
+      throw new Error(reverted ? `successor release ${input.loadedRelease} lost its attempt while this daemon proved it: ${describeOwnProof(proof)}; ${reverted}` : `successor release ${input.loadedRelease} did not produce functional proof`);
     }
     return { kind: "passed", proof };
   } catch (error) {
     return {
       kind: "failed",
       error,
-      rolledBack: await rollbackFailedSuccessor(input.layout, input.runtimeDir)
+      rolledBack: await rollbackFailedSuccessor(input.layout, input.runtimeDir, {
+        probeId: input.probeId,
+        failure: attemptFailureText(error)
+      })
     };
   }
 }
-async function rollbackFailedSuccessor(layout, runtimeDir) {
+async function rollbackFailedSuccessor(layout, runtimeDir, cause = {}) {
   return withInstallLock(layout, async () => {
     const attempt = await readUpdateAttempt(layout);
     if (!attempt || attempt.status !== "pending")
       return false;
+    const attribution = cause.probeId ? { revertedBy: cause.probeId } : {};
     if (!attempt.previousReleaseId) {
       await replaceUpdateAttempt(layout, {
         ...attempt,
         status: "reverted",
-        failure: "functional served-turn proof failed, but no previous release exists"
+        failure: cause.failure ?? "functional served-turn proof failed, but no previous release exists",
+        ...attribution
       });
       return false;
     }
@@ -20860,7 +20930,8 @@ async function rollbackFailedSuccessor(layout, runtimeDir) {
     await replaceUpdateAttempt(layout, {
       ...attempt,
       status: "reverted",
-      failure: "functional served-turn proof failed before confirmation"
+      failure: cause.failure ?? "functional served-turn proof failed before confirmation",
+      ...attribution
     });
     if (runtimeDir)
       await queueUpdateRollbackAlert(runtimeDir, attempt.releaseId);
@@ -21067,6 +21138,28 @@ import { resolve as resolve26 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
 var UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS = 2e4;
 var UPDATE_PROBE_TURN_TIMEOUT_MS = 45e3;
+var ACP_ERROR_CODE = /\bACP error (-\d+):/;
+var ACP_PROMPT_INACTIVITY = /\bACP session\/prompt timed out after \d+ms of inactivity\b/;
+function isServerInternalCode(code) {
+  return code === -32603 || code <= -32e3 && code >= -32099;
+}
+function classifyAcpTurnFailure(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
+  if (!message)
+    return void 0;
+  if (ACP_PROMPT_INACTIVITY.test(message))
+    return { kind: "prompt-inactivity" };
+  const code = Number(ACP_ERROR_CODE.exec(message)?.[1]);
+  if (Number.isFinite(code) && isServerInternalCode(code))
+    return { kind: "server-internal", code };
+  return void 0;
+}
+function sameAcpTurnFailure(one, other) {
+  if (one.kind === "server-internal") {
+    return other.kind === "server-internal" && one.code === other.code;
+  }
+  return other.kind === one.kind;
+}
 var UpdateFunctionalProbeError = class extends Error {
   reason;
   code = "BEELINE_UPDATE_FUNCTIONAL_PROBE_FAILED";
@@ -21138,6 +21231,7 @@ async function runUpdateFunctionalProbe(input) {
       args: agentArgsWithModelSelection(selectedAgent, input.config.modelSelection)
     };
     let modelAnswer = {};
+    let turnCompleted = true;
     if (input.config.bwrapPath) {
       const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
       const operatorHome = input.config.operatorHome ?? homedir10();
@@ -21199,7 +21293,11 @@ async function runUpdateFunctionalProbe(input) {
                 ...refusal ? { providerRefusal: refusal } : {}
               });
             }
-            const current = await input.compareWithCurrentRelease(refusal);
+            const current = await input.compareWithCurrentRelease({
+              kind: "provider-refusal",
+              reason: refusal.reason,
+              refusal
+            });
             if (current.kind !== "refused" || current.status !== refusal.status) {
               throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { providerRefusal: refusal });
             }
@@ -21214,7 +21312,26 @@ async function runUpdateFunctionalProbe(input) {
       } catch (error) {
         if (error instanceof UpdateFunctionalProbeError)
           throw error;
-        throw new UpdateFunctionalProbeError("turn-failed", error instanceof Error ? error.message : String(error), { cause: error });
+        const detail = error instanceof Error ? error.message : String(error);
+        const failure = classifyAcpTurnFailure(error);
+        if (!failure || !input.compareWithCurrentRelease) {
+          throw new UpdateFunctionalProbeError("turn-failed", detail, { cause: error });
+        }
+        const current = await input.compareWithCurrentRelease({
+          kind: "acp-turn-failure",
+          reason: detail,
+          failure
+        });
+        const currentFailure = current.kind === "unavailable" ? classifyAcpTurnFailure(current.reason) : void 0;
+        if (!currentFailure || !sameAcpTurnFailure(failure, currentFailure)) {
+          throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { cause: error });
+        }
+        console.warn(`[body] update probe: the probe turn failed the same way on this release and the current release (${detail}); that failure is not this bundle's doing, so the probe passes as inconclusive`);
+        turnCompleted = false;
+        modelAnswer = {
+          modelAnswer: "unavailable",
+          modelAnswerReason: `${detail} (the current release fails the same way)`
+        };
       }
     } catch (error) {
       if (error instanceof UpdateFunctionalProbeError)
@@ -21225,7 +21342,7 @@ async function runUpdateFunctionalProbe(input) {
       harness,
       sandboxed: Boolean(input.config.bwrapPath),
       sessionStarted: true,
-      turnCompleted: true,
+      turnCompleted,
       nativeTools: [],
       ...modelAnswer
     };
@@ -21239,7 +21356,7 @@ async function runUpdateFunctionalProbe(input) {
 import { spawn as spawn7 } from "node:child_process";
 import { dirname as dirname14, join as join8 } from "node:path";
 init_self_update();
-var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 8e4;
+var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 12e4;
 var UPDATE_PROBE_COMMAND = "update-probe";
 function parseReport(line) {
   let parsed;
@@ -21567,8 +21684,8 @@ async function runStoredDaemon(pathOrPointer) {
               releaseId: loadedRelease ?? "unknown",
               sandboxRequired: runtime.sandbox !== "off",
               ...currentReleaseId ? {
-                compareWithCurrentRelease: async (refusal) => {
-                  console.warn(`[thin-core] successor probe refused by the provider (${refusal.reason}); probing the current release ${currentReleaseId} for the same refusal`);
+                compareWithCurrentRelease: async (appeal) => {
+                  console.warn(`[thin-core] successor probe got no answer from the provider (${appeal.reason}); probing the current release ${currentReleaseId} for the same outcome`);
                   await extendSystemdStartTimeout(CURRENT_RELEASE_PROBE_TIMEOUT_MS + 15e3);
                   return probeReleaseInSubprocess({
                     layout,
@@ -21614,7 +21731,12 @@ async function runStoredDaemon(pathOrPointer) {
       console.log(`[beeline] agent ${runtime.agent.publicKey} removed; runtime archived at ${archivedRuntime}`);
     }
   } catch (error) {
-    const rolledBack = successorRolledBack || layout && pendingSuccessor && !ready && await rollbackFailedSuccessor(layout, runtimeDir);
+    const rolledBack = successorRolledBack || layout && pendingSuccessor && !ready && // Named, so a sibling daemon's journal can say whose failure reverted
+    // the attempt it shares with this one.
+    await rollbackFailedSuccessor(layout, runtimeDir, {
+      probeId: runtime.agent.publicKey,
+      failure: attemptFailureText(error)
+    });
     if (rolledBack) {
       console.error("[thin-core] successor failed before READY; previous release restored once");
       const alertRoom = runtime.rooms[0]?.channelId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {