@askexenow/exe-os 0.9.374 → 0.9.376

package/dist/{chunk-7TSBV3SD.js → chunk-PTY2N23C.js}

@@ -13,13 +13,133 @@ import {
 
 // src/bin/verify-stack.ts
 import { execSync } from "child_process";
+import { createHash } from "crypto";
 import { readFileSync, existsSync } from "fs";
 import http from "http";
 import path from "path";
+
+// src/lib/sso-session-contract.ts
+var APEX_SSO_COOKIES = ["exe_sess", "exe_sess_refresh", "exe_access_token"];
+var SSO_PRESENCE_SENTINEL = "exe_access_token";
+var SSO_PRESENCE_SENTINEL_VALUE = "1";
+var SSO_SESSION_COOKIE = "exe_sess";
+var MAX_SSO_HANDOFF_HOPS = 2;
+var SSO_SESSION_CONTRACT_CHECK_NAME = "SSO session auth admission contract";
+var FORGED_SESSION_VALUE = "eyJhbGciOiJIUzI1NiJ9.forged-payload-not-issued-by-gotrue.forged-signature";
+function gatingLayerOf(probes) {
+  return probes.anonymous.finalHost === probes.authHost ? "edge-gated" : "client-gated";
+}
+function refusedAtEdge(probe, authHost) {
+  return probe.finalHost === authHost;
+}
+function evaluateProduct(probes) {
+  const layer = gatingLayerOf(probes);
+  const findings = [];
+  const at = (p) => `landed on ${p.finalHost} (status ${p.status}, ${p.hops} hop(s))`;
+  if (layer === "client-gated") {
+    findings.push({
+      scenario: "anonymous",
+      severity: "review",
+      detail: `${probes.host} is not gated at the edge \u2014 an anonymous visitor is served by the product itself (${at(probes.anonymous)}), so its admission decision runs in the browser and is invisible over plain HTTP. This check will NOT roll a deploy back on that: check 9 (served-HTML cookie contract) and the Playwright monitor both see what this cannot. If this product was supposed to be behind the edge gate, that is the finding.`
+    });
+  } else {
+    findings.push({
+      scenario: "anonymous",
+      severity: "ok",
+      detail: `anonymous visitor refused at the edge -> ${probes.authHost}`
+    });
+    const forgeries = [
+      {
+        scenario: "forged-session",
+        probe: probes.forgedSession,
+        detail: `a FORGED \`${SSO_SESSION_COOKIE}\` was ADMITTED to ${probes.host} while an anonymous visitor with no cookies at all was correctly refused \u2014 ${at(probes.forgedSession)}. The edge is trusting the cookie's mere presence instead of validating it against GoTrue. This is bug 462d3273's exact shape: anyone can mint this cookie.`
+      },
+      {
+        scenario: "sentinel-only",
+        probe: probes.sentinelOnly,
+        detail: `a forged \`${SSO_PRESENCE_SENTINEL}=${SSO_PRESENCE_SENTINEL_VALUE}\` sentinel with NO real \`${SSO_SESSION_COOKIE}\` was ADMITTED to ${probes.host} while an anonymous visitor was correctly refused \u2014 ${at(probes.sentinelOnly)}. The sentinel is deliberately JS-readable and therefore trivially forgeable; its presence is not proof of anything. This is bug 4a6650f5's exact shape, and it is the case most likely to regress unnoticed because a sentinel-only jar looks like a normal logged-in one at a glance.`
+      }
+    ];
+    for (const forgery of forgeries) {
+      findings.push(
+        refusedAtEdge(forgery.probe, probes.authHost) ? { scenario: forgery.scenario, severity: "ok", detail: `${forgery.scenario} refused at the edge` } : { scenario: forgery.scenario, severity: "violation", detail: forgery.detail }
+      );
+    }
+  }
+  const real = probes.realSession;
+  if (real) {
+    if (real.hops > MAX_SSO_HANDOFF_HOPS) {
+      findings.push({
+        scenario: "real-session",
+        severity: "violation",
+        detail: `a real apex session took ${real.hops} redirect(s) reaching ${probes.host}, over the contract's ${MAX_SSO_HANDOFF_HOPS} \u2014 ${at(real)}. An unbounded hop count here is the CRM livelock (bug 83ba9546 regression): the edge and the app are disagreeing about the handoff and bouncing the user between them.`
+      });
+    } else if (real.finalHost !== probes.host) {
+      findings.push({
+        scenario: "real-session",
+        severity: "violation",
+        detail: `a REAL apex session was sent away from ${probes.host} \u2014 ${at(real)}. The app never accepted the shared session at all.`
+      });
+    } else if (real.sawPasswordField) {
+      findings.push({
+        scenario: "real-session",
+        severity: "violation",
+        detail: `${probes.host} served a login form to a REAL apex session \u2014 ${at(real)}. The shared session was not accepted (the 2026-08-30 ERP/Wiki failure mode).`
+      });
+    } else if (real.bodyFingerprint === probes.anonymous.bodyFingerprint) {
+      findings.push({
+        scenario: "real-session",
+        severity: "violation",
+        detail: `${probes.host} served a REAL apex session the byte-identical response it serves an anonymous visitor \u2014 ${at(real)}. The session is being ignored, not honored; for a client-gated product this is the only shape of the 2026-08-30 failure visible without a browser.`
+      });
+    } else {
+      findings.push({
+        scenario: "real-session",
+        severity: "ok",
+        detail: `real apex session admitted in ${real.hops} hop(s)`
+      });
+    }
+  }
+  return findings;
+}
+function summarizeProducts(products) {
+  const violations = [];
+  const reviews = [];
+  let oks = 0;
+  for (const product of products) {
+    for (const finding of evaluateProduct(product)) {
+      const label = `${product.app}/${finding.scenario}`;
+      if (finding.severity === "violation") violations.push(`${label}: ${finding.detail}`);
+      else if (finding.severity === "review") reviews.push(`${label}: ${finding.detail}`);
+      else oks += 1;
+    }
+  }
+  return { violations, reviews, oks };
+}
+function htmlHasPasswordField(html) {
+  return /<input[^>]*type\s*=\s*["']?password["']?/i.test(html);
+}
+function cookieHeader(jar) {
+  return Object.entries(jar).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function parseApexCookies(setCookieLines) {
+  const jar = {};
+  for (const line of setCookieLines) {
+    const pair = line.split(";")[0] ?? "";
+    const eq = pair.indexOf("=");
+    if (eq <= 0) continue;
+    const name = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (APEX_SSO_COOKIES.includes(name)) jar[name] = value;
+  }
+  return jar;
+}
+
+// src/bin/verify-stack.ts
 var DEFAULT_COMPOSE = "/opt/exe-stack/docker-compose.yml";
 var DEFAULT_ENV = "/opt/exe-stack/.env";
 var CHECK_TIMEOUT_MS = 5e3;
-var TOTAL_TIMEOUT_MS = 6e4;
+var TOTAL_TIMEOUT_MS = 12e4;
 var SERVICE_URLS = {
   "exe-os": "http://127.0.0.1:8765/health",
   "exe-gateway": "http://127.0.0.1:3100/health",
@@ -398,6 +518,189 @@ async function checkSsoCookieContract(deployed, urlOverrides) {
     message: `${Object.keys(urls).length} product(s) free of retired SSO cookie names`
   };
 }
+var MAX_PROBE_HOPS = 6;
+var SSO_ADMISSION_APPS = {
+  "exe-crm": "crm",
+  "exe-erp": "erp",
+  "exe-wiki": "wiki"
+};
+async function probeAdmission(url, jar, timeoutMs) {
+  let current = url;
+  let hops = 0;
+  const headers = {
+    // Some edges vary their gate on Accept; ask for a document like a browser does.
+    accept: "text/html,application/xhtml+xml",
+    "user-agent": "exe-os-verify-stack/sso-session-contract"
+  };
+  const cookie = cookieHeader(jar);
+  if (cookie) headers.cookie = cookie;
+  for (; ; ) {
+    const res = await fetch(current, {
+      headers,
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (location) {
+        hops += 1;
+        current = new URL(location, current).toString();
+        if (hops < MAX_PROBE_HOPS) continue;
+      }
+      return {
+        finalHost: new URL(current).host,
+        hops,
+        status: res.status,
+        sawPasswordField: false,
+        bodyFingerprint: `redirect:${res.status}:${location ?? ""}`
+      };
+    }
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
+    }
+    return {
+      finalHost: new URL(current).host,
+      hops,
+      status: res.status,
+      sawPasswordField: htmlHasPasswordField(body),
+      bodyFingerprint: createHash("sha256").update(body).digest("hex")
+    };
+  }
+}
+async function loginForApexCookies(authUrl, email, password, timeoutMs) {
+  let res;
+  try {
+    res = await fetch(`${authUrl}/auth/login`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ email, password }),
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    return { error: `login request failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (res.status >= 400) {
+    return {
+      error: `POST ${authUrl}/auth/login returned ${res.status} (account locked, disabled, or password rotated?)`
+    };
+  }
+  const setCookies = typeof res.headers.getSetCookie === "function" ? res.headers.getSetCookie() : [];
+  const jar = parseApexCookies(setCookies);
+  const missing = APEX_SSO_COOKIES.filter((name) => !(name in jar));
+  if (missing.length > 0) {
+    return { error: `login succeeded but did not set: ${missing.join(", ")}` };
+  }
+  if (jar[SSO_PRESENCE_SENTINEL] !== SSO_PRESENCE_SENTINEL_VALUE) {
+    return {
+      error: `\`${SSO_PRESENCE_SENTINEL}\` came back as "${jar[SSO_PRESENCE_SENTINEL]}" rather than the literal presence sentinel "${SSO_PRESENCE_SENTINEL_VALUE}" \u2014 if it now carries a real value, every consumer that refuses to trust it and every consumer that wrongly trusts it both changed behaviour silently`
+    };
+  }
+  return { jar };
+}
+async function checkSsoSessionContract(env, deployed, overrides) {
+  const check = SSO_SESSION_CONTRACT_CHECK_NAME;
+  const domain = process.env.SSO_DOMAIN ?? env.SSO_DOMAIN ?? env.DOMAIN;
+  if (!overrides?.targets && !domain) {
+    return {
+      check,
+      status: "skip",
+      message: "No DOMAIN in the stack env \u2014 this check probes the PUBLIC hostnames the edge gate actually serves, and cannot infer them. Set DOMAIN (or SSO_DOMAIN) to enable it."
+    };
+  }
+  const targets = overrides?.targets ?? Object.entries(SSO_ADMISSION_APPS).filter(([service]) => deployed.size === 0 ? true : deployed.has(service)).map(([service, subdomain]) => ({
+    service,
+    host: `${subdomain}.${domain}`,
+    baseUrl: `https://${subdomain}.${domain}/`
+  }));
+  if (targets.length === 0) {
+    return { check, status: "skip", message: "No SSO-gated products deployed in this selection" };
+  }
+  const authHost = overrides?.authHost ?? `auth.${domain}`;
+  const authUrl = overrides?.authUrl ?? `https://auth.${domain}`;
+  const jars = [
+    { scenario: "anonymous", jar: {} },
+    { scenario: "forged-session", jar: { [SSO_SESSION_COOKIE]: FORGED_SESSION_VALUE } },
+    { scenario: "sentinel-only", jar: { [SSO_PRESENCE_SENTINEL]: SSO_PRESENCE_SENTINEL_VALUE } }
+  ];
+  const email = process.env.SSO_E2E_EMAIL ?? env.SSO_E2E_EMAIL ?? env.GOTRUE_TEST_EMAIL;
+  const password = process.env.SSO_E2E_PASSWORD ?? env.SSO_E2E_PASSWORD ?? env.GOTRUE_TEST_PASSWORD;
+  let happyPathSkip = null;
+  if (email && password) {
+    const login = await loginForApexCookies(authUrl, email, password, CHECK_TIMEOUT_MS * 2);
+    if ("error" in login) {
+      happyPathSkip = `real-session scenario NOT run \u2014 ${login.error}`;
+    } else {
+      jars.push({ scenario: "real-session", jar: login.jar });
+    }
+  } else {
+    happyPathSkip = "real-session scenario NOT run \u2014 no SSO_E2E_EMAIL/SSO_E2E_PASSWORD (or GOTRUE_TEST_*) configured. The three deny-side scenarios need no credential, still ran, and still gate this deploy.";
+  }
+  const pairs = targets.flatMap((target) => jars.map(({ scenario, jar }) => ({ target, scenario, jar })));
+  const settled = await Promise.all(
+    pairs.map(async (pair) => {
+      try {
+        return { pair, probe: await probeAdmission(pair.target.baseUrl, pair.jar, CHECK_TIMEOUT_MS * 2) };
+      } catch (err) {
+        return { pair, error: err instanceof Error ? err.message : String(err) };
+      }
+    })
+  );
+  const byProduct = /* @__PURE__ */ new Map();
+  const unreachable = [];
+  for (const entry of settled) {
+    if ("probe" in entry && entry.probe) {
+      const bucket = byProduct.get(entry.pair.target.service) ?? {};
+      bucket[entry.pair.scenario] = entry.probe;
+      byProduct.set(entry.pair.target.service, bucket);
+    } else {
+      unreachable.push(
+        `${entry.pair.target.service} (${entry.pair.target.host}/${entry.pair.scenario}): ${"error" in entry ? entry.error : "no result"}`
+      );
+    }
+  }
+  const products = [];
+  for (const target of targets) {
+    const bucket = byProduct.get(target.service);
+    if (!bucket?.anonymous || !bucket["forged-session"] || !bucket["sentinel-only"]) {
+      unreachable.push(
+        `${target.service} (${target.host}): incomplete probe set \u2014 no baseline to judge against`
+      );
+      continue;
+    }
+    products.push({
+      app: target.service,
+      host: target.host,
+      authHost,
+      anonymous: bucket.anonymous,
+      forgedSession: bucket["forged-session"],
+      sentinelOnly: bucket["sentinel-only"],
+      realSession: bucket["real-session"]
+    });
+  }
+  const { violations, reviews, oks } = summarizeProducts(products);
+  if (violations.length > 0) {
+    return {
+      check,
+      status: "fail",
+      message: `${violations.length} SSO admission contract violation(s) on the DEPLOYED stack \u2014 ${violations.join(" | ")}`
+    };
+  }
+  const notes = [];
+  if (reviews.length > 0) notes.push(`needs review: ${reviews.join(" | ")}`);
+  if (unreachable.length > 0) notes.push(`unreachable: ${unreachable.join("; ")}`);
+  if (happyPathSkip) notes.push(happyPathSkip);
+  if (notes.length > 0) {
+    return { check, status: "warn", message: `${oks} admission decision(s) correct. ${notes.join(" | ")}` };
+  }
+  return {
+    check,
+    status: "pass",
+    message: `${oks} admission decision(s) correct across ${products.length} product(s): both forgery shapes refused wherever the edge refuses an anonymous visitor, and a real apex session honored within ${MAX_SSO_HANDOFF_HOPS} hop(s)`
+  };
+}
 async function checkLiveArtifactMatchesManifest(composeFile, manifestPath) {
   const check = LIVE_ARTIFACT_CHECK_NAME;
   const candidates = manifestPath ? [manifestPath] : ["/opt/exe-stack/stack-manifest.json", "deploy/stack-manifests/v0.9.json"];
@@ -535,6 +838,8 @@ async function runVerifyStack(options) {
   addResult(await checkSsoCookieContract(deployed));
   if (Date.now() > deadline) return summarize(results);
   addResult(await checkLiveArtifactMatchesManifest(composeFile));
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkSsoSessionContract(env, deployed));
   return summarize(results);
 }
 function summarize(results) {
@@ -562,7 +867,7 @@ function printUsage() {
   console.log(`
 Usage: exe-os verify-stack [options]
 
-Post-deploy verification \u2014 10 runtime checks after stack-update.
+Post-deploy verification \u2014 11 runtime checks after stack-update.
 
 Options:
   --compose <path>   Path to docker-compose.yml (default: ${DEFAULT_COMPOSE})
@@ -580,6 +885,8 @@ Checks:
   8. Cross-service auth (JWT \u2192 wiki + CRM)
   9. SSO auth cookie contract (no retired cookie name in served HTML)
  10. Live artifact matches the digest pinned by the signed manifest
+ 11. SSO session auth admission contract \u2014 presents real and forged cookie jars
+     to the live edge and asserts who gets admitted (fatal: rolls back)
 `);
 }
 if (isMainModule(import.meta.url) && process.argv[1]?.includes("verify-stack")) {
@@ -607,6 +914,7 @@ export {
   LIVE_ARTIFACT_CHECK_NAME,
   parseComposeServiceNames,
   checkSsoCookieContract,
+  checkSsoSessionContract,
   checkLiveArtifactMatchesManifest,
   runVerifyStack
 };

package/dist/{chunk-UKLN57Q5.js → chunk-PZ5SKYK6.js}

@@ -1,11 +1,11 @@
+import {
+  ingest
+} from "./chunk-5UBWBXLF.js";
 import {
   listWorkflowDefinitions,
   runWorkflow,
   startWorkflow
-} from "./chunk-YMP2QSOP.js";
-import {
-  ingest
-} from "./chunk-YSLGFPWX.js";
+} from "./chunk-QN56VQ6Z.js";
 import {
   initCRMBridge
 } from "./chunk-ML4S5SHZ.js";

package/dist/{chunk-636LKCKE.js → chunk-Q6ZLQMP2.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   loadConfig
 } from "./chunk-ZIG7VPJV.js";

package/dist/{chunk-N7VEP5B3.js → chunk-QFR5EKZG.js}

@@ -1,17 +1,18 @@
 import {
   updateTask
-} from "./chunk-ZCERWHY2.js";
+} from "./chunk-4M6RXJEY.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX,
   TASK_CLAIM_NOT_HELD_PREFIX,
+  TASK_PR_TRACEABILITY_REQUIRED_PREFIX,
   TASK_SIDECHAIN_WRITE_BLOCKED_PREFIX
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/mcp/tools/update-task.ts
 import { z } from "zod";
@@ -48,7 +49,9 @@ function registerUpdateTask(server) {
         commits: z.array(z.string()).optional().describe("Commit hashes produced"),
         tests_status: z.enum(["pass", "fail", "skip", "none"]).optional().describe("Test execution status"),
         build_status: z.enum(["pass", "fail", "skip"]).optional().describe("Build status"),
-        pr_number: z.number().optional().describe("PR number if created"),
+        pr_number: z.number().int().positive().optional().describe("PR number if created. Required (along with pr_url, or use pr_no_reason instead) when completing a task that reports commits/files_changed \u2014 all agents share one GitHub account, so this task record is the only reliable way to trace a merged PR back to the agent/task/session that produced it."),
+        pr_url: z.string().optional().describe("Full PR URL, e.g. https://github.com/org/repo/pull/123. More traceable than pr_number alone \u2014 derives pr_number automatically. Prefer this over pr_number."),
+        pr_no_reason: z.string().optional().describe('Explicit reason this completion has no PR (e.g. "direct to main", "non-code task"). Required instead of pr_number/pr_url when completing a task with commits/files_changed but no PR was opened.'),
         open_questions: z.array(z.string()).optional().describe("Open questions for reviewer"),
         assertions: z.string().optional().describe(
           'JSON array of assertions with confidence scores. Use when starting work (in_progress). Format: [{"type":"diagnosis|scope|estimate|approach|build|judgment","claim":"...","confidence":0.8,"basis":"..."}]'
@@ -66,13 +69,13 @@ function registerUpdateTask(server) {
         estimate_confidence: z.number().min(0).max(1).optional().describe("Confidence in time estimate (0.0-1.0). Provide alongside estimated_minutes.")
       }
     },
-    async ({ task_id, status: rawStatus, result, files_changed, decisions, commits, tests_status, build_status, pr_number, open_questions, assertions, assertions_resolved, receipts, estimated_minutes, estimate_confidence }) => {
+    async ({ task_id, status: rawStatus, result, files_changed, decisions, commits, tests_status, build_status, pr_number, pr_url, pr_no_reason, open_questions, assertions, assertions_resolved, receipts, estimated_minutes, estimate_confidence }) => {
       const status = rawStatus;
       let callerAgentId;
       let callerSession;
       let callerIsSidechain = false;
       try {
-        const { getActiveAgent: getAgent } = await import("./active-agent-ONPPEWQV.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-BOBBUJ74.js");
         const active = getAgent();
         callerAgentId = active.agentId;
         callerSession = resolveCallerSessionForUpdate();
@@ -103,6 +106,8 @@ function registerUpdateTask(server) {
           testsStatus: tests_status,
           buildStatus: build_status,
           prNumber: pr_number,
+          prUrl: pr_url,
+          prNoReason: pr_no_reason,
           openQuestions: open_questions,
           assertions,
           assertionsResolved: assertions_resolved,
@@ -141,12 +146,29 @@ function registerUpdateTask(server) {
             isError: true
           };
         }
+        if (msg.startsWith(TASK_PR_TRACEABILITY_REQUIRED_PREFIX)) {
+          return {
+            content: [{
+              type: "text",
+              text: `BLOCKED: this completion reports commits/files_changed but no PR traceability. All agents share one GitHub account, so git blame cannot tell which agent/task produced a merged PR \u2014 this task record has to. Retry update_task with pr_url (preferred) or pr_number if you opened a PR, or pr_no_reason (e.g. "direct to main", "non-code task") if there genuinely isn't one.
+
+Detail: ${msg}`
+            }],
+            isError: true
+          };
+        }
         throw err;
       }
       let text = `Task "${task.title}" marked ${task.status}.
 File: ${task.taskFile}`;
+      if (task.prUrl) text += `
+PR: ${task.prUrl}`;
+      else if (task.prNumber) text += `
+PR: #${task.prNumber}`;
+      else if (task.prNoReason) text += `
+PR: none (${task.prNoReason})`;
       const isTerminal = status === "done" || status === "needs_review" || status === "closed";
-      if (isTerminal && task.reviewer) {
+      if (isTerminal && task.executionMode === "durable_tmux" && task.reviewer) {
         try {
           const { notifyCoordinatorTaskCompletion } = await import("./lib/tmux-routing.js");
           const { isCoordinatorName: isCoordinatorName2 } = await import("./lib/employees.js");

package/dist/{chunk-YMP2QSOP.js → chunk-QN56VQ6Z.js}

@@ -1,7 +1,7 @@
 import {
   executeAction,
   substituteTemplate
-} from "./chunk-GM7TLYOK.js";
+} from "./chunk-K3VDF6II.js";
 
 // src/automation/workflow-engine.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-6YVUR3OU.js → chunk-QR3BUMOS.js}

@@ -3,12 +3,12 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   checkLicense,
   isFeatureAllowed,
   isPersonalFreeGrandfathered
-} from "./chunk-L6RXG36J.js";
+} from "./chunk-Y2HD2YB7.js";
 import {
   PLAN_LIMITS
 } from "./chunk-A7XLR3K7.js";

package/dist/{chunk-XZ65ST2I.js → chunk-QV5CQLQH.js}

@@ -6,10 +6,10 @@ import {
   connectEmbedDaemon,
   isClientConnected,
   sendDaemonRequest
-} from "./chunk-NUK7EEN5.js";
+} from "./chunk-ZKJ5S23O.js";
 import {
   directWriterAllowed
-} from "./chunk-V3W3SATA.js";
+} from "./chunk-CL4J4757.js";
 
 // src/lib/db-daemon-client.ts
 function normalizeStatement(stmt) {

package/dist/{chunk-DJOIMFKV.js → chunk-REZIGNA6.js}

@@ -1,10 +1,10 @@
 import {
   registerScopedQueryChokepoint,
   scopedQueryChokepointStatus
-} from "./chunk-IN6CAM4F.js";
+} from "./chunk-EHAN752X.js";
 import {
   getClient
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/lib/org-scoped-rows.ts
 var SCOPED_QUERY_MAX_LIMIT = 200;

package/dist/{chunk-UQGSBM3U.js → chunk-RFPMXR6B.js}

@@ -34,6 +34,8 @@ var NO_DB_INTEGRITY_EVENTS = Object.freeze({
   unresolvedUnverifiedBackups: 0,
   lastUnresolvedUnverified: null,
   failedBackups: 0,
+  lowDiskSkips: 0,
+  lastLowDiskSkip: null,
   lastVerifiedBackup: null,
   lastProvenBackupOnDisk: null,
   provenBackupsAllDeleted: false
@@ -99,6 +101,13 @@ function getDbIntegrityHealth() {
       break;
     }
   }
+  let lastLowDiskSkip = null;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].kind === "backup-skipped-low-disk") {
+      lastLowDiskSkip = events[i];
+      break;
+    }
+  }
   const unresolved = selectUnresolvedUnverified(events);
   const lastProvenBackupOnDisk = selectLastProvenOnDisk(events);
   return {
@@ -112,6 +121,8 @@ function getDbIntegrityHealth() {
     unresolvedUnverifiedBackups: unresolved.length,
     lastUnresolvedUnverified: unresolved.length > 0 ? unresolved[unresolved.length - 1] : null,
     failedBackups: countOf("backup-failed"),
+    lowDiskSkips: countOf("backup-skipped-low-disk"),
+    lastLowDiskSkip,
     lastVerifiedBackup,
     lastProvenBackupOnDisk,
     provenBackupsAllDeleted: lastVerifiedBackup !== null && lastProvenBackupOnDisk === null

package/dist/{chunk-DN4YVV4Z.js → chunk-RSABKW6B.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5MOYSU5A.js";
 import {
   redactSecrets
-} from "./chunk-4QCFFW2H.js";
+} from "./chunk-5QCIWWFA.js";
 
 // src/lib/memory-write-governor.ts
 import { createHash } from "crypto";

package/dist/{chunk-LP4GB656.js → chunk-RZNP35SI.js}

@@ -1,12 +1,12 @@
 import {
   sessionScopeFilter
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   leaseExpiryIso
 } from "./chunk-E23LNUWJ.js";
 import {
   getProjectName
-} from "./chunk-JTVIANUB.js";
+} from "./chunk-AEUGIJDO.js";
 
 // src/lib/subagent-observability.ts
 var MAX_RESULT_DIGEST_CHARS = 200;