@akasecurity/cli 0.9.12 → 0.9.13

package/dist/cli.js

@@ -20885,7 +20885,17 @@ var UNPRICEABLE_PROVIDERS = Object.freeze([
   "gateway",
   "unknown",
   "cli",
-  "api"
+  "api",
+  // The browser extension's native host records these as `llm_call.provider`
+  // for a web-chat turn — the web tool id, deliberately never the vendor id
+  // (`openai`/`anthropic`) the session root carries. Subscription traffic
+  // burns rate-limit budget, not dollar credits, and listing them here is
+  // what keeps that true structurally: a later maintainer who wants to price
+  // web-chat traffic at API rates has to delete this entry first, and meet
+  // the reason on the way, rather than quietly adding one to
+  // PROVIDER_PLATFORM.
+  "chatgpt",
+  "claude-ai"
 ]);
 function platformForProvider(provider) {
   return PROVIDER_PLATFORM.get(provider.trim().toLowerCase()) ?? null;
@@ -21094,7 +21104,12 @@ var HARNESS = {
   ClaudeDesktop: "claudedesktop",
   ChatGpt: "chatgpt",
   ClaudeAi: "claudeai",
-  Api: "api"
+  Api: "api",
+  // Not a coding assistant a person drives — an in-process SDK embedded in an
+  // application, so it has no IDE/CLI/desktop/web surface of its own. Carries
+  // the same id as its SOURCE_TOOL counterpart, unlike every capture-side tool
+  // whose wire spelling differs from its display spelling.
+  AiTcSdk: "ai-tc-sdk"
 };
 var Harness = external_exports.enum(HARNESS).meta({ id: "Harness" });
 var SOURCE_TOOL = {
@@ -21110,9 +21125,15 @@ var SOURCE_TOOL = {
   // whose tool could not be identified both render through the read side's
   // miss path rather than as a harness of their own.
   Cli: "cli",
-  Unknown: "unknown"
+  Unknown: "unknown",
+  // The wire id an in-process, request-path SDK stamps on its own structural
+  // rows (`request_decision`) — never a capture of prompt/response/tool text,
+  // since the SDK sits in front of a model call rather than inside a coding
+  // assistant's own hook contract.
+  AiTcSdk: "ai-tc-sdk"
 };
 var SourceTool = external_exports.enum(SOURCE_TOOL).meta({ id: "SourceTool" });
+var WebSourceTool = SourceTool.extract(["ChatGpt", "ClaudeAi"]);
 var TOOL_TO_HARNESS = {
   [SOURCE_TOOL.ClaudeCode]: HARNESS.ClaudeCode,
   [SOURCE_TOOL.ClaudeDesktop]: HARNESS.ClaudeDesktop,
@@ -21121,7 +21142,12 @@ var TOOL_TO_HARNESS = {
   [SOURCE_TOOL.ChatGpt]: HARNESS.ChatGpt,
   [SOURCE_TOOL.Codex]: HARNESS.Codex,
   [SOURCE_TOOL.Antigravity]: HARNESS.Antigravity,
-  [SOURCE_TOOL.ClaudeAi]: HARNESS.ClaudeAi
+  [SOURCE_TOOL.ClaudeAi]: HARNESS.ClaudeAi,
+  // Wire and display id are the same string here, but the row still belongs:
+  // both vocabularies carry the `AiTcSdk` member, and the join is exactly
+  // their intersection — leaving a shared member out would read as an
+  // uninstrumented tool on both surfaces, which this one is not.
+  [SOURCE_TOOL.AiTcSdk]: HARNESS.AiTcSdk
 };
 
 // ../packages/schema/src/zod/finding.ts
@@ -21155,7 +21181,8 @@ var FindingProvider = Harness.extract([
   "ClaudeAi",
   "Codex",
   "Antigravity",
-  "Api"
+  "Api",
+  "AiTcSdk"
 ]).meta({ id: "FindingProvider" });
 var FindingCategory = external_exports.enum([
   "secret",
@@ -21532,18 +21559,41 @@ var AuditEventType = external_exports.enum([
   // 'tool_call' is the reconciler's structural row for every call, while
   // 'tool_use' exists only where a hook enforced against the arguments.
   "tool_use",
-  // One row per model REFUSAL: a switch onto a prohibited model that was
-  // denied, or a turn refused because the session was already running on one.
-  // A structural row like the ones above rather than a capture — it carries
-  // the model that was refused and nothing the user typed, because what is
-  // worth recording about a governance decision is the decision, and prompt
-  // text is the thing this product exists to keep from travelling.
+  // One row per model REFUSAL, across all four seams a prohibited model can be
+  // stopped at: a switch onto it, a turn already running on it, a subagent
+  // spawn asking for it, or a request-path refusal an embedded request-path
+  // SDK makes in-process before the call leaves the application. Which seam
+  // rides `attributes.refusal_seam`, never this member name. A structural row
+  // like the ones above rather than a capture — it carries the model that was
+  // refused and nothing the user typed, because what is worth recording about
+  // a governance decision is the decision, and prompt text is the thing this
+  // product exists to keep from travelling.
   "model_refusal",
+  // One row per request-path DECISION: a policy check an embedded request-path
+  // SDK performs in-process before a model call leaves the application, or
+  // against that call's non-streamed response. A structural row like
+  // 'model_refusal' rather than a capture — content-free in the same way:
+  // which side, which seam, what action and which field are decided rides
+  // `attributes`, never this member name, and the matched text itself never
+  // travels.
+  //
+  // A prohibited-model refusal on the request path is deliberately NOT this
+  // member: it stays 'model_refusal' with `refusal_seam: 'request'`, so it
+  // shares one bucket with the plugin's switch/turn/spawn refusals rather
+  // than splitting one governance concept across two event types. This
+  // member carries every OTHER request-path decision.
+  "request_decision",
   // One row per config-inventory scan, hung off the session root. It is the
   // fact the posture inspection findings reference (findings require an
   // audit_event_id), and its started_at is the "scanned Nm ago" the read
   // surface renders.
-  "config_scan"
+  "config_scan",
+  // One row per reported browser-extension capture status, hung off the web
+  // session root. The durable home of what one tab's network interception
+  // is doing — a write-through of the native host's in-memory tracker, so a
+  // second process (aka extension status) and a restarted host both have
+  // somewhere to read it back from.
+  "capture_status"
 ]).meta({ id: "AuditEventType" });
 var AttributeBag = external_exports.record(external_exports.string(), external_exports.unknown());
 var HostAttributes = external_exports.object({
@@ -21703,6 +21753,20 @@ var CaptureAttributes = external_exports.object({
   // repeated rather than referenced because a store reader opens this file.
   redact_degraded_to: ActionTaken.optional()
 }).catchall(external_exports.unknown());
+var CaptureStatusAttributes = external_exports.object({
+  source_tool: external_exports.string().optional(),
+  patched: external_exports.boolean().optional(),
+  live: external_exports.boolean().optional(),
+  blind: external_exports.boolean().optional(),
+  sends_seen_dom: external_exports.number().int().nonnegative().optional(),
+  exchanges_seen_net: external_exports.number().int().nonnegative().optional(),
+  parse_failures: external_exports.number().int().nonnegative().optional(),
+  unparsed_bodies: external_exports.number().int().nonnegative().optional(),
+  shape_misses: external_exports.array(external_exports.string()).optional(),
+  conversation_endpoints: external_exports.number().int().nonnegative().optional(),
+  closed: external_exports.boolean().optional(),
+  enforcement: external_exports.string().optional()
+}).catchall(external_exports.unknown());
 var ToolCallInspection = external_exports.object({
   ruleId: external_exports.string().min(1),
   ruleName: external_exports.string(),
@@ -22562,6 +22626,30 @@ var AttachedCredential = external_exports.object({
   keyPrefix: external_exports.string().min(1).max(16).optional(),
   mintedAt: external_exports.iso.datetime().optional()
 });
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function unsafeEndpointReason(endpoint) {
+  let parsed2;
+  try {
+    parsed2 = new URL(endpoint);
+  } catch {
+    return "unparseable";
+  }
+  if (parsed2.username !== "" || parsed2.password !== "") return "userinfo";
+  if (parsed2.search !== "" || parsed2.hash !== "") return "query-or-fragment";
+  if (parsed2.protocol === "https:") return null;
+  return parsed2.protocol === "http:" && LOOPBACK_HOSTS.has(parsed2.hostname) ? null : "insecure";
+}
+function isSafeEndpoint(endpoint) {
+  return unsafeEndpointReason(endpoint) === null;
+}
+function originOnly(endpoint) {
+  try {
+    const parsed2 = new URL(endpoint);
+    return `${parsed2.protocol}//${parsed2.host}`;
+  } catch {
+    return "(unparseable endpoint)";
+  }
+}
 var MAX_DATE_MS = 253402300799999;
 var MAX_INT4 = 2147483647;
 var StorePosturePack = external_exports.object({
@@ -22716,6 +22804,11 @@ var RemoteFailureKind = external_exports.enum([
   "rejected",
   "unreachable"
 ]);
+var ControlPlaneFailure = RemoteFailureKind.extract([
+  "unauthorized",
+  "forbidden",
+  "unreachable"
+]);
 var AttachDeviceRequest = external_exports.object({
   // This machine's own continuity id, so re-attaching ROTATES the credential
   // on one machine record instead of producing a second one. Client-minted
@@ -23255,7 +23348,12 @@ var EventMetadata = external_exports.object({
   // in — set by the browser extension's network capture so a stored `response`
   // row can be joined to the `llm_call` leaf describing the same turn. Absent
   // on every other capture path, which has no such id.
-  messageId: external_exports.string().optional(),
+  //
+  // Non-empty for the reason WebExchange.messageId is: it is the join key, and
+  // a blank one matches no `llm_call` leaf. That refusal reaches only the
+  // places an event is PARSED; the local write path types the event and parses
+  // nothing, which is why `toCaptureAttributes` omits a blank one separately.
+  messageId: external_exports.string().min(1).optional(),
   conversationId: external_exports.string().optional(),
   // How long THIS capture's inspection blocked its caller, in whole
   // milliseconds — the plugin's own added latency, NOT the LLM call it sat in
@@ -24358,6 +24456,22 @@ function isHistorySyncConsentStale(consent, endpoint) {
   if (consent === void 0 || endpoint === void 0) return false;
   return consent.endpoint === endpoint && consent.payloadVersion !== HISTORY_SYNC_PAYLOAD_VERSION;
 }
+var WEB_CHAT_CAPTURE_CONSENT_VERSION = 1;
+var WebChatCaptureConsent = external_exports.object({
+  acknowledgedAt: external_exports.iso.datetime(),
+  version: external_exports.number().int().positive()
+});
+var WebChatResponseCapture = external_exports.enum(["with-findings", "always", "never"]);
+var WebChatCapture = external_exports.object({
+  responses: WebChatResponseCapture.default("with-findings"),
+  account: external_exports.boolean().default(false),
+  // Absent until granted. Presence alone does not authorize anything — see
+  // isWebChatCaptureConsentValid.
+  consent: WebChatCaptureConsent.optional()
+});
+function isWebChatCaptureConsentValid(consent) {
+  return consent?.version === WEB_CHAT_CAPTURE_CONSENT_VERSION;
+}
 var BODY_RETENTION_DEFAULT_DAYS = 30;
 var BodyRetention = external_exports.object({
   enabled: external_exports.boolean().default(false),
@@ -24416,6 +24530,16 @@ var WorkspaceSettings = external_exports.object({
   // both widenings. Absent until granted, and a grant for a different endpoint
   // or an older payload no longer counts.
   historySyncConsent: HistorySyncConsent.optional(),
+  // What the browser extension may record from a web chat, and the grant that
+  // authorizes it. Absent until the user answers: recording something that was
+  // never recorded before is never an assumed grant on upgrade, so the whole
+  // block is optional rather than defaulted in. What an absent block means is
+  // webChatCaptureOf's answer, in one place.
+  //
+  // Enforcement is NOT gated on this. A machine that has never answered still
+  // blocks, redacts and warns on what a user sends; the grant covers what is
+  // written down.
+  webChatCapture: WebChatCapture.optional(),
   // Local body expiry (see BodyRetention). Off until switched on; expiring a
   // body never removes the row or its findings.
   bodyRetention: BodyRetention.default({
@@ -24426,6 +24550,9 @@ var WorkspaceSettings = external_exports.object({
 function defaultWorkspaceSettings() {
   return WorkspaceSettings.parse({});
 }
+function webChatCaptureOf(settings) {
+  return settings.webChatCapture ?? WebChatCapture.parse({});
+}
 function isAttached(settings) {
   return settings.runMode === "attached" && settings.controlPlane !== void 0;
 }
@@ -24529,7 +24656,10 @@ function toCaptureAttributes(event) {
     // `.catchall(z.unknown())` carries the long tail.
     ...metadata?.model !== void 0 ? { model: metadata.model } : {},
     ...metadata?.turnIndex !== void 0 ? { turn_index: metadata.turnIndex } : {},
-    ...metadata?.messageId !== void 0 ? { message_id: metadata.messageId } : {},
+    // A blank id is omitted rather than stored: it is a join key and `''` joins
+    // nothing. This runs on the local write path, which types the event but
+    // never parses it, so EventMetadata's own `.min(1)` does not reach here.
+    ...metadata?.messageId !== void 0 && metadata.messageId !== "" ? { message_id: metadata.messageId } : {},
     ...metadata?.conversationId !== void 0 ? { conversation_id: metadata.conversationId } : {}
   };
 }
@@ -24913,12 +25043,14 @@ var RecommendedActionIdParam = external_exports.object({ id: external_exports.st
 // ../packages/schema/src/zod/settings-action.ts
 var HistorySyncConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "HistorySyncConsentChoice" });
 var ModelJudgeConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "ModelJudgeConsentChoice" });
+var WebChatCaptureConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "WebChatCaptureConsentChoice" });
 var SaveSettingsInput = external_exports.object({
   historicalAccess: external_exports.string(),
   modelJudgeConsent: ModelJudgeConsentChoice,
   historySyncConsent: HistorySyncConsentChoice,
   vaultConsent: external_exports.string(),
   vaultInlineReveal: external_exports.string(),
+  webChatCaptureConsent: WebChatCaptureConsentChoice,
   // Widened to `string` like its neighbours rather than typed as
   // `RedactFallback`, on this module's own layering rule: shape here, VALUE at
   // the call site, so the domain check receives the type it was written for.
@@ -25133,11 +25265,24 @@ var WebExchange = external_exports.object({
   turnIndex: external_exports.number().int().nonnegative().optional(),
   toolCalls: external_exports.array(WebToolCall).default([]),
   // Absent when the adapter recovered no text. Capped by the caller at
-  // RESPONSE_TEXT_MAX_BYTES; `truncated` records that the cap was reached, so a
-  // short capture is never mistaken for a short reply.
+  // RESPONSE_TEXT_MAX_BYTES, so a short capture is never mistaken for a short
+  // reply.
   responseText: external_exports.string().optional(),
+  // The stored text is short of the reply. It does NOT say which of the two
+  // ceilings on this path cut it: the caller applies its own cap on the raw
+  // bytes it reads off the wire, which can be reached by a stream whose
+  // recovered text stays well under RESPONSE_TEXT_MAX_BYTES, and applies that
+  // one to the text. A reader cannot tell them apart, and nothing downstream
+  // should branch as though it could.
   truncated: external_exports.boolean().default(false)
 });
+var WebEnforcementState = external_exports.enum([
+  "watching",
+  "composer-only",
+  "button-only",
+  "unattached",
+  "unknown"
+]);
 var RESPONSE_TEXT_MAX_BYTES = 2 * 1024 * 1024;
 var WebCaptureStatus = external_exports.object({
   patched: external_exports.boolean(),
@@ -25149,8 +25294,66 @@ var WebCaptureStatus = external_exports.object({
   unparsedBodies: external_exports.number().int().nonnegative(),
   // The adapter-declared JSON key paths that were absent from a real payload —
   // the earliest signal that a site's contract moved.
-  shapeMisses: external_exports.array(external_exports.string()).default([])
-});
+  shapeMisses: external_exports.array(external_exports.string()).default([]),
+  // How many `kind: 'conversation'` endpoints the reporting tab's adapter
+  // compiled. Zero means this build declares none for the site, so observing
+  // nothing is the design rather than a fault — the one fact that separates a
+  // site nobody has surveyed yet from one whose contract moved. Defaulted so a
+  // build predating the field is read as declaring nothing rather than refused.
+  conversationEndpoints: external_exports.number().int().nonnegative().default(0),
+  // The document that sent this report is going away. The bridge sets it on
+  // its `pagehide` report and nowhere else.
+  //
+  // A property of the REPORT rather than of capture health, which is why
+  // nothing in `deriveWebCaptureState` reads it and why it stays out of the
+  // bridge's own report signature — a closing tab's last word must not be
+  // suppressed for carrying the same health as the report before it. What
+  // reads it is the per-site fold: a document that said it was unloading stops
+  // voting on the site's state, so the reload the `blind` remediation asks for
+  // can actually clear the verdict it was shown. A document that dies without
+  // sending one is covered by CAPTURE_STATUS_DOCUMENT_QUIET_MS instead.
+  //
+  // Defaulted so a build predating the field reads as a document that never
+  // said it was closing — which keeps it voting, the same as every report that
+  // is not a final one.
+  closed: external_exports.boolean().default(false),
+  // What the DOM enforcement path is doing, which none of the counters above
+  // can say: `sendsSeenDom` rises only once a send has COMPLETED, so a tab
+  // whose watcher never bound reports zero exactly like a tab nobody typed in.
+  // Defaulted to 'unknown' rather than 'watching' so a status from a build
+  // predating the field is not read as reporting a healthy one.
+  enforcement: WebEnforcementState.default("unknown")
+});
+function webCaptureStatusObservedTurnPath(status) {
+  if (!status.patched) return true;
+  if (status.conversationEndpoints === 0) return true;
+  return status.blind || status.shapeMisses.length > 0 || status.parseFailures > 0 || status.unparsedBodies > 0 || status.exchangesSeenNet > 0;
+}
+function pickReportedCaptureStatus(candidates) {
+  return candidates.find((c) => webCaptureStatusObservedTurnPath(c.status)) ?? candidates[0];
+}
+var CAPTURE_STATUS_RECENCY_MS = 30 * 24 * 60 * 60 * 1e3;
+var CAPTURE_STATUS_RECENCY_DAYS = CAPTURE_STATUS_RECENCY_MS / (24 * 60 * 60 * 1e3);
+var CAPTURE_STATUS_DOCUMENT_QUIET_MS = 12 * 60 * 60 * 1e3;
+function fromCaptureStatusAttributes(bag) {
+  const parsedBag = CaptureStatusAttributes.safeParse(bag);
+  if (!parsedBag.success) return null;
+  const b = parsedBag.data;
+  const parsedStatus = WebCaptureStatus.safeParse({
+    patched: b.patched,
+    live: b.live,
+    blind: b.blind,
+    sendsSeenDom: b.sends_seen_dom,
+    exchangesSeenNet: b.exchanges_seen_net,
+    parseFailures: b.parse_failures,
+    unparsedBodies: b.unparsed_bodies,
+    shapeMisses: b.shape_misses,
+    conversationEndpoints: b.conversation_endpoints,
+    closed: b.closed,
+    enforcement: b.enforcement
+  });
+  return parsedStatus.success ? parsedStatus.data : null;
+}
 
 // ../packages/local-ops/src/registry.ts
 var AGENT_PLUGINS = [
@@ -27715,6 +27918,114 @@ var CONFIG_POSTURE_RULES = [
   }
 ];
 
+// ../packages/detections/src/posture/web-capture-posture.ts
+var RULE_VERSION2 = "1";
+var DRIFT_MIN_PARSE_FAILURES = 2;
+var WEB_CAPTURE_DRIFT_STATES = /* @__PURE__ */ new Set([
+  "blind",
+  "degraded"
+]);
+var WEB_CAPTURE_DRIFT_RULE = {
+  ruleId: "web-capture-drift",
+  version: RULE_VERSION2,
+  name: "Web chat capture is not reading the site",
+  category: "config",
+  severity: "medium",
+  definition: JSON.stringify({
+    kind: "web-capture-drift",
+    states: [...WEB_CAPTURE_DRIFT_STATES],
+    minParseFailures: DRIFT_MIN_PARSE_FAILURES
+  })
+};
+function deriveWebCaptureState(status) {
+  if (status === void 0) return "unreported";
+  if (status.conversationEndpoints === 0) return "standby";
+  if (!status.patched) return "unpatched";
+  if (status.blind) return "blind";
+  if (status.shapeMisses.length > 0) return "degraded";
+  if (status.parseFailures >= DRIFT_MIN_PARSE_FAILURES) return "degraded";
+  return status.live ? "active" : "idle";
+}
+var STATE_SEVERITY = {
+  blind: 0,
+  degraded: 1,
+  unpatched: 2,
+  idle: 3,
+  standby: 4,
+  active: 5,
+  unreported: 6
+};
+function worseThan(a, b) {
+  const sa = STATE_SEVERITY[deriveWebCaptureState(a.status)];
+  const sb = STATE_SEVERITY[deriveWebCaptureState(b.status)];
+  if (sa !== sb) return sa < sb;
+  if (a.observedAt !== b.observedAt) return a.observedAt > b.observedAt;
+  return (a.rootSessionId ?? "") > (b.rootSessionId ?? "");
+}
+function reportedCaptureDocumentForSite(documents) {
+  let newestReport = "";
+  for (const d of documents) if (d.lastReportAt > newestReport) newestReport = d.lastReportAt;
+  const retired = (d) => {
+    if (d.closed) return true;
+    const behind = Date.parse(newestReport) - Date.parse(d.lastReportAt);
+    return Number.isFinite(behind) && behind > CAPTURE_STATUS_DOCUMENT_QUIET_MS;
+  };
+  const voting = documents.filter((d) => !retired(d));
+  const tested = voting.some((d) => webCaptureStatusObservedTurnPath(d.status));
+  const pool = tested ? voting : documents;
+  let worst;
+  for (const d of pool) if (worst === void 0 || worseThan(d, worst)) worst = d;
+  return worst;
+}
+var STATIC_COPY = {
+  active: { headline: "turns are being observed on this site" },
+  unreported: {
+    // Says "recently" rather than "yet": the store read is bounded to
+    // CAPTURE_STATUS_RECENCY_MS, so this state covers a site nothing has ever
+    // reported for AND one whose last report has aged out. The two are the
+    // same fact to a reader — nobody has confirmed anything lately — and the
+    // copy may not claim the stronger of them.
+    headline: `no report in the last ${String(CAPTURE_STATUS_RECENCY_DAYS)} days \u2014 open the site in Chrome with the extension loaded`
+  },
+  standby: {
+    headline: "this build declares no endpoints for the site, so nothing is observed yet"
+  },
+  unpatched: {
+    // Says what the flags say and no more. `patched` is false both for a tap
+    // that installed and hooked neither transport and for one that never ran
+    // at all — a page reports the same status either way, so the copy may not
+    // assert one of them.
+    headline: "the page tap captured neither fetch nor XHR \u2014 it may not have installed; reload the extension at chrome://extensions"
+  },
+  idle: { headline: "watching; no turn has been observed yet" },
+  blind: {
+    headline: "messages were sent in the page that the network capture never saw",
+    remediation: "reload the tab. If it persists after `aka update` and reloading the extension at chrome://extensions, the site's send path has changed and needs a new extension build."
+  },
+  degraded: {
+    headline: "the site's payloads no longer carry the fields the extension reads",
+    remediation: "run `aka update`, then reload the extension at chrome://extensions. If it stays degraded after an update, the site's contract has changed and needs a new extension build."
+  }
+};
+function webCaptureStateCopy(state) {
+  return STATIC_COPY[state];
+}
+function webCaptureReport(documents) {
+  return WebSourceTool.options.map((tool) => {
+    const record2 = reportedCaptureDocumentForSite(documents.filter((d) => d.tool === tool));
+    const state = deriveWebCaptureState(record2?.status);
+    const copy = webCaptureStateCopy(state);
+    return {
+      tool,
+      state,
+      headline: copy.headline,
+      ...copy.remediation !== void 0 ? { remediation: copy.remediation } : {},
+      drift: WEB_CAPTURE_DRIFT_STATES.has(state),
+      ...record2 !== void 0 ? { observedAt: record2.observedAt } : {}
+    };
+  });
+}
+
 // ../packages/detections/src/security/redos-probe.ts
 var BUDGET_MS = 100;
 var EXPONENTIAL_UNITS = [
@@ -27900,17 +28211,6 @@ function publishByLink(tmp, file2, data) {
 function controlPlaneCredentialPath(settingsDir2) {
   return join5(settingsDir2, ATTACHED_CREDENTIAL_FILENAME);
 }
-var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
-function isSafeEndpoint(endpoint) {
-  let parsed2;
-  try {
-    parsed2 = new URL(endpoint);
-  } catch {
-    return false;
-  }
-  if (parsed2.protocol === "https:") return true;
-  return parsed2.protocol === "http:" && LOOPBACK_HOSTS.has(parsed2.hostname);
-}
 function repairOrRefuseMode(file2) {
   const link = lstatSync2(file2, { throwIfNoEntry: false });
   if (link === void 0) return "absent";
@@ -27969,10 +28269,23 @@ function readControlPlaneCredential(settingsDir2, connection) {
   const read = readControlPlaneCredentialFile(settingsDir2, connection);
   return read.usable ? read.credential : null;
 }
+function unsafeEndpointRefusal(reason) {
+  switch (reason) {
+    case "unparseable":
+      return "that does not look like a web address.";
+    case "userinfo":
+      return "the address carries a username or password, which must not be stored alongside the credential.";
+    case "query-or-fragment":
+      return "the address must be an origin, optionally with a path, not a query string or fragment.";
+    case "insecure":
+      return "an access key must not be stored for a non-HTTPS endpoint (http is accepted only for a loopback deployment).";
+  }
+}
 function writeControlPlaneCredential(settingsDir2, credential) {
-  if (!isSafeEndpoint(credential.endpoint)) {
+  const reason = unsafeEndpointReason(credential.endpoint);
+  if (reason !== null) {
     throw new Error(
-      `refusing to store a control-plane credential for a non-HTTPS endpoint: ${credential.endpoint}`
+      `refusing to store a control-plane credential for ${originOnly(credential.endpoint)}: ` + unsafeEndpointRefusal(reason)
     );
   }
   ensureDataDirSync(settingsDir2);
@@ -29716,7 +30029,7 @@ var SESSION_ROOT = `event_type = 'session'`;
 var HAS_ACTIVITY = `EXISTS (
   SELECT 1 FROM audit_events c
   WHERE c.root_session_id = audit_events.id
-    AND c.event_type NOT IN ('hook', 'config_scan'))`;
+    AND c.event_type NOT IN ('hook', 'config_scan', 'capture_status'))`;
 var SqliteActivityRepository = class {
   constructor(db, now = () => Date.now()) {
     this.db = db;
@@ -29743,10 +30056,10 @@ var SqliteActivityRepository = class {
                SELECT id FROM audit_events WHERE event_type = 'session' AND started_at >= ?
                UNION
                SELECT root_session_id FROM audit_events INDEXED BY idx_audit_started_at
-                WHERE started_at >= ?
+                WHERE started_at >= ? AND event_type <> 'capture_status'
                UNION
                SELECT root_session_id FROM audit_events INDEXED BY idx_audit_ended_at
-                WHERE ended_at >= ?)`,
+                WHERE ended_at >= ? AND event_type <> 'capture_status')`,
       [liveThreshold, liveThreshold, liveThreshold]
     );
     const toolCallsToday = countScalar(
@@ -30153,7 +30466,10 @@ var SqliteAuditEventsRepository = class {
          attributes = excluded.attributes,
          ended_at   = excluded.ended_at
        WHERE COALESCE(json_extract(excluded.attributes, '$.output_tokens'), 0)
-           > COALESCE(json_extract(audit_events.attributes, '$.output_tokens'), 0)`
+           > COALESCE(json_extract(audit_events.attributes, '$.output_tokens'), 0)
+          OR (json_extract(excluded.attributes, '$.usage_source') IS NOT NULL
+              AND json_extract(excluded.attributes, '$.output_tokens') IS NULL
+              AND excluded.attributes <> audit_events.attributes)`
     );
     this.upsertSessionRootStmt = db.prepare(
       `INSERT OR IGNORE INTO audit_events
@@ -30421,6 +30737,87 @@ var SqliteBodyRetentionRepository = class {
   }
 };
 
+// ../packages/persistence/src/repositories/capture-status.ts
+var STATUS_LOOKBACK_ROWS = 128;
+var SqliteCaptureStatusRepository = class {
+  constructor(db) {
+    this.db = db;
+    this.recentStmt = db.prepare(
+      `SELECT a.started_at AS startedAt,
+              a.attributes AS attributes,
+              a.root_session_id AS rootSessionId
+         FROM audit_events a
+        WHERE a.event_type = 'capture_status'
+          AND a.source_tool = ?
+          AND a.started_at >= ?
+        ORDER BY a.started_at DESC, a.id DESC
+        LIMIT ?`
+    );
+  }
+  db;
+  recentStmt;
+  /**
+   * Every document that reported for a site, in registry order by site, from
+   * the last `CAPTURE_STATUS_RECENCY_MS`.
+   *
+   * SEVERAL per site, not one: a browser is many documents and each reports
+   * for itself, so one row per site is a choice about which of them a user
+   * sees — and the newest is the wrong one, since a healthy tab writing a
+   * fresh report would hide a drifting tab's verdict, which is the whole
+   * reason these rows exist. The pick WITHIN a document is made here (the
+   * unchanged `pickReportedCaptureStatus`, over that document's own rows);
+   * choosing between documents belongs where the state semantics live, and
+   * that is `reportedCaptureDocumentForSite` in `@akasecurity/detections` —
+   * this package may not import it.
+   *
+   * `now` is a required argument rather than a `Date.now()` read, so a caller
+   * that already holds a render instant passes THAT one and a test can drive
+   * the window without moving the wall clock.
+   *
+   * A site whose reports have all aged out contributes nothing, so it derives
+   * to `unreported`. That is the point: nothing but the browser extension ever
+   * writes these rows, so an uninstalled extension's last verdict would
+   * otherwise stand as a live claim for ever with no later report able to
+   * clear it.
+   */
+  latest(now) {
+    const since = now - CAPTURE_STATUS_RECENCY_MS;
+    const documents = [];
+    for (const tool of WebSourceTool.options) {
+      const rows = /* @__PURE__ */ new Map();
+      const lastWord = /* @__PURE__ */ new Map();
+      for (const row of allRows(this.recentStmt, [
+        tool,
+        since,
+        STATUS_LOOKBACK_ROWS
+      ])) {
+        const status = fromCaptureStatusAttributes(parseJsonObject(row.attributes));
+        if (status === null) continue;
+        const record2 = { tool, observedAt: epochMillisToIso(row.startedAt), status };
+        const group = rows.get(row.rootSessionId);
+        if (group === void 0) {
+          rows.set(row.rootSessionId, [record2]);
+          lastWord.set(row.rootSessionId, { at: record2.observedAt, closed: status.closed });
+        } else {
+          group.push(record2);
+        }
+      }
+      for (const [root, candidates] of rows) {
+        const picked = pickReportedCaptureStatus(candidates);
+        const last = lastWord.get(root);
+        if (picked === void 0 || last === void 0) continue;
+        documents.push({
+          ...picked,
+          ...root === null ? {} : { rootSessionId: root },
+          lastReportAt: last.at,
+          closed: last.closed
+        });
+      }
+    }
+    return documents;
+  }
+};
+
 // ../packages/persistence/src/repositories/classified-data.ts
 var SqliteClassifiedDataRepository = class {
   constructor(db) {
@@ -36300,6 +36697,7 @@ function openAndInitialize(file2, base, skipTags) {
       activity: new SqliteActivityRepository(db),
       sourceProject: new SqliteSourceProjectRepository(db),
       auditEvents: new SqliteAuditEventsRepository(db),
+      captureStatus: new SqliteCaptureStatusRepository(db),
       classifiedData: new SqliteClassifiedDataRepository(db),
       inspectionDefinitions: new SqliteInspectionDefinitionsRepository(db),
       inspectionFindings: new SqliteInspectionFindingsRepository(db),
@@ -36340,6 +36738,7 @@ function openLocalDatabase(dir, options = {}) {
     activity,
     sourceProject,
     auditEvents,
+    captureStatus,
     classifiedData,
     inspectionDefinitions,
     inspectionFindings,
@@ -36557,6 +36956,7 @@ function openLocalDatabase(dir, options = {}) {
     activity,
     sourceProject,
     auditEvents,
+    captureStatus,
     classifiedData,
     inspectionDefinitions,
     inspectionFindings,
@@ -36801,11 +37201,6 @@ function keyStateOf(key) {
 // ../packages/persistence/src/forward-health.ts
 import { readFileSync as readFileSync11 } from "fs";
 import { join as join12 } from "path";
-var FAILURES = /* @__PURE__ */ new Set([
-  "unauthorized",
-  "forbidden",
-  "unreachable"
-]);
 var BREAKER_COOLDOWN_MS = 3e4;
 function parseForwardHealth(raw, nowMs) {
   try {
@@ -36814,7 +37209,8 @@ function parseForwardHealth(raw, nowMs) {
     const record2 = parsed2;
     const failures = typeof record2.consecutiveFailures === "number" && record2.consecutiveFailures >= 0 ? record2.consecutiveFailures : 0;
     const openedAtMs = typeof record2.openedAtMs === "number" && Number.isFinite(record2.openedAtMs) && record2.openedAtMs <= nowMs ? record2.openedAtMs : null;
-    const lastFailure = typeof record2.lastFailure === "string" && FAILURES.has(record2.lastFailure) ? record2.lastFailure : null;
+    const parsedFailure = ControlPlaneFailure.safeParse(record2.lastFailure);
+    const lastFailure = parsedFailure.success ? parsedFailure.data : null;
     return { consecutiveFailures: failures, openedAtMs, lastFailure };
   } catch {
     return null;
@@ -41044,6 +41440,12 @@ var RemoteRequestInvalid = class extends Error {
   }
   cause;
 };
+var RemoteEndpointRefused = class extends Error {
+  constructor(endpoint) {
+    super(`refusing to talk to an unsafe control-plane endpoint: ${originOnly(endpoint)}`);
+    this.name = "RemoteEndpointRefused";
+  }
+};
 var RemoteResponseInvalid = class extends Error {
   constructor(route, detail) {
     super(`control plane answered ${route} with ${detail}`);
@@ -41196,14 +41598,15 @@ function parsed(schema, body, route) {
   }
   return result.data;
 }
-function withoutTrailingSlashes(endpoint) {
+function resolveBaseUrl(endpoint) {
+  if (!isSafeEndpoint(endpoint)) throw new RemoteEndpointRefused(endpoint);
   let end = endpoint.length;
   while (end > 0 && endpoint.charCodeAt(end - 1) === SLASH2) end -= 1;
   return endpoint.slice(0, end);
 }
 var SLASH2 = "/".charCodeAt(0);
 function createRemoteClient(options) {
-  const base = withoutTrailingSlashes(options.endpoint);
+  const base = resolveBaseUrl(options.endpoint);
   const url2 = (route) => `${base}${route}`;
   const common = { apiKey: options.apiKey, timeoutMs: options.timeoutMs };
   const sendOne = async (event) => {
@@ -41321,7 +41724,7 @@ var ATTACH_ROUTES = {
   token: "/v1/attach/token"
 };
 function createAttachClient(options) {
-  const base = withoutTrailingSlashes(options.endpoint);
+  const base = resolveBaseUrl(options.endpoint);
   const common = { timeoutMs: options.timeoutMs };
   return {
     notOfferedStatus: 404,
@@ -41362,6 +41765,7 @@ function classifyRemoteFailure(err) {
     case "RemoteRouteAbsent":
       return "route-absent";
     case "RemoteRequestInvalid":
+    case "RemoteEndpointRefused":
       return "invalid-request";
     case "RemoteResponseInvalid":
       return "rejected";
@@ -41451,7 +41855,16 @@ function rebuildCapture(row) {
   const metadata = {
     ...rootSessionId === null ? {} : { sessionId: rootSessionId },
     ...filePath === void 0 ? {} : { filePath },
-    ...pick2(attributes, { repo: "repo", toolName: "tool_name", model: "model" }),
+    ...pick2(attributes, {
+      repo: "repo",
+      toolName: "tool_name",
+      model: "model",
+      // The join back to the llm_call leaf for the same web-chat turn.
+      // Stripping these would forward a response capture the deployment can
+      // never correlate to the llm_call leaf describing the same turn.
+      messageId: "message_id",
+      conversationId: "conversation_id"
+    }),
     // The two constrained strings, kept only if they satisfy the wire.
     ...withField("traceId", keep(stringOrUndefined(attributes.trace_id), TRACE_ID)),
     ...withField(
@@ -42099,10 +42512,15 @@ import { join as join32 } from "path";
 // ../packages/plugin-runtime/src/attached/atomic-publish.ts
 import { rename as rename2 } from "fs/promises";
 var RETRYABLE = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
-var ATTEMPTS = 5;
+var IMMEDIATE_RETRIES = 8;
+var TIMED_RETRIES = 4;
+var ATTEMPTS = 1 + IMMEDIATE_RETRIES + TIMED_RETRIES;
 var delay = (ms) => new Promise((resolve7) => {
   setTimeout(resolve7, ms);
 });
+var yieldToLoop = () => new Promise((resolve7) => {
+  setImmediate(resolve7);
+});
 async function publishByRename(tmp, file2, move = rename2) {
   for (let attempt = 1; ; attempt += 1) {
     try {
@@ -42111,7 +42529,7 @@ async function publishByRename(tmp, file2, move = rename2) {
     } catch (err) {
       const code = err.code;
       if (attempt >= ATTEMPTS || code === void 0 || !RETRYABLE.has(code)) throw err;
-      await delay(attempt * 10);
+      await (attempt <= IMMEDIATE_RETRIES ? yieldToLoop() : delay((attempt - IMMEDIATE_RETRIES) * 10));
     }
   }
 }
@@ -42854,6 +43272,18 @@ function parseAttachArgs(argv) {
 var CONTROL_CHARS = /[\p{Cc}\p{Cf}]/u;
 var MUTUALLY_EXCLUSIVE = "--sync-history and --no-sync-history are mutually exclusive";
 var isError = (v) => "error" in v;
+function unsafeEndpointMessage(reason) {
+  switch (reason) {
+    case "unparseable":
+      return "that does not look like a web address; include the scheme, as in https://aka.example.com.";
+    case "userinfo":
+      return "the address carries a username or password; remove them, the access key is sent separately.";
+    case "query-or-fragment":
+      return "the address must be an origin, optionally with a path; drop the query string or fragment.";
+    case "insecure":
+      return "an access key must not travel in the clear. Use an https URL (http is accepted only for a loopback deployment).";
+  }
+}
 async function runAttach(argv, deps = {}) {
   const io = deps.prompter ?? terminalPrompter();
   const exit = deps.exit ?? ((code) => process.exit(code));
@@ -42872,10 +43302,9 @@ ${USAGE}`);
     exit(2);
     return;
   }
-  if (!isSafeEndpoint(endpoint)) {
-    io.err(
-      `refusing to attach to ${endpoint}: an access key must not travel in the clear. Use an https URL (http is accepted only for a loopback deployment).`
-    );
+  const unsafeReason = unsafeEndpointReason(endpoint);
+  if (unsafeReason !== null) {
+    io.err(`refusing to attach to ${originOnly(endpoint)}: ${unsafeEndpointMessage(unsafeReason)}`);
     exit(2);
     return;
   }
@@ -44512,6 +44941,7 @@ import { createRequire as createRequire3 } from "module";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname10, join as join36 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
+import { parseArgs as parseArgs5 } from "util";
 var require4 = createRequire3(import.meta.url);
 var here2 = dirname10(fileURLToPath7(import.meta.url));
 function cliRoot() {
@@ -44625,13 +45055,18 @@ function registerWindowsHost(manifestPath) {
   ]);
 }
 function runExtension(argv) {
-  const sub = argv[0];
+  const { values, positionals } = parseArgs5({
+    args: argv,
+    options: HOME_OPTION,
+    allowPositionals: true
+  });
+  const sub = positionals[0];
   if (sub === "install") {
     runInstall(chromeManifestDir());
     return;
   }
   if (sub === "status") {
-    runStatus2(chromeManifestDir());
+    runStatus2(chromeManifestDir(), homeBase(values.home));
     return;
   }
   process.stderr.write(
@@ -44705,7 +45140,40 @@ function manifestFault(manifestPath) {
   if (missing.length === 0) return null;
   return `does not grant ${missing.length === 1 ? "the extension id" : "the extension ids"} ${missing.join(", ")}`;
 }
-function runStatus2(manifestDir) {
+function captureBlock(home) {
+  try {
+    const effective = readEffectiveSettings(home);
+    const webChat = webChatCaptureOf(effective.settings);
+    if (!isWebChatCaptureConsentValid(webChat.consent)) {
+      return "\nnetwork capture: not enabled\n  no web-chat capture consent is recorded, so nothing is observed or stored\n  enable it under Settings in `aka dashboard`\n";
+    }
+    const db = openLocalDatabase(dataDir(home));
+    let records;
+    try {
+      records = db.captureStatus.latest(Date.now());
+    } finally {
+      db.close();
+    }
+    const lines = webCaptureReport(records).map((site) => {
+      let line = `  ${site.tool.padEnd(10)} ${site.state.padEnd(10)} ${site.headline}
+`;
+      if (site.drift && site.remediation !== void 0) {
+        line += `    ${WEB_CAPTURE_DRIFT_RULE.ruleId} (${WEB_CAPTURE_DRIFT_RULE.severity}) \u2014 ${site.remediation}
+`;
+      }
+      return line;
+    });
+    return `
+network capture
+${lines.join("")}`;
+  } catch (err) {
+    return `
+network capture: unavailable
+  the local store could not be read (${err instanceof Error ? err.message : String(err)})
+`;
+  }
+}
+function runStatus2(manifestDir, home) {
   const manifestPath = join36(manifestDir, `${NATIVE_HOST_NAME}.json`);
   if (!existsSync18(manifestPath)) {
     process.stdout.write(
@@ -44714,29 +45182,32 @@ function runStatus2(manifestDir) {
   run \`aka extension install\` to set it up
 `
     );
-    return;
-  }
-  const fault = manifestFault(manifestPath);
-  process.stdout.write(
-    `native-messaging host: ${fault ? "installed (out of date)" : "installed"}
+  } else {
+    const fault = manifestFault(manifestPath);
+    process.stdout.write(
+      `native-messaging host: ${fault ? "installed (out of date)" : "installed"}
   manifest: ${manifestPath}
 ` + (fault ? `  this manifest ${fault}
   Chrome refuses a connection from any origin the manifest omits \u2014
   re-run \`aka extension install\` to rewrite it
 ` : "")
-  );
-  if (fault) process.exitCode = 1;
+    );
+    if (fault) process.exitCode = 1;
+  }
+  if (home !== void 0) {
+    process.stdout.write(captureBlock(home));
+  }
 }
 
 // src/commands/init.ts
 import { existsSync as existsSync20, lstatSync as lstatSync4, readdirSync as readdirSync7, statSync as statSync13 } from "fs";
 import { join as join37 } from "path";
 import * as readline from "readline/promises";
-import { parseArgs as parseArgs6 } from "util";
+import { parseArgs as parseArgs7 } from "util";
 
 // src/commands/plugins.ts
 import { existsSync as existsSync19 } from "fs";
-import { parseArgs as parseArgs5 } from "util";
+import { parseArgs as parseArgs6 } from "util";
 function runPlugins(argv, deps = {}) {
   const [sub, ...rest] = argv;
   if (!sub || sub === "list") return listPlugins(rest);
@@ -44746,7 +45217,7 @@ function runPlugins(argv, deps = {}) {
   process.exitCode = 1;
 }
 async function listPlugins(argv) {
-  const { values } = parseArgs5({ args: argv, options: HOME_OPTION });
+  const { values } = parseArgs6({ args: argv, options: HOME_OPTION });
   const home = homeBase(values.home);
   const active = /* @__PURE__ */ new Set();
   if (existsSync19(dbPath(home))) {
@@ -44774,7 +45245,7 @@ async function listPlugins(argv) {
   out.write("Update:   aka update            (or: aka check-updates)\n");
 }
 async function installPlugin(argv, deps) {
-  const { positionals } = parseArgs5({ args: argv, options: HOME_OPTION, allowPositionals: true });
+  const { positionals } = parseArgs6({ args: argv, options: HOME_OPTION, allowPositionals: true });
   const id = positionals[0];
   if (!id) {
     process.stderr.write("aka plugins install: missing <agent> (try: aka plugins list)\n");
@@ -44939,7 +45410,7 @@ function existsAsNonDirectory(path) {
   }
 }
 async function runInit(argv) {
-  const { values } = parseArgs6({
+  const { values } = parseArgs7({
     args: argv,
     options: { ...HOME_OPTION, yes: { type: "boolean", short: "y" } }
   });
@@ -45036,7 +45507,7 @@ async function confirm(question) {
 }
 
 // src/commands/prune.ts
-import { parseArgs as parseArgs7 } from "util";
+import { parseArgs as parseArgs8 } from "util";
 var USAGE2 = `Usage: aka prune [--dry-run] [--days <n>]
 
 Expire captured bodies past the retention horizon. Keeps every event row and
@@ -45062,7 +45533,7 @@ function fmtBytes(n) {
 function runPrune(argv, io = terminalPrompter(), managedOverride) {
   let values;
   try {
-    ({ values } = parseArgs7({
+    ({ values } = parseArgs8({
       args: argv,
       options: {
         ...HOME_OPTION,
@@ -45137,7 +45608,7 @@ function runPrune(argv, io = terminalPrompter(), managedOverride) {
 
 // src/commands/scan.ts
 import { statSync as statSync14 } from "fs";
-import { parseArgs as parseArgs8 } from "util";
+import { parseArgs as parseArgs9 } from "util";
 function severityRank2(s) {
   return Severity.options.indexOf(s);
 }
@@ -45166,7 +45637,7 @@ function renderForwardLine(outcome) {
   }
 }
 async function runScan(argv, deps = {}) {
-  const { values, positionals } = parseArgs8({
+  const { values, positionals } = parseArgs9({
     args: argv,
     options: {
       ...HOME_OPTION,
@@ -45314,10 +45785,10 @@ async function runScan(argv, deps = {}) {
 }
 
 // src/commands/stats.ts
-import { parseArgs as parseArgs9 } from "util";
+import { parseArgs as parseArgs10 } from "util";
 var DAY_MS6 = 864e5;
 async function runStats(argv) {
-  const { values } = parseArgs9({
+  const { values } = parseArgs10({
     args: argv,
     options: { ...HOME_OPTION, range: { type: "string" } }
   });
@@ -45419,7 +45890,7 @@ function renderTokenUsage(summary, range) {
 }
 
 // src/commands/sync-history.ts
-import { parseArgs as parseArgs10 } from "util";
+import { parseArgs as parseArgs11 } from "util";
 var USAGE3 = `Usage: aka sync-history [--on | --off] [--run]
 
 Whether this machine may send the activity it recorded before attaching.
@@ -45437,7 +45908,7 @@ async function runSyncHistory(argv, deps = {}) {
   const exit = deps.exit ?? ((code) => process.exit(code));
   let values;
   try {
-    ({ values } = parseArgs10({
+    ({ values } = parseArgs11({
       args: argv,
       options: {
         ...HOME_OPTION,
@@ -45566,7 +46037,7 @@ applies. Run \`aka sync-history --on\` to grant it again.`;
 }
 
 // src/commands/tui.tsx
-import { parseArgs as parseArgs11 } from "util";
+import { parseArgs as parseArgs12 } from "util";
 import { render } from "ink";
 
 // src/tui/Dashboard.tsx
@@ -46076,7 +46547,7 @@ function parseView(positionals) {
   return VIEWS2.includes(first) ? first : "health";
 }
 async function runTui(argv) {
-  const { values, positionals } = parseArgs11({
+  const { values, positionals } = parseArgs12({
     args: argv,
     options: HOME_OPTION,
     allowPositionals: true
@@ -46120,7 +46591,7 @@ async function runTui(argv) {
 
 // src/commands/update.ts
 import * as readline2 from "readline/promises";
-import { parseArgs as parseArgs12 } from "util";
+import { parseArgs as parseArgs13 } from "util";
 
 // src/lib/install-origin.ts
 import { dirname as dirname11 } from "path";
@@ -46135,7 +46606,7 @@ function cliInstallOrigin() {
 
 // src/commands/update.ts
 async function runUpdate(argv) {
-  const { values, positionals } = parseArgs12({
+  const { values, positionals } = parseArgs13({
     args: argv,
     options: { ...HOME_OPTION, yes: { type: "boolean", short: "y" } },
     allowPositionals: true
@@ -46268,11 +46739,11 @@ function applyPluginUpdate2(status) {
 }
 
 // src/commands/vault.ts
-import { parseArgs as parseArgs14 } from "util";
+import { parseArgs as parseArgs15 } from "util";
 
 // src/commands/vault-prune.ts
 import { randomUUID as randomUUID21 } from "crypto";
-import { parseArgs as parseArgs13 } from "util";
+import { parseArgs as parseArgs14 } from "util";
 
 // src/lib/transcript-rewrite.ts
 import {
@@ -46540,7 +47011,7 @@ function plural(count2, one, many) {
   return `${String(count2)} ${count2 === 1 ? one : many}`;
 }
 async function runPrune2(argv, io) {
-  const { values } = parseArgs13({
+  const { values } = parseArgs14({
     args: argv,
     options: {
       ...HOME_OPTION,
@@ -46768,7 +47239,7 @@ function descriptorLine(d) {
   return `${kind} \xB7 seen ${String(d.occurrences)}\xD7 \xB7 first ${d.firstSeen.slice(0, 10)}`;
 }
 async function runShow2(argv, io) {
-  const { values, positionals } = parseArgs14({
+  const { values, positionals } = parseArgs15({
     args: argv,
     options: { ...HOME_OPTION, help: { type: "boolean", short: "h" } },
     allowPositionals: true