@heretek-ai/epistemic-swarm 2.3.0 → 2.5.0

package/dist/tui.js

@@ -22,16 +22,29 @@ var TERMINAL_FALLBACK = (stage) => `Run \`es approve ${stage}\` at a terminal wi
 var APPROVAL_PREVIEW_TTL_MS = 120000;
 async function approveInTui(input) {
   const dir = input.stateDir ?? defaultStateDir();
+  const clock = input.now ?? Date.now;
+  const locked = (retryAfterSec) => ({
+    ok: false,
+    locked: true,
+    retryAfterSec,
+    retryAt: new Date(clock() + retryAfterSec * 1000).toISOString()
+  });
   if (!await exists(factoryLayout(input.root).dir) || !await hasHumanKey(dir))
     return { ok: false, fallback: true, reason: TERMINAL_FALLBACK(input.stage) };
   const gate = await checkApprovalAttempts(dir);
   if (!gate.allowed)
-    return { ok: false, locked: true, retryAfterSec: gate.retryAfterSec ?? 0 };
-  const title = `Approve ${input.stage} as ${input.approvedBy ?? userInfo().username}`;
+    return locked(gate.retryAfterSec ?? 0);
+  const base = `Approve ${input.stage} as ${input.approvedBy ?? userInfo().username}`;
+  let feedback;
   for (;; ) {
+    const title = feedback ? `${base} \u2014 ${feedback}` : base;
     const codepoints = await input.readPassphrase(title);
     if (codepoints === undefined)
       return { ok: false, cancelled: true };
+    if (codepoints.length === 0) {
+      zeroCodepoints(codepoints);
+      return { ok: false, cancelled: true };
+    }
     const passphrase = codepoints.join("");
     zeroCodepoints(codepoints);
     try {
@@ -59,7 +72,8 @@ async function approveInTui(input) {
       if (error instanceof HumanKeyError && error.message === "wrong passphrase") {
         const check = await noteWrongPassphrase({ dir, root: input.root, stage: input.stage, channel: "tui" });
         if (!check.allowed)
-          return { ok: false, locked: true, retryAfterSec: check.retryAfterSec ?? 0 };
+          return locked(check.retryAfterSec ?? 0);
+        feedback = `Wrong passphrase. ${check.remaining ?? 0} attempts left.`;
         continue;
       }
       throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "esRelease": {
     "order": 3
   },
@@ -44,7 +44,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@heretek-ai/es-core": "2.3.0",
+    "@heretek-ai/es-core": "2.5.0",
     "@opencode/plugin": "2.0.24"
   },
   "devDependencies": {

package/src/approve-tui.ts

@@ -51,7 +51,7 @@ export interface ApproveTuiInput {
 export type ApproveTuiOutcome =
   | { readonly ok: true; readonly record: Approval }
   | { readonly ok: false; readonly fallback: true; readonly reason: string }
-  | { readonly ok: false; readonly locked: true; readonly retryAfterSec: number }
+  | { readonly ok: false; readonly locked: true; readonly retryAfterSec: number; readonly retryAt: string }
   | { readonly ok: false; readonly cancelled: true }
 
 const TERMINAL_FALLBACK = (stage: ApprovalStage) =>
@@ -71,6 +71,13 @@ export const APPROVAL_PREVIEW_TTL_MS = 120_000
  */
 export async function approveInTui(input: ApproveTuiInput): Promise<ApproveTuiOutcome> {
   const dir = input.stateDir ?? defaultStateDir()
+  const clock = input.now ?? Date.now
+  const locked = (retryAfterSec: number): ApproveTuiOutcome => ({
+    ok: false,
+    locked: true,
+    retryAfterSec,
+    retryAt: new Date(clock() + retryAfterSec * 1000).toISOString(),
+  })
   // A TUI that cannot see the project root and the sealed key (a remote
   // attach) keeps the "approve in a terminal" alert instead of signing
   // anywhere else.
@@ -78,12 +85,22 @@ export async function approveInTui(input: ApproveTuiInput): Promise<ApproveTuiOu
     return { ok: false, fallback: true, reason: TERMINAL_FALLBACK(input.stage) }
 
   const gate = await checkApprovalAttempts(dir)
-  if (!gate.allowed) return { ok: false, locked: true, retryAfterSec: gate.retryAfterSec ?? 0 }
+  if (!gate.allowed) return locked(gate.retryAfterSec ?? 0)
 
-  const title = `Approve ${input.stage} as ${input.approvedBy ?? userInfo().username}`
+  const base = `Approve ${input.stage} as ${input.approvedBy ?? userInfo().username}`
+  // #353: the reopened dialog names the failure reason and the attempts
+  // left, so a wrong passphrase is visible instead of silent.
+  let feedback: string | undefined
   for (;;) {
+    const title = feedback ? `${base} — ${feedback}` : base
     const codepoints = await input.readPassphrase(title)
     if (codepoints === undefined) return { ok: false, cancelled: true }
+    // #353: an empty Enter cancels like the CLI ("empty cancels"), and
+    // records no failure.
+    if (codepoints.length === 0) {
+      zeroCodepoints(codepoints)
+      return { ok: false, cancelled: true }
+    }
     // The string cannot be zeroed in JS (same as the CLI's echo-off input):
     // it lives in this local only, and the array is zeroed at once.
     const passphrase = codepoints.join("")
@@ -115,7 +132,8 @@ export async function approveInTui(input: ApproveTuiInput): Promise<ApproveTuiOu
     } catch (error) {
       if (error instanceof HumanKeyError && error.message === "wrong passphrase") {
         const check = await noteWrongPassphrase({ dir, root: input.root, stage: input.stage, channel: "tui" })
-        if (!check.allowed) return { ok: false, locked: true, retryAfterSec: check.retryAfterSec ?? 0 }
+        if (!check.allowed) return locked(check.retryAfterSec ?? 0)
+        feedback = `Wrong passphrase. ${check.remaining ?? 0} attempts left.`
         continue
       }
       throw error

package/src/policy.ts

@@ -7,6 +7,7 @@ import path from "node:path"
 import {
   agentSpec,
   bwrapAvailable,
+  bwrapOverlay,
   checkStopFile,
   evaluateRead,
   evaluateShell,
@@ -39,6 +40,28 @@ export function patchTargets(patchText: string): string[] {
   return targets
 }
 
+/**
+ * The seat-shell sandbox mode for `cwd` (#326): "sandboxed" when bubblewrap
+ * can build the seat sandbox including the overlay mounts the shell backstop
+ * needs, "host-fallback" when bwrap is present but the overlay is unavailable
+ * for `cwd` (e.g. a btrfs mount without userxattr — the shell then runs
+ * without the read-only backstop, the #294 fallback), "unavailable" when
+ * there is no bwrap at all (seat shells are refused outright).
+ *
+ * Naming only: enforcement is unchanged. Whether the fallback stays or the
+ * shell fails closed on such hosts is the human's product decision on #326;
+ * this names the mode so the control matrix asserts the designed behaviour
+ * for the mode the host is in, with the mode in the assertion output.
+ */
+export function seatShellSandboxMode(cwd: string): "sandboxed" | "host-fallback" | "unavailable" {
+  if (!bwrapAvailable()) return "unavailable"
+  try {
+    return bwrapOverlay(cwd) ? "sandboxed" : "host-fallback"
+  } catch {
+    return "host-fallback"
+  }
+}
+
 const deny = (message: string): never => {
   throw new ToolError({ message })
 }

package/src/rpc.ts

@@ -70,6 +70,37 @@ export function createRpcHandlers(
       reason: error instanceof Error ? error.message : String(error),
     })
 
+  // #355: an unreadable run state (missing/forged seal) is a status value,
+  // not a throw — otherwise the 5 s footer poll logs `rpc handler failed`
+  // every poll. The problem is logged once per distinct problem.
+  let lastSealProblem: string | undefined
+  const isSealProblem = (error: unknown): string | undefined => {
+    const message = error instanceof Error ? error.message : String(error)
+    return /Cannot verify \.factory\/runtime\/state\.json|\.factory\/runtime\/state\.json has a|is a version .* run/i.test(
+      message,
+    )
+      ? message
+      : undefined
+  }
+  const noteSealProblem = (message: string) => {
+    if (lastSealProblem !== message) {
+      lastSealProblem = message
+      console.warn(`[epistemic-swarm] run state unreadable: ${message}`)
+    }
+  }
+  const clearSealProblem = () => {
+    if (lastSealProblem !== undefined) {
+      lastSealProblem = undefined
+      console.warn("[epistemic-swarm] run state readable again")
+    }
+  }
+  const sealFix = (message: string): string => {
+    if (message.includes("es reseal --sign")) return "es reseal --sign"
+    if (message.includes("ES_STATE_DIR")) return "ES_STATE_DIR"
+    if (message.includes("/grill")) return "/grill"
+    return "see status"
+  }
+
   /** Everything a trust approval covers: gate commands and project hooks. */
   const trustSubject = async () => {
     const { config } = await loadGatesConfig(runtime.root)
@@ -87,7 +118,24 @@ export function createRpcHandlers(
 
   return {
     status: async () => {
-      const state = await runtime.factory.read()
+      let state: Awaited<ReturnType<Runtime["factory"]["read"]>>
+      try {
+        state = await runtime.factory.read()
+      } catch (error) {
+        const problem = isSealProblem(error)
+        if (problem === undefined) throw error
+        noteSealProblem(problem)
+        const fix = sealFix(problem)
+        return {
+          summary: `<factory-state>State unreadable: ${problem}</factory-state>`,
+          stage: "ERROR",
+          pending: [],
+          headline: `State unreadable: ${problem}`,
+          footer: `ES · state unreadable · ${problem.slice(0, 100)} · fix: ${fix}`,
+          sealProblem: problem,
+        }
+      }
+      clearSealProblem()
       const liveness = await readLiveness(runtime.root, state)
       const paused = live.paused?.()
       const footer = footerLine(state, liveness, paused)
@@ -106,7 +154,26 @@ export function createRpcHandlers(
       warnings: [...runtime.warnings],
     }),
     factoryState: async () => {
-      const state = await runtime.factory.read()
+      let state: Awaited<ReturnType<Runtime["factory"]["read"]>>
+      try {
+        state = await runtime.factory.read()
+      } catch (error) {
+        const problem = isSealProblem(error)
+        if (problem === undefined) throw error
+        noteSealProblem(problem)
+        return {
+          headline: `State unreadable: ${problem}`,
+          seats: [],
+          events: [],
+          phases: [],
+          audits: [],
+          pending: [],
+          spend: { usd: 0, estimated: false },
+          stage: "ERROR",
+          sealProblem: problem,
+        }
+      }
+      clearSealProblem()
       const frontier = await readFrontier(runtime.root).catch(() => undefined)
       const liveness = await readLiveness(runtime.root, state)
       const research = researchLine(liveness)