@node9/proxy 2.34.0 → 2.35.0

package/dist/index.mjs

@@ -12934,6 +12934,9 @@ function appendLocalAudit(toolName, args, decision, checkedBy, meta, auditHashAr
     ...transcriptPathField,
     ...taintFields,
     ...exposureFields,
+    ...meta?.decidedBy && { decidedBy: meta.decidedBy },
+    ...meta?.channel && { channel: meta.channel },
+    ...meta?.cardId && { cardId: meta.cardId },
     ...testRun,
     agent: meta?.agent,
     mcpServer: meta?.mcpServer,
@@ -15310,9 +15313,159 @@ function getPersistentDecision(toolName) {
 
 // src/auth/daemon.ts
 import fs10 from "fs";
+import http from "http";
 import net from "net";
 import path10 from "path";
 import os8 from "os";
+
+// src/auth/decision-record.ts
+var CHANNELS = ["terminal", "monitor", "native", "cloud"];
+var PERSON_CHANNELS = /* @__PURE__ */ new Set([
+  "terminal",
+  "monitor",
+  "native"
+]);
+var CARD_PROTOCOL = 2;
+var PERSON_LABELS = {
+  terminal: "User Decision (Terminal (node9 tail))",
+  monitor: "User Decision (node9 monitor)",
+  native: "User Decision (Native)"
+};
+var REDIRECT_LABEL = "Steered Redirect (Terminal)";
+var TIMER_LABEL = "Approval Timeout";
+var CLOUD_LABEL = "Organization Policy (SaaS)";
+var ABANDONED_LABEL = "No Approver (node9 tail closed)";
+function personRecord(channel, decision, extra = {}, now = Date.now()) {
+  return {
+    decision,
+    decidedBy: "person",
+    channel,
+    label: extra.redirect ? REDIRECT_LABEL : PERSON_LABELS[channel],
+    ...extra,
+    decidedAt: now
+  };
+}
+function timerRecord(timeoutMs, now = Date.now()) {
+  return {
+    decision: "deny",
+    decidedBy: "timer",
+    label: TIMER_LABEL,
+    reason: `No response within ${Math.round(timeoutMs / 1e3)}s: auto-denied by the approval timeout.`,
+    decidedAt: now
+  };
+}
+function abandonedRecord(now = Date.now()) {
+  return {
+    decision: "deny",
+    decidedBy: "abandoned",
+    label: ABANDONED_LABEL,
+    reason: "No approver was left to answer: node9 tail was closed.",
+    decidedAt: now
+  };
+}
+var DECIDED_BY = /* @__PURE__ */ new Set([
+  "person",
+  "timer",
+  "cloud",
+  "policy",
+  "abandoned"
+]);
+var STANDING = /* @__PURE__ */ new Set([
+  "always-allow",
+  "always-deny",
+  "trust",
+  "trust-recipients"
+]);
+function boundedString(v, max) {
+  return typeof v === "string" && v.length > 0 ? v.slice(0, max) : void 0;
+}
+function parseDecisionRecord(x) {
+  if (!x || typeof x !== "object") return null;
+  const r = x;
+  if (r.decision !== "allow" && r.decision !== "deny") return null;
+  if (typeof r.decidedBy !== "string" || !DECIDED_BY.has(r.decidedBy)) return null;
+  const label2 = boundedString(r.label, 200);
+  if (!label2) return null;
+  const channel = typeof r.channel === "string" && CHANNELS.includes(r.channel) ? r.channel : void 0;
+  if (r.decidedBy === "person" && (!channel || !PERSON_CHANNELS.has(channel))) return null;
+  const out = {
+    decision: r.decision,
+    decidedBy: r.decidedBy,
+    label: label2,
+    decidedAt: typeof r.decidedAt === "number" && Number.isFinite(r.decidedAt) ? r.decidedAt : 0
+  };
+  if (channel) out.channel = channel;
+  const redirect = boundedString(r.redirect, 2e3);
+  if (redirect) out.redirect = redirect;
+  const reason = boundedString(r.reason, 2e3);
+  if (reason) out.reason = reason;
+  const ruleName = boundedString(r.ruleName, 256);
+  if (ruleName) out.ruleName = ruleName;
+  if (typeof r.standing === "string" && STANDING.has(r.standing))
+    out.standing = r.standing;
+  const trustDuration = boundedString(r.trustDuration, 8);
+  if (trustDuration) out.trustDuration = trustDuration;
+  return out;
+}
+function legacyWaitFields(record) {
+  switch (record.decidedBy) {
+    case "person": {
+      const source = record.redirect ? "terminal-redirect" : record.channel === "native" ? "native" : "terminal";
+      const reason = record.redirect ?? record.reason;
+      return { decision: record.decision, source, ...reason && { reason } };
+    }
+    case "timer":
+      return {
+        decision: record.decision,
+        source: "timeout",
+        ...record.reason && { reason: record.reason }
+      };
+    case "cloud":
+    case "policy":
+      return {
+        decision: record.decision,
+        source: record.decidedBy,
+        ...record.reason && { reason: record.reason }
+      };
+    case "abandoned":
+      return { decision: "abandoned" };
+  }
+}
+function recordFromLegacyWait(body, now = Date.now()) {
+  if (body.decision === "abandoned") return abandonedRecord(now);
+  const decision = body.decision;
+  switch (body.source) {
+    case "terminal":
+    case "browser":
+      return personRecord("terminal", decision, body.reason ? { reason: body.reason } : {}, now);
+    case "native":
+      return personRecord("native", decision, {}, now);
+    case "terminal-redirect":
+      return personRecord("terminal", decision, body.reason ? { redirect: body.reason } : {}, now);
+    case "timeout":
+      return { ...timerRecord(0, now), ...body.reason && { reason: body.reason } };
+    case "cloud":
+      return {
+        decision,
+        decidedBy: "cloud",
+        label: CLOUD_LABEL,
+        ...body.reason && { reason: body.reason },
+        decidedAt: now
+      };
+    case "policy":
+      return {
+        decision,
+        decidedBy: "policy",
+        label: "Policy",
+        ...body.reason && { reason: body.reason },
+        decidedAt: now
+      };
+    default:
+      return null;
+  }
+}
+
+// src/auth/daemon.ts
 var ACTIVITY_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path10.join(os8.tmpdir(), "node9-activity.sock");
 function notifyActivitySocket(data) {
   return new Promise((resolve) => {
@@ -15410,7 +15563,7 @@ async function daemonHasInteractiveApprover(timeoutMs = 400) {
     return false;
   }
 }
-async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityId, cwd, recoveryCommand, skipBackgroundAuth, viewOnly, localSmartRuleMatched, socketActivitySent, sessionId) {
+async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityId, cwd, recoveryCommand, skipBackgroundAuth, viewOnly, localSmartRuleMatched, socketActivitySent, sessionId, card) {
   const base2 = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), 5e3);
@@ -15436,19 +15589,43 @@ async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityI
         ...skipBackgroundAuth && { skipBackgroundAuth: true },
         ...viewOnly && { viewOnly: true },
         ...localSmartRuleMatched && { localSmartRuleMatched: true },
-        ...sessionId && { sessionId }
+        ...sessionId && { sessionId },
+        ...cardFields(card)
       }),
       signal: ctrl.signal
     });
     if (!res.ok) throw new Error("Daemon fail");
-    const { id, allowCount } = await res.json();
-    return { id, allowCount: allowCount ?? 1 };
+    return registeredCard(await res.json());
   } finally {
     clearTimeout(timer);
   }
 }
+function cardFields(card) {
+  return {
+    // A review card: the hook already decided this call needs a person; the
+    // daemon never checks it again (approval-card design, defect 1).
+    kind: "review",
+    // Protocol 2 makes the card's /wait require the internal token: claim it
+    // only when this process can read the token (a daemon under another uid
+    // is running but its pid file probe fails with EPERM), or every wait
+    // would get 403 and the review would be denied unseen.
+    ...getInternalToken() && { protocol: CARD_PROTOCOL },
+    ...card?.channels && { channels: card.channels },
+    ...typeof card?.timeoutMs === "number" && { timeoutMs: card.timeoutMs }
+  };
+}
+function registeredCard(body) {
+  const b = body;
+  return {
+    id: b.id,
+    allowCount: b.allowCount ?? 1,
+    ...b.protocol === CARD_PROTOCOL && {
+      protocol: CARD_PROTOCOL,
+      deadline: typeof b.deadline === "number" ? b.deadline : null
+    }
+  };
+}
 async function waitForDaemonDecision(id, signal, maxWaitMs = 12e4) {
-  const base2 = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
   const waitCtrl = new AbortController();
   let capped = false;
   const waitTimer = maxWaitMs > 0 ? setTimeout(() => {
@@ -15458,14 +15635,18 @@ async function waitForDaemonDecision(id, signal, maxWaitMs = 12e4) {
   const onAbort = () => waitCtrl.abort();
   if (signal) signal.addEventListener("abort", onAbort);
   try {
-    const waitRes = await fetch(`${base2}/wait/${id}`, { signal: waitCtrl.signal }).catch(
+    const { status, body } = await daemonGet(`/wait/${id}`, waitCtrl.signal).catch(
       (err) => {
         if (capped && !signal?.aborted) throw new Error("node9 daemon did not answer in time");
         throw err;
       }
     );
-    if (!waitRes.ok) return { decision: "deny" };
-    const { decision, source, reason } = await waitRes.json();
+    if (status === 409) throw new Error("node9 card was withdrawn");
+    if (status !== 200) return { decision: "deny" };
+    const parsed = JSON.parse(body);
+    const record = parseDecisionRecord(parsed.record);
+    if (record) return { ...legacyWaitFields(record), record };
+    const { decision, source, reason } = parsed;
     if (decision === "allow") return { decision: "allow", source };
     if (decision === "abandoned") return { decision: "abandoned", source };
     return { decision: "deny", source, reason };
@@ -15474,7 +15655,29 @@ async function waitForDaemonDecision(id, signal, maxWaitMs = 12e4) {
     if (signal) signal.removeEventListener("abort", onAbort);
   }
 }
-async function notifyDaemonViewer(toolName, args, meta, riskMetadata, activityId, socketActivitySent) {
+function daemonGet(urlPath, signal, token = getInternalToken()) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(
+      {
+        host: DAEMON_HOST,
+        port: DAEMON_PORT,
+        path: urlPath,
+        signal,
+        agent: false,
+        headers: token ? { "X-Node9-Internal": token } : {}
+      },
+      (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => body += chunk);
+        res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
+        res.on("error", reject);
+      }
+    );
+    req.on("error", reject);
+  });
+}
+async function notifyDaemonViewer(toolName, args, meta, riskMetadata, activityId, socketActivitySent, extra) {
   const base2 = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
   const res = await fetch(`${base2}/check`, {
     method: "POST",
@@ -15490,13 +15693,16 @@ async function notifyDaemonViewer(toolName, args, meta, riskMetadata, activityId
       // event via socket. Same contract as registerDaemonEntry — without
       // it the daemon double-emits 'activity' for cloud-enforced flows.
       fromCLI: socketActivitySent !== false,
-      activityId
+      activityId,
+      ...extra?.cwd && { cwd: extra.cwd },
+      ...extra?.recoveryCommand && { recoveryCommand: extra.recoveryCommand },
+      ...extra?.sessionId && { sessionId: extra.sessionId },
+      ...cardFields(extra?.card)
     }),
     signal: AbortSignal.timeout(3e3)
   });
   if (!res.ok) throw new Error("Daemon unreachable");
-  const { id, allowCount } = await res.json();
-  return { id, allowCount: allowCount ?? 1 };
+  return registeredCard(await res.json());
 }
 async function notifyTaint(filePath, source, fromEid) {
   if (!isDaemonRunning()) return;
@@ -15589,14 +15795,18 @@ async function approveSessionExposure(sessionId, keys) {
   } catch {
   }
 }
-async function resolveViaDaemon(id, decision, internalToken, source) {
+async function resolveViaDaemon(id, decision, internalToken, source, record) {
   const base2 = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
-  await fetch(`${base2}/resolve/${id}`, {
+  const res = await fetch(`${base2}/resolve/${id}`, {
     method: "POST",
     headers: { "Content-Type": "application/json", "X-Node9-Internal": internalToken },
-    body: JSON.stringify({ decision, ...source && { source } }),
+    body: JSON.stringify({ decision, ...source && { source }, ...record && { record } }),
     signal: AbortSignal.timeout(3e3)
   });
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => null);
+  const winner = parseDecisionRecord(body?.record);
+  return winner && typeof body?.won === "boolean" ? { won: body.won, record: winner } : null;
 }
 
 // src/auth/orchestrator.ts
@@ -17190,17 +17400,98 @@ function asApprovalRequest(description) {
   return description;
 }
 
-// src/auth/decision-sources.ts
-var HUMAN_DECISION_SOURCES = /* @__PURE__ */ new Set([
-  "terminal",
-  "browser",
-  "native"
-]);
-var REDIRECT_SOURCE = "terminal-redirect";
-var DECISION_ROUTE_SOURCES = /* @__PURE__ */ new Set([
-  ...HUMAN_DECISION_SOURCES,
-  REDIRECT_SOURCE
-]);
+// src/auth/card-result.ts
+var CHANNEL_NAMES = {
+  terminal: "Terminal (node9 tail)",
+  monitor: "node9 monitor",
+  native: "system dialog window",
+  cloud: "organization"
+};
+function authResultFromRecord(r, ctx = {}) {
+  const who = { decidedBy: r.decidedBy, ...r.channel && { channel: r.channel } };
+  switch (r.decidedBy) {
+    case "person": {
+      const channel = r.channel ?? "terminal";
+      const decisionSource = channel === "native" ? "native" : "terminal";
+      if (r.decision === "allow") {
+        return { approved: true, checkedBy: "daemon", decisionSource, ...who };
+      }
+      return {
+        approved: false,
+        reason: r.redirect || `The human user rejected this action via the Node9 ${CHANNEL_NAMES[channel]}.`,
+        blockedBy: "local-decision",
+        blockedByLabel: r.label,
+        decisionSource,
+        ...who,
+        ...r.redirect && { redirect: r.redirect }
+      };
+    }
+    case "timer":
+      if (r.decision === "deny" && ctx.downgradedBlock)
+        return { ...ctx.downgradedBlock, blockedBy: "timeout", ...who };
+      return r.decision === "allow" ? { approved: true, ...who } : {
+        approved: false,
+        reason: ctx.timeoutReason || r.reason || "No response: auto-denied after the approval timeout.",
+        blockedBy: "timeout",
+        blockedByLabel: TIMER_LABEL,
+        ...who
+      };
+    case "cloud":
+      return r.decision === "allow" ? { approved: true, checkedBy: "cloud", decisionSource: "cloud", ...who } : {
+        approved: false,
+        reason: r.reason || "Action rejected by organization administrator via Slack.",
+        blockedBy: "team-policy",
+        blockedByLabel: CLOUD_LABEL,
+        decisionSource: "cloud",
+        ...who
+      };
+    case "policy":
+      return r.decision === "allow" ? { approved: true, checkedBy: "local-policy", ...who } : {
+        approved: false,
+        reason: r.reason || "Action blocked by policy.",
+        blockedBy: "local-config",
+        blockedByLabel: r.label,
+        ...r.ruleName && { ruleHit: r.ruleName },
+        ...who
+      };
+    case "abandoned":
+      return {
+        approved: false,
+        reason: r.reason || "No approver was left to answer.",
+        blockedBy: "no-approval-mechanism",
+        blockedByLabel: ABANDONED_LABEL,
+        ...who
+      };
+  }
+}
+function approvalUnavailable(reason) {
+  return {
+    approved: false,
+    reason: reason || "node9 could not get an approval decision for this call.",
+    blockedBy: "no-approval-mechanism",
+    blockedByLabel: "Approval Unavailable"
+  };
+}
+function decidedByOf(res) {
+  if (res.decidedBy) return res.decidedBy;
+  if (res.blockedBy === "timeout") return "timer";
+  if (res.checkedBy === "cloud" || res.blockedBy === "team-policy") return "cloud";
+  return "policy";
+}
+function recordFromAuthResult(res, now = Date.now()) {
+  const decidedBy = decidedByOf(res);
+  const channel = res.channel ?? (decidedBy === "cloud" ? "cloud" : decidedBy === "person" ? "native" : void 0);
+  return {
+    decision: res.approved ? "allow" : "deny",
+    decidedBy,
+    ...channel && { channel },
+    label: res.blockedByLabel || (decidedBy === "cloud" ? CLOUD_LABEL : decidedBy === "timer" ? TIMER_LABEL : res.approved ? "Allowed" : "Blocked"),
+    ...res.reason && { reason: res.reason.slice(0, 2e3) },
+    ...res.ruleHit && { ruleName: res.ruleHit },
+    ...res.redirect && { redirect: res.redirect },
+    decidedAt: now
+  };
+}
 
 // src/auth/orchestrator.ts
 var SENSITIVE_PATH_PATTERN = sensitivePathMatch("").patternName;
@@ -18240,28 +18531,22 @@ ${packageReview}`;
   const { signal } = abortController;
   const racePromises = [];
   const approvalTimeoutMs = config.settings.approvalTimeoutMs ?? 0;
-  if (approvalTimeoutMs > 0) {
-    racePromises.push(
-      new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          resolve({
-            approved: false,
-            reason: approvalTimeoutReason(approvalTimeoutMs),
-            blockedBy: "timeout",
-            blockedByLabel: "Approval Timeout"
-          });
-        }, approvalTimeoutMs);
-        signal.addEventListener("abort", () => {
-          clearTimeout(timer);
-          reject(new Error("Aborted"));
-        });
-      })
-    );
-  }
   let viewerId = null;
   const internalToken = getInternalToken();
   let daemonEntryId = null;
   let daemonAllowCount = 1;
+  let cardDeadline;
+  const cardOptions = {
+    channels: [
+      "terminal",
+      "monitor",
+      // Only when the popup can show: a card listing a channel nobody can
+      // use is never abandoned when node9 tail closes, and waits unanswered.
+      ...approvers.native && !isManual && !options?.calledFromDaemon && (process.platform === "darwin" || process.platform === "win32" || !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY)) ? ["native"] : [],
+      ...cloudEnforced && cloudRequestId && cloudMayVote ? ["cloud"] : []
+    ],
+    timeoutMs: approvalTimeoutMs
+  };
   if (approvers.terminal && isDaemonRunning() && !options?.calledFromDaemon) {
     if (cloudEnforced && cloudRequestId) {
       const viewer = await notifyDaemonViewer(
@@ -18270,11 +18555,20 @@ ${packageReview}`;
         meta,
         riskMetadata,
         options?.activityId,
-        options?.socketActivitySent
+        options?.socketActivitySent,
+        {
+          cwd: options?.cwd,
+          recoveryCommand: statefulRecoveryCommand,
+          sessionId: meta?.sessionId,
+          card: cardOptions
+        }
       ).catch(() => null);
       viewerId = viewer?.id ?? null;
       daemonEntryId = viewerId;
-      if (viewer) daemonAllowCount = viewer.allowCount;
+      if (viewer) {
+        daemonAllowCount = viewer.allowCount;
+        cardDeadline = viewer.deadline;
+      }
     } else {
       try {
         const entry = await registerDaemonEntry(
@@ -18298,14 +18592,35 @@ ${packageReview}`;
           void 0,
           localSmartRuleMatched || options?.localSmartRuleMatched,
           options?.socketActivitySent,
-          meta?.sessionId
+          meta?.sessionId,
+          cardOptions
         );
         daemonEntryId = entry.id;
         daemonAllowCount = entry.allowCount;
+        cardDeadline = entry.deadline;
       } catch {
       }
     }
   }
+  if (approvalTimeoutMs > 0 && cardDeadline === void 0) {
+    racePromises.push(
+      new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          resolve({
+            approved: false,
+            reason: approvalTimeoutReason(approvalTimeoutMs),
+            blockedBy: "timeout",
+            blockedByLabel: "Approval Timeout",
+            decidedBy: "timer"
+          });
+        }, approvalTimeoutMs);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          reject(new Error("Aborted"));
+        });
+      })
+    );
+  }
   if (cloudEnforced && cloudRequestId && cloudMayVote) {
     racePromises.push(
       (async () => {
@@ -18316,7 +18631,9 @@ ${packageReview}`;
             reason: cloudResult.approved ? void 0 : cloudResult.reason || "Action rejected by organization administrator via Slack.",
             checkedBy: cloudResult.approved ? "cloud" : void 0,
             blockedBy: cloudResult.approved ? void 0 : "team-policy",
-            blockedByLabel: "Organization Policy (SaaS)"
+            blockedByLabel: "Organization Policy (SaaS)",
+            decidedBy: "cloud",
+            channel: "cloud"
           };
         } catch (err) {
           const error = err;
@@ -18346,14 +18663,31 @@ ${packageReview}`;
           if (config.policySource !== "workspace") {
             for (const d of exposureDestinations) addTrustedRecipient(d, "approval");
           }
-          return { approved: true, checkedBy: "daemon", decisionSource: "native" };
+          return {
+            approved: true,
+            checkedBy: "daemon",
+            decisionSource: "native",
+            decidedBy: "person",
+            channel: "native"
+          };
         }
         if (decision === "always_allow") {
           if (standingTrustApplies()) {
             writeTrustSession(toolName, 36e5, args);
-            return { approved: true, checkedBy: "trust" };
+            return {
+              approved: true,
+              checkedBy: "trust",
+              decidedBy: "person",
+              channel: "native"
+            };
           }
-          return { approved: true, checkedBy: "daemon", decisionSource: "native" };
+          return {
+            approved: true,
+            checkedBy: "daemon",
+            decisionSource: "native",
+            decidedBy: "person",
+            channel: "native"
+          };
         }
         const isApproved = decision === "allow";
         return {
@@ -18362,75 +18696,32 @@ ${packageReview}`;
           checkedBy: isApproved ? "daemon" : void 0,
           blockedBy: isApproved ? void 0 : "local-decision",
           blockedByLabel: "User Decision (Native)",
-          decisionSource: "native"
+          decisionSource: "native",
+          decidedBy: "person",
+          channel: "native"
         };
       })()
     );
   }
+  const fromCard = /* @__PURE__ */ new WeakSet();
+  const timeoutReason = approvalTimeoutMs > 0 ? approvalTimeoutReason(approvalTimeoutMs) : void 0;
   if (daemonEntryId && approvers.terminal) {
     racePromises.push(
       (async () => {
-        const {
-          decision: daemonDecision,
-          source: decisionSource,
-          reason: daemonReason
-        } = await waitForDaemonDecision(
-          daemonEntryId,
-          signal,
-          daemonWaitCapMs(config.settings.approvalTimeoutMs)
-        );
-        if (daemonDecision === "abandoned") throw new Error("Abandoned");
-        const isApproved = daemonDecision === "allow";
-        const isRedirect = decisionSource === REDIRECT_SOURCE;
-        if (!isApproved && !isRedirect && !(decisionSource && HUMAN_DECISION_SOURCES.has(decisionSource))) {
-          if (decisionSource === "cloud")
-            return {
-              approved: false,
-              reason: daemonReason || "Action rejected by organization administrator via Slack.",
-              blockedBy: "team-policy",
-              blockedByLabel: "Organization Policy (SaaS)",
-              decisionSource: "cloud"
-            };
-          const timedOut = decisionSource === "timeout";
-          if (downgradedBlock)
-            return {
-              ...downgradedBlock,
-              blockedBy: timedOut ? "timeout" : "local-config"
-            };
-          if (timedOut)
-            return {
-              approved: false,
-              reason: daemonReason || "No response: auto-denied after the approval timeout.",
-              blockedBy: "timeout",
-              blockedByLabel: "Approval Timeout"
-            };
-          if (decisionSource === "policy")
-            return {
-              approved: false,
-              reason: daemonReason || "Action blocked by policy.",
-              blockedBy: "local-config",
-              blockedByLabel: explainableLabel
-            };
-          return {
-            approved: false,
-            reason: daemonReason || "node9 could not get an approval decision for this call.",
-            blockedBy: "no-approval-mechanism",
-            blockedByLabel: "Approval Unavailable"
-          };
+        const cap = cardDeadline === void 0 ? daemonWaitCapMs(config.settings.approvalTimeoutMs) : cardDeadline === null ? 0 : Math.max(cardDeadline - Date.now(), 0) + 5e3;
+        const outcome = await waitForDaemonDecision(daemonEntryId, signal, cap);
+        const legacy = !outcome.record;
+        const record = outcome.record ?? recordFromLegacyWait(outcome);
+        if (downgradedBlock && (!record || legacy && record.decidedBy === "policy" && record.decision === "deny")) {
+          const softened = { ...downgradedBlock, blockedBy: "local-config" };
+          fromCard.add(softened);
+          return softened;
         }
-        if (isApproved && decisionSource === "cloud")
-          return { approved: true, checkedBy: "cloud", decisionSource: "cloud" };
-        if (isApproved && decisionSource === "policy")
-          return { approved: true, checkedBy: "local-policy" };
-        const via = "Terminal (node9 tail)";
-        return {
-          approved: isApproved,
-          reason: isApproved ? void 0 : isRedirect && daemonReason || `The human user rejected this action via the Node9 ${via}.`,
-          checkedBy: isApproved ? "daemon" : void 0,
-          blockedBy: isApproved ? void 0 : "local-decision",
-          blockedByLabel: isRedirect ? "Steered Redirect (Terminal)" : `User Decision (${via})`,
-          decisionSource: "terminal"
-        };
+        if (!record) return approvalUnavailable(outcome.reason);
+        if (legacy && record.decidedBy === "policy") record.label = explainableLabel;
+        const result = authResultFromRecord(record, { downgradedBlock, timeoutReason });
+        fromCard.add(result);
+        return result;
       })()
     );
   }
@@ -18462,7 +18753,7 @@ REASON: Action blocked because no approval channels are available. (Native/Brows
       blockedByLabel: explainableLabel
     };
   }
-  const finalResult = await new Promise((resolve) => {
+  const raceResult = await new Promise((resolve) => {
     let resolved = false;
     let failures = 0;
     const total = racePromises.length;
@@ -18470,14 +18761,6 @@ REASON: Action blocked because no approval channels are available. (Native/Brows
       if (!resolved) {
         resolved = true;
         abortController.abort();
-        if (daemonEntryId && internalToken) {
-          resolveViaDaemon(
-            daemonEntryId,
-            res.approved ? "allow" : "deny",
-            internalToken,
-            res.decisionSource
-          ).catch(() => null);
-        }
         resolve(res);
       }
     };
@@ -18485,26 +18768,29 @@ REASON: Action blocked because no approval channels are available. (Native/Brows
       p.then(finish).catch((err) => {
         if (err.name === "AbortError" || err.message?.includes("canceled") || err.message?.includes("Aborted"))
           return;
-        if (err.message === "Abandoned") {
-          finish({
-            approved: false,
-            reason: "Browser dashboard closed without making a decision.",
-            blockedBy: "local-decision",
-            blockedByLabel: "Browser Dashboard (Abandoned)"
-          });
-          return;
-        }
         failures++;
         if (failures === total && !resolved) {
-          finish({ approved: false, reason: "All approval channels failed or disconnected." });
+          finish(approvalUnavailable("All approval channels failed or disconnected."));
         }
       });
     }
   });
+  let finalResult = raceResult;
+  if (daemonEntryId && internalToken && !fromCard.has(raceResult)) {
+    const reply = await resolveViaDaemon(
+      daemonEntryId,
+      raceResult.approved ? "allow" : "deny",
+      internalToken,
+      raceResult.decisionSource,
+      recordFromAuthResult(raceResult)
+    ).catch(() => null);
+    if (reply && !reply.won)
+      finalResult = authResultFromRecord(reply.record, { downgradedBlock, timeoutReason });
+  }
   if (finalResult.approved && exposureKeys.length > 0 && meta?.sessionId && ucPolicy?.afterExposure === "ask-once") {
     await approveSessionExposure(meta.sessionId, exposureKeys);
   }
-  if (cloudRequestId && creds && finalResult.checkedBy !== "cloud") {
+  if (cloudRequestId && creds && finalResult.checkedBy !== "cloud" && finalResult.decidedBy !== "cloud") {
     await resolveNode9SaaS(
       cloudRequestId,
       creds,
@@ -18528,7 +18814,12 @@ REASON: Action blocked because no approval channels are available. (Native/Brows
       {
         ...ownRowMeta(finalResult.approved),
         ...cloudRequestId && { cloudRequestId },
-        ...appPermReview && { ruleName: `app-permission:${appPermReviewTool}` }
+        ...appPermReview && { ruleName: `app-permission:${appPermReviewTool}` },
+        // Who decided, from the decision record, and the card: the daemon
+        // writes its own row for the same card, and the report counts one.
+        ...finalResult.decidedBy && { decidedBy: finalResult.decidedBy },
+        ...finalResult.channel && { channel: finalResult.channel },
+        ...daemonEntryId && { cardId: daemonEntryId }
       },
       hashAuditArgs
     );