local-operator-ui 0.34.56 → 0.35.0

package/out/main/index.js

@@ -185,6 +185,26 @@ const profileName = zod.z.string().min(1).max(128).refine(
   )
 );
 const target = zod.z.object({ kind: zod.z.enum(["agent", "team"]), name: profileName }).strict();
+const importSourceName = zod.z.enum(["claude", "codex", "omp"]);
+const importSessionIds = zod.z.record(
+  zod.z.string(),
+  zod.z.array(zod.z.string().min(1).max(512)).max(5e3)
+);
+const importRequestFields = {
+  sources: zod.z.array(importSourceName).max(3).optional(),
+  sessionIds: importSessionIds.optional(),
+  /*
+   * Kept on the wire for the CLI/TUI and future callers, but the Settings
+   * surface never sets it: no-default-all is enforced in the UI by requiring
+   * an explicit per-session selection before preview and again before import.
+   */
+  all: zod.z.boolean().optional(),
+  includeSubagents: zod.z.boolean().optional(),
+  includeClearedSegments: zod.z.boolean().optional(),
+  includeMemory: zod.z.boolean().optional(),
+  includeInstructions: zod.z.boolean().optional(),
+  maxSessions: zod.z.number().int().min(1).max(5e3).optional()
+};
 const modelSelection = zod.z.object({
   provider: zod.z.string().min(1).max(128),
   model_id: zod.z.string().min(1).max(512),
@@ -419,6 +439,27 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
   zod.z.object({ op: zod.z.literal("runtimes.list") }).strict(),
   zod.z.object({ op: zod.z.literal("profiles.list") }).strict(),
   zod.z.object({ op: zod.z.literal("profiles.get"), name: profileName }).strict(),
+  /*
+   * The harness import plane. Reads are fixed-shape GETs; preview and start
+   * carry the same explicit request fields, and neither is allowed to infer a
+   * selection: the UI paints an empty selection and makes the user choose.
+   */
+  zod.z.object({ op: zod.z.literal("imports.sources") }).strict(),
+  zod.z.object({
+    op: zod.z.literal("imports.sessions"),
+    source: importSourceName,
+    includeSubagents: zod.z.boolean().optional()
+  }).strict(),
+  zod.z.object({ op: zod.z.literal("imports.preview"), ...importRequestFields }).strict(),
+  zod.z.object({ op: zod.z.literal("imports.start"), ...importRequestFields }).strict(),
+  zod.z.object({
+    op: zod.z.literal("imports.status"),
+    jobId: zod.z.string().min(1).max(128)
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("imports.cancel"),
+    jobId: zod.z.string().min(1).max(128)
+  }).strict(),
   /*
    * Definition CAS (proposed additive wire, b-wire-receipt-definition-cas-and-adopt).
    * `expectedDefinitionRevision` is an opaque echo of the `definition_revision` the
@@ -2780,6 +2821,10 @@ zod.z.object({
 const DESKTOP_MESSAGE_BYTE_BUDGET = 88e4;
 const DESKTOP_CONTROL_BYTE_BUDGET = 262144;
 const DESKTOP_SYSTEM_PROMPT_BYTE_BUDGET = 11e5;
+const IMPORT_OPS = /* @__PURE__ */ new Set([
+  "imports.preview",
+  "imports.start"
+]);
 const MESSAGE_OPS = /* @__PURE__ */ new Set([
   "sessions.message",
   "sessions.command",
@@ -2792,7 +2837,7 @@ const MESSAGE_OPS = /* @__PURE__ */ new Set([
 function desktopRequestByteBudget(op) {
   if (op === "legacy.agent.systemPrompt.update")
     return DESKTOP_SYSTEM_PROMPT_BYTE_BUDGET;
-  return MESSAGE_OPS.has(op) ? DESKTOP_MESSAGE_BYTE_BUDGET : DESKTOP_CONTROL_BYTE_BUDGET;
+  return MESSAGE_OPS.has(op) || IMPORT_OPS.has(op) ? DESKTOP_MESSAGE_BYTE_BUDGET : DESKTOP_CONTROL_BYTE_BUDGET;
 }
 const DESKTOP_CONTROL_DEADLINE_MS = 2e4;
 const DESKTOP_LONG_READ_DEADLINE_MS = 9e4;
@@ -3054,6 +3099,18 @@ function assertPairedPublicationTarget(request) {
     );
   }
 }
+function harnessImportBody(request) {
+  return {
+    sources: request.sources ?? null,
+    session_ids: request.sessionIds ?? {},
+    all: request.all ?? false,
+    include_subagents: request.includeSubagents ?? false,
+    include_cleared_segments: request.includeClearedSegments ?? false,
+    include_memory: request.includeMemory ?? true,
+    include_instructions: request.includeInstructions ?? true,
+    ...request.maxSessions === void 0 ? {} : { max_sessions: request.maxSessions }
+  };
+}
 function desktopEndpoint(request) {
   switch (request.op) {
     case "capabilities":
@@ -3149,6 +3206,38 @@ function desktopEndpoint(request) {
         method: "POST",
         body: { request_id: request.requestId, name: request.name }
       };
+    case "imports.sources":
+      return { path: "/v1/desktop/imports/sources", method: "GET" };
+    case "imports.sessions": {
+      const query = new URLSearchParams({ source: request.source });
+      if (request.includeSubagents) query.set("include_subagents", "true");
+      return {
+        path: `/v1/desktop/imports/sessions?${query.toString()}`,
+        method: "GET"
+      };
+    }
+    case "imports.preview":
+      return {
+        path: "/v1/desktop/imports/preview",
+        method: "POST",
+        body: harnessImportBody(request)
+      };
+    case "imports.start":
+      return {
+        path: "/v1/desktop/imports/jobs",
+        method: "POST",
+        body: harnessImportBody(request)
+      };
+    case "imports.status":
+      return {
+        path: `/v1/desktop/imports/jobs/${encodeURIComponent(request.jobId)}`,
+        method: "GET"
+      };
+    case "imports.cancel":
+      return {
+        path: `/v1/desktop/imports/jobs/${encodeURIComponent(request.jobId)}`,
+        method: "DELETE"
+      };
     case "profiles.create":
       return {
         path: "/v1/desktop/profiles",
@@ -4659,27 +4748,42 @@ function resolveWindowChromeForLaunch(input) {
 const GLASS_COVERAGES = ["sidebars", "full"];
 const GLASS_MAC_MATERIALS = ["window", "menu", "popover"];
 const GLASS_WIN_MATERIALS = ["mica", "acrylic", "tabbed"];
+const DEFAULT_GLASS_INTENSITY = 80;
 const DEFAULT_GLASS_SETTINGS = {
   enabled: false,
   coverage: "full",
-  intensity: 40,
+  intensity: DEFAULT_GLASS_INTENSITY,
   material: "window"
 };
 const WIN_BACKGROUND_MATERIAL_MIN_BUILD = 22621;
 const parseVersion = (version) => version.split(".").map((part) => Number.parseInt(part, 10)).map((n) => Number.isFinite(n) ? n : 0);
+const gpuFeatureUsable = (status2) => typeof status2 === "string" && status2.startsWith("enabled");
+function glassEnvironmentObjection(environment) {
+  if (!environment) return null;
+  if (environment.accelerationDisabledByLaunch || environment.hardwareAcceleration === false)
+    return "hardware-acceleration-disabled";
+  if (environment.gpu && (!gpuFeatureUsable(environment.gpu.compositing) || !gpuFeatureUsable(environment.gpu.rasterization)))
+    return "gpu-unavailable";
+  if (environment.backdropFilter === false)
+    return "backdrop-filter-unavailable";
+  return null;
+}
 function glassCapabilityFor(input) {
-  const none = (reason) => ({
+  const none = (reason, defaultMaterial = DEFAULT_GLASS_SETTINGS.material) => ({
     supported: false,
     mechanism: "none",
     reason,
     materials: [],
-    defaultMaterial: DEFAULT_GLASS_SETTINGS.material,
+    defaultMaterial,
     liquid: false,
+    defaultEnabled: false,
     liveToggle: false
   });
   const version = parseVersion(input.osVersion);
   if (input.platform === "darwin") {
     if (input.reducedTransparency) return none("reduced-transparency");
+    const objection = glassEnvironmentObjection(input.environment);
+    if (objection) return none(objection);
     return {
       supported: true,
       mechanism: "vibrancy",
@@ -4687,26 +4791,26 @@ function glassCapabilityFor(input) {
       materials: GLASS_MAC_MATERIALS,
       defaultMaterial: "window",
       liquid: (version[0] ?? 0) >= 26,
+      defaultEnabled: true,
       liveToggle: true
     };
   }
   if (input.platform === "win32") {
     if ((version[2] ?? 0) < WIN_BACKGROUND_MATERIAL_MIN_BUILD)
-      return none("windows-too-old");
-    if (input.reducedTransparency) return none("reduced-transparency");
-    return {
-      supported: true,
-      mechanism: "background-material",
-      reason: "ok",
-      materials: GLASS_WIN_MATERIALS,
-      defaultMaterial: "mica",
-      liquid: false,
-      liveToggle: false
-    };
+      return none("windows-too-old", "mica");
+    return none("windows-unverified", "mica");
   }
-  if (input.platform === "linux") return none("linux-no-native-blur");
+  if (input.platform === "linux") return none("linux-compositor-dependent");
   return none("unsupported-platform");
 }
+function defaultGlassSettings(capability) {
+  return {
+    enabled: capability.defaultEnabled,
+    coverage: "full",
+    intensity: DEFAULT_GLASS_INTENSITY,
+    material: capability.defaultMaterial
+  };
+}
 const isCoverage = (value) => GLASS_COVERAGES.includes(value);
 const migrateCoverage = (value) => value === "chrome" ? "sidebars" : value;
 function sanitizeGlassSettings(raw, capability, base = DEFAULT_GLASS_SETTINGS) {
@@ -4726,6 +4830,40 @@ function sanitizeGlassSettings(raw, capability, base = DEFAULT_GLASS_SETTINGS) {
     material
   };
 }
+const GLASS_FILE_VERSION = 2;
+const GLASS_SETTINGS_FIELDS = [
+  "enabled",
+  "coverage",
+  "intensity",
+  "material"
+];
+function resolveStoredGlass(raw, capability) {
+  if (raw === null || typeof raw !== "object") return null;
+  const record = raw;
+  if (record.settings === null || typeof record.settings !== "object")
+    return null;
+  const defaults = defaultGlassSettings(capability);
+  const stored = sanitizeGlassSettings(
+    record.settings,
+    capability,
+    DEFAULT_GLASS_SETTINGS
+  );
+  const legacy = record.version !== GLASS_FILE_VERSION || !Array.isArray(record.explicit);
+  const explicit = legacy ? [...GLASS_SETTINGS_FIELDS] : GLASS_SETTINGS_FIELDS.filter(
+    (field) => record.explicit.includes(field)
+  );
+  const settings = { ...defaults };
+  for (const field of explicit)
+    settings[field] = stored[field];
+  return {
+    settings,
+    explicit,
+    scheme: record.scheme === "light" ? "light" : "dark"
+  };
+}
+function glassGateLine(capability, settings, platform) {
+  return `[window-glass] launch gate platform=${platform} supported=${capability.supported} default=${capability.defaultEnabled} enabled=${settings.enabled} intensity=${settings.intensity} reason=${capability.reason} mechanism=${capability.mechanism}`;
+}
 const glassIsActive = (settings, capability) => settings.enabled && capability.supported;
 const GLASS_TRANSPARENT = "#00000000";
 function glassWindowOptions(settings, capability, platform) {
@@ -4763,6 +4901,7 @@ const WINDOW_GLASS_GET_CHANNEL = "window-glass:get";
 const WINDOW_GLASS_SET_CHANNEL = "window-glass:set";
 const WINDOW_GLASS_SCHEME_CHANNEL = "window-glass:scheme";
 const WINDOW_GLASS_STATE_CHANNEL = "window-glass:state";
+const WINDOW_GLASS_RENDERER_CHANNEL = "window-glass:renderer";
 const WINDOW_GLASS_FILE = "window-glass.json";
 function windowGlassArgument(state2, scheme) {
   if (!state2.active) return `${WINDOW_GLASS_ARG}=off`;
@@ -32318,6 +32457,8 @@ const enUiBrowser = {
   "ui.browser.browser_tab_strip.close": 'Close "',
   "ui.browser.browser_tab_strip.copy_url": "Copy URL",
   "ui.browser.browser_tab_strip.close_tab": "Close tab",
+  "ui.browser.browser_tab_strip.mute_tab": "Mute tab",
+  "ui.browser.browser_tab_strip.unmute_tab": "Unmute tab",
   "ui.browser.browser_tab_strip.close_tab_shortcut": "Close tab ({shortcut})",
   "ui.browser.browser_tab_strip.close_named_tab": "Close {title}",
   "ui.browser.browser_tab_strip.all_tabs_unshown": "All tabs — {count, plural, other {{count, number, ::group-off} not shown}}",
@@ -32330,6 +32471,7 @@ const enUiBrowser = {
   "ui.browser.browser_url_bar.forward_shortcut": "Forward ({shortcut})",
   "ui.browser.browser_url_bar.find_in_page": "Find in page",
   "ui.browser.browser_url_bar.find_in_page_shortcut": "Find in page ({shortcut})",
+  "ui.browser.browser_url_bar.print_page": "Print page",
   "ui.browser.browser_url_bar.forward": "Forward",
   "ui.browser.browser_url_bar.reset_page_zoom_shortcut": "Reset page zoom ({shortcut})",
   "ui.browser.browser_url_bar.page_zoom_reset": "Page zoom {zoom, number, ::group-off}%, reset to 100%",
@@ -34320,12 +34462,12 @@ const enUiSettingsAppearance = {
 };
 const enUiSettingsAppearanceWindowGlass = {
   "ui.settings.appearance.window_glass.label": "Translucent window",
-  "ui.settings.appearance.window_glass.description": "Lets your desktop show through the app window, blurred by the system. Off by default. Text stays readable on every theme: the slider stops before any theme's text gets hard to read.",
+  "ui.settings.appearance.window_glass.description": "Lets your desktop show through the app window, blurred by the system. On by default on macOS where the system supports it, and off elsewhere. Text stays readable on every theme: the slider stops before any theme's text gets hard to read.",
   "ui.settings.appearance.window_glass.restart_needed": "Restart Local Operator to apply this change. The window keeps its current look until then.",
-  "ui.settings.appearance.window_glass.unsupported_reduced_transparency": "Translucent window is unavailable because Reduce transparency is on in your system accessibility settings. Turn it off there and this control will appear.",
+  "ui.settings.appearance.window_glass.unsupported_reduced_transparency": "Translucent window is unavailable because Reduce transparency is on in your system accessibility settings. Turn it off there to enable this control.",
   "ui.settings.appearance.window_glass.unsupported_windows_too_old": "Translucent window needs Windows 11 version 22H2 or later.",
-  "ui.settings.appearance.window_glass.unsupported_linux": "Translucent window is not available on Linux: there is no system blur an app can ask for, and a see-through window without one would show the desktop's text through the app's.",
-  "ui.settings.appearance.window_glass.unsupported_other": "Translucent window is not available on this system.",
+  "ui.settings.appearance.window_glass.unsupported_linux": "Translucent window is not available on Linux: there is no native window blur an app can request. Desktop translucency there depends on the compositor (X11 or Wayland) and can fall back to software blur, which would show the desktop's text through the app's.",
+  "ui.settings.appearance.window_glass.unsupported_other": "Translucent window is not available on this platform: only macOS is verified to composite a blurred window, and the Windows 11 material is not verified on a real machine yet.",
   "ui.settings.appearance.window_glass.coverage_label": "Glass applies to",
   "ui.settings.appearance.window_glass.coverage_description": "Which parts of the window go translucent. Sidebars only leaves the conversation and pages solid. Full app also covers them and the side panels; web pages, documents and images shown inside stay solid.",
   "ui.settings.appearance.window_glass.coverage_sidebars": "Sidebars only",
@@ -34342,7 +34484,11 @@ const enUiSettingsAppearanceWindowGlass = {
   "ui.settings.appearance.window_glass.material_tabbed": "Tabbed",
   "ui.settings.appearance.window_glass.intensity_start": "Frosted",
   "ui.settings.appearance.window_glass.intensity_end": "See-through",
-  "ui.settings.appearance.window_glass.intensity_value": "{value}% toward see-through"
+  "ui.settings.appearance.window_glass.intensity_value": "{value}% toward see-through",
+  "ui.settings.appearance.window_glass.unsupported_windows_unverified": "Translucent window is not offered on Windows yet: Mica and Acrylic are implemented but have not been tested on a real Windows machine, so the control stays off until that testing lands.",
+  "ui.settings.appearance.window_glass.unsupported_gpu": "Translucent window is unavailable because the GPU cannot composite it right now: compositing or rasterisation is disabled or running in software. A driver update or leaving a remote session may bring the control back without a restart.",
+  "ui.settings.appearance.window_glass.unsupported_acceleration": "Translucent window is unavailable because hardware acceleration is off for this launch (--disable-gpu or a crash fallback). Relaunch with acceleration on to use it.",
+  "ui.settings.appearance.window_glass.unsupported_backdrop_filter": "Translucent window is unavailable because this renderer cannot draw a backdrop blur."
 };
 const enUiSettingsConfiguration = {
   "ui.settings.configuration.backend_setting_row.read_only": "Read-only",
@@ -34438,6 +34584,82 @@ const enUiSettingsConfiguration = {
   "ui.settings.configuration.settings_filter_bar.advanced_shown": "{count, plural, one {{count, number, ::group-off} advanced setting shown — Expand all to see it} other {{count, number, ::group-off} advanced settings shown — Expand all to see them}}",
   "ui.settings.configuration.settings_filter_bar.core_and_advanced": "{coreCount, plural, one {{coreCount, number, ::group-off} core setting} other {{coreCount, number, ::group-off} core settings}}, {advancedCount, plural, one {{advancedCount, number, ::group-off} advanced} other {{advancedCount, number, ::group-off} advanced}}"
 };
+const enUiSettingsImports = {
+  "ui.settings.imports.title": "Import conversations",
+  "ui.settings.imports.description": "Copy conversations and curated memory from Claude Code, Codex or omp into Local Operator. The source stores are read-only.",
+  "ui.settings.imports.source_heading": "Sources",
+  "ui.settings.imports.source_not_found": "Not found",
+  "ui.settings.imports.source_sessions": "{count, plural, one {# session} other {# sessions}}",
+  "ui.settings.imports.loading_sources": "Checking for source stores...",
+  "ui.settings.imports.loading_sessions": "Reading {source} sessions...",
+  "ui.settings.imports.loading_preview": "Building the preview...",
+  "ui.settings.imports.empty_sources": "No Claude Code, Codex or omp stores were detected on this machine.",
+  "ui.settings.imports.empty_sessions": "No sessions found for {source}.",
+  "ui.settings.imports.empty_filter": "No sessions match this search.",
+  "ui.settings.imports.error_sources": "Could not read the source stores. {reason}",
+  "ui.settings.imports.error_sessions": "Could not read {source} sessions. {reason}",
+  "ui.settings.imports.error_preview": "Could not build the preview. {reason}",
+  "ui.settings.imports.error_start": "Could not start the import. {reason}",
+  "ui.settings.imports.error_job": "Could not read import progress. {reason}",
+  "ui.settings.imports.error_cancel": "Could not cancel the import. {reason}",
+  "ui.settings.imports.retry": "Retry",
+  "ui.settings.imports.refresh": "Refresh",
+  "ui.settings.imports.search_placeholder": "Search conversations",
+  "ui.settings.imports.select_all": "Select all",
+  "ui.settings.imports.clear_all": "Clear selection",
+  "ui.settings.imports.selected": "{count, plural, one {# selected} other {# selected}}",
+  "ui.settings.imports.selection_limit": "Only {max, number} sessions can be selected at once. Select fewer sessions or import them in batches.",
+  "ui.settings.imports.session_meta": "{messages, plural, one {# message} other {# messages}} · {compactions, plural, one {# compaction} other {# compactions}}",
+  "ui.settings.imports.session_updated": "Updated {date}",
+  "ui.settings.imports.session_index_only": "Index only — no conversation body",
+  "ui.settings.imports.preview_heading": "Preview",
+  "ui.settings.imports.preview_summary": "{sessions, plural, one {# session} other {# sessions}} · {messages, plural, one {# message} other {# messages}} · {compactions, plural, one {# compaction} other {# compactions}}",
+  "ui.settings.imports.preview_memory": "{records, plural, one {# memory record} other {# memory records}} · ~{tokens} tokens",
+  "ui.settings.imports.preview_confirm": "Review the selection above, then confirm the copy.",
+  "ui.settings.imports.preview_required": "Select at least one session and build a preview first.",
+  "ui.settings.imports.confirm_label": "I understand these conversations will be copied into Local Operator.",
+  "ui.settings.imports.import_button": "{count, plural, one {Import # session} other {Import # sessions}}",
+  "ui.settings.imports.importing": "Importing",
+  "ui.settings.imports.progress_heading": "Importing conversations",
+  "ui.settings.imports.progress_job": "Job {job} · {state}",
+  "ui.settings.imports.progress_pending": "{count, plural, one {# session pending} other {# sessions pending}}",
+  "ui.settings.imports.cancel": "Cancel import",
+  "ui.settings.imports.cancelling": "Cancelling...",
+  "ui.settings.imports.result_heading": "Import result",
+  "ui.settings.imports.result_summary": "{state} · {sessions, plural, one {# session} other {# sessions}} · {messages, plural, one {# message} other {# messages}}",
+  "ui.settings.imports.result_summary_cancelled": "{state} · {sessions, number} of {total, plural, one {# session} other {# sessions}} · {messages, plural, one {# message} other {# messages}}",
+  "ui.settings.imports.result_target": "New session {target}",
+  "ui.settings.imports.outcome_imported": "imported",
+  "ui.settings.imports.outcome_resumed": "resumed",
+  "ui.settings.imports.outcome_skipped": "already imported",
+  "ui.settings.imports.outcome_metadata": "index only — nothing to import",
+  "ui.settings.imports.outcome_failed": "failed",
+  "ui.settings.imports.outcome_cancelled": "cancelled",
+  "ui.settings.imports.warnings_heading": "{count, plural, one {# warning} other {# warnings}}",
+  "ui.settings.imports.review_instructions": "Instructions saved for review",
+  "ui.settings.imports.review_memory": "Unattached memory saved for review",
+  "ui.settings.imports.copy_path": "Copy path",
+  "ui.settings.imports.copied": "Copied",
+  "ui.settings.imports.rerun_safe": "Re-running is safe: unchanged sources are skipped, grown sources resume, rewritten sources get a new copy.",
+  "ui.settings.imports.import_another": "Import more conversations",
+  "ui.settings.imports.metadata_only_explain": "The source index has an entry but no conversation body; nothing can be imported. The harness may have removed the rollout.",
+  "ui.settings.imports.state_queued": "queued",
+  "ui.settings.imports.state_running": "running",
+  "ui.settings.imports.state_done": "done",
+  "ui.settings.imports.state_failed": "failed",
+  "ui.settings.imports.state_cancelled": "cancelled",
+  "ui.settings.imports.phase_queued": "queued",
+  "ui.settings.imports.phase_selecting": "selecting",
+  "ui.settings.imports.phase_importing": "importing",
+  "ui.settings.imports.phase_memory": "reading memory",
+  "ui.settings.imports.phase_done": "finishing",
+  "ui.settings.imports.phase_cancelled": "cancelled",
+  "ui.settings.imports.session_pending": "Pending",
+  "ui.settings.imports.session_importing": "Importing",
+  "ui.settings.imports.availability_full": "full",
+  "ui.settings.imports.availability_metadata_only": "index only",
+  "ui.settings.imports.availability_unsupported": "unsupported"
+};
 const enUiSettingsIntegrations = {
   "ui.settings.integrations.add_integration_form.add_integration": "Add integration",
   "ui.settings.integrations.add_integration_form.name": "Name",
@@ -36318,6 +36540,7 @@ const bundledEnglish = {
   ...enUiSettingsAppearance,
   ...enUiSettingsAppearanceWindowGlass,
   ...enUiSettingsConfiguration,
+  ...enUiSettingsImports,
   ...enUiSettingsIntegrations,
   ...enUiSettings,
   ...enUiSettingsModelDefaultEffort,
@@ -39040,6 +39263,7 @@ const PAGE_ZOOM_STEPS = [
   4,
   5
 ];
+const PRINT_CANCELLED = /cancel/i;
 class PageControls {
   constructor(changed, resultTimeoutMs = 5e3) {
     this.changed = changed;
@@ -39174,6 +39398,36 @@ class PageControls {
     const factor = command === "reset" ? 1 : command === "in" ? PAGE_ZOOM_STEPS.find((step) => step > current + 1e-3) ?? 5 : [...PAGE_ZOOM_STEPS].reverse().find((step) => step < current - 1e-3) ?? 0.25;
     active.view.webContents.setZoomFactor?.(factor);
   }
+  /** Print the presented page (LOH-13 slice C).
+   *
+   * HUMAN-ONLY, like everything in this class: it travels the sender-
+   * authorized page-control IPC and the tab's serial lane, never the agent
+   * protocol — an agent that needs a page as a document already has the
+   * PDF/screenshot actions, and silently sending a page to a physical
+   * printer is not a capability a tool call should hold.
+   *
+   * `silent: false` is the load-bearing option: Electron's silent mode
+   * prints to the default printer with default settings and NO dialog,
+   * which for a human press would be a side effect they never confirmed.
+   * The dialog is the consent. A failure the dialog itself reports
+   * (cancelled is the person changing their mind, not a failure) only
+   * surfaces through `notice` when Electron names a real reason. */
+  print(active) {
+    if (!active.presented) return;
+    const wc = active.view.webContents;
+    if (wc.isDestroyed() || !wc.print) {
+      this.notice = "Printing is not available for this page";
+      this.noticeTabId = active.tabId;
+      return;
+    }
+    this.notice = null;
+    wc.print({ silent: false, printBackground: false }, (success, reason) => {
+      if (success || !reason || PRINT_CANCELLED.test(reason)) return;
+      this.notice = `Printing failed: ${reason}`;
+      this.noticeTabId = active.tabId;
+      this.changed();
+    });
+  }
   /** Call BEFORE a capability transfer. Isolated per-WebContents zoom means
    * resetting this tab cannot alter another tab at the same origin. */
   prepareAgent(record) {
@@ -39183,6 +39437,71 @@ class PageControls {
     if (changed) this.changed();
   }
 }
+class TabAudioTracker {
+  constructor(changed) {
+    this.changed = changed;
+  }
+  states = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  /** Start tracking one tab (idempotent) and return its current state. The
+   * muted flag is re-read live on every call: `setAudioMuted` is also
+   * reachable from the page's own media controls in principle, and a stale
+   * cached flag would render a button that claims the opposite of the
+   * page's actual state. */
+  stateFor(tab) {
+    this.track(tab);
+    const state2 = this.states.get(tab.tabId) ?? {
+      audible: false,
+      muted: false
+    };
+    const wc = tab.view.webContents;
+    if (!wc.isDestroyed()) state2.muted = wc.isAudioMuted?.() ?? state2.muted;
+    return { ...state2 };
+  }
+  /** Mute or unmute one tab. Returns the resulting state, or null when the
+   * webContents is already gone — the caller (a human press) then reports
+   * the tab as closed rather than claiming a mute that never landed. */
+  setMuted(tab, muted) {
+    const wc = tab.view.webContents;
+    if (wc.isDestroyed()) return null;
+    this.track(tab);
+    wc.setAudioMuted?.(muted);
+    const state2 = this.stateFor(tab);
+    state2.muted = wc.isAudioMuted?.() ?? muted;
+    this.states.set(tab.tabId, state2);
+    this.changed();
+    return { ...state2 };
+  }
+  /** Drop tracking for every tab not in `liveTabIds`. Called from the
+   * projection, which is the one place main already enumerates the live
+   * set on every change. */
+  prune(liveTabIds) {
+    for (const [tabId, entry] of this.listeners) {
+      if (liveTabIds.has(tabId)) continue;
+      this.listeners.delete(tabId);
+      this.states.delete(tabId);
+      if (!entry.wc.isDestroyed())
+        entry.wc.removeListener("audio-state-changed", entry.listener);
+    }
+  }
+  track(tab) {
+    if (this.listeners.has(tab.tabId)) return;
+    const wc = tab.view.webContents;
+    this.states.set(tab.tabId, {
+      audible: wc.isDestroyed() ? false : wc.isCurrentlyAudible?.() ?? false,
+      muted: wc.isDestroyed() ? false : wc.isAudioMuted?.() ?? false
+    });
+    const listener = (event) => {
+      const current = this.states.get(tab.tabId);
+      if (!current) return;
+      current.audible = event?.audible ?? false;
+      this.states.set(tab.tabId, current);
+      this.changed();
+    };
+    this.listeners.set(tab.tabId, { wc, listener });
+    if (!wc.isDestroyed()) wc.on("audio-state-changed", listener);
+  }
+}
 const DUPLICATABLE_WEB_URL = /^https?:\/\//i;
 const DOCUMENT_SCOPED = /* @__PURE__ */ new Set([
   "read",
@@ -39272,6 +39591,10 @@ class BrowserHost {
   chromeTabOrder = new ChromeTabOrder();
   registry;
   pageControls;
+  /** Per-tab audio for the strip's mute control (LOH-13 slice C). Main owns
+   * it for the reason `tabLoading` is read here: a background tab's sound
+   * is legible only through this projection. */
+  tabAudio = new TabAudioTracker(() => this.onChanged());
   cdp;
   approvals;
   ownership;
@@ -39581,6 +39904,9 @@ class BrowserHost {
     const activeRecord = this.registry.activeTab;
     const active = activeRecord && !activeRecord.view.webContents.isDestroyed() ? activeRecord : null;
     const navigation = active?.view.webContents.navigationHistory;
+    this.tabAudio.prune(
+      new Set(this.registry.snapshot().map((entry) => entry.tabId))
+    );
     return {
       pageControls: this.pageControls.state(active),
       tabs: this.chromeTabOrder.project(this.registry.snapshot()).map((entry, displayOrder) => ({
@@ -39616,7 +39942,20 @@ class BrowserHost {
         // was the whole of what the user saw of an agent's work. Read from the
         // record rather than the snapshot: `snapshot()` is the diagnostic
         // projection shared with `status`/`tabs`, and this field is chrome.
-        loading: this.tabLoading(entry.tabId)
+        loading: this.tabLoading(entry.tabId),
+        // PER TAB, projected with `loading` and for the same reason: a
+        // background tab making sound has no other surface. `audible`
+        // gates the mute control's visibility; `muted` is its state.
+        // Read from the record (guarded like `tabLoading`) because the
+        // snapshot carries no webContents.
+        audible: (() => {
+          const record = this.registry.get(entry.tabId);
+          return record && !record.view.webContents.isDestroyed() ? this.tabAudio.stateFor(record).audible : false;
+        })(),
+        muted: (() => {
+          const record = this.registry.get(entry.tabId);
+          return record && !record.view.webContents.isDestroyed() ? this.tabAudio.stateFor(record).muted : false;
+        })()
       })),
       activeTabId: activeRecord?.tabId ?? null,
       // The download surface's facts (§16.4): what is in flight, where it went and
@@ -39718,8 +40057,23 @@ class BrowserHost {
         error: { code: "tab_closed", message: t("ui.browser.chrome.tab_gone") }
       };
     let url = "";
-    let destinationId = action === "reload" ? tabId : null;
+    let destinationId = action === "duplicate" ? null : tabId;
     try {
+      if (action === "mute" || action === "unmute") {
+        const result = this.tabAudio.setMuted(record, action === "mute");
+        if (!result)
+          return {
+            status: "failed",
+            action,
+            tabId: null,
+            error: {
+              code: "tab_closed",
+              message: t("ui.browser.chrome.tab_gone")
+            }
+          };
+        this.onChanged();
+        return { status: "completed", action, tabId };
+      }
       url = record.view.webContents.getURL();
       if (action === "duplicate" && url !== "about:blank" && !DUPLICATABLE_WEB_URL.test(url))
         return {
@@ -39788,6 +40142,7 @@ class BrowserHost {
       if (!active || active.tabId !== tabId || !active.presented || active.view.webContents.isDestroyed())
         throw new Error("The browser tab is no longer presented.");
       if (action === "open") this.pageControls.open(active);
+      else if (action === "print") this.pageControls.print(active);
       else if (action === "close") this.pageControls.clear();
       else if (action === "search")
         this.pageControls.search(active, query, forward, next);
@@ -40527,7 +40882,8 @@ class DownloadArmer {
       deadlineTimer: null,
       capTimer: null,
       finish: null,
-      settled: false
+      settled: false,
+      human: false
     };
     this.captures.set(tabId, capture);
     const deadline2 = setTimeout(() => this.settle(capture), timeoutMs);
@@ -40582,9 +40938,15 @@ class DownloadArmer {
    */
   decide(item, webContentsId) {
     const tabId = this.options.tabForWebContents(webContentsId);
-    const capture = tabId === null ? void 0 : this.captures.get(tabId);
+    let capture = tabId === null ? void 0 : this.captures.get(tabId);
     if (!capture || capture.settled) {
-      return { cancel: true, reason: "no download call is armed on this tab" };
+      capture = (tabId !== null ? this.humanCapture(tabId) : null) ?? void 0;
+      if (!capture) {
+        return {
+          cancel: true,
+          reason: "no download call is armed on this tab"
+        };
+      }
     }
     const raw = item.getFilename();
     const clean = safeName(raw);
@@ -40706,6 +41068,58 @@ class DownloadArmer {
     const dirs = this.notes.filter((note) => note.dir !== "").map((n) => n.dir);
     return [...this.captures.values()].at(-1)?.dir ?? dirs.at(-1) ?? null;
   }
+  /** Build (or reuse) the human capture for one user-owned tab.
+   *
+   * Returns null — leaving the caller to cancel — when this host cannot
+   * honestly call the download human-initiated: the tab is agent-owned or
+   * handed to an agent (`ownerKindOf` reads the registry's CURRENT owner,
+   * which hand-over flips), the armer was built without a human directory,
+   * or that directory cannot be made. A settled human capture is replaced
+   * rather than reused, so its file count bounds one burst (up to the
+   * quiet window after the last write) and never the session.
+   *
+   * The directory is NOT chmodded, unlike `arm`: it is the person's own
+   * downloads folder, which predates this app and whose mode is theirs.
+   * The runtime-cap sampler IS started, for the reason `CAP_SAMPLE_MS`
+   * states: an unknown-size human download has the same disk to fill as
+   * an agent's. */
+  humanCapture(tabId) {
+    if (this.ownerKindOf(tabId) !== "user") return null;
+    const dir = this.options.humanDownloadDir?.() ?? null;
+    if (!dir) return null;
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+      return null;
+    }
+    const capture = {
+      tabId,
+      dir,
+      timeoutMs: 0,
+      startedAt: (this.options.now ?? Date.now)(),
+      files: [],
+      refusals: [],
+      pending: 0,
+      started: false,
+      live: [],
+      handedOut: /* @__PURE__ */ new Set(),
+      active: null,
+      lastProgressAt: 0,
+      quietTimer: null,
+      deadlineTimer: null,
+      capTimer: null,
+      finish: null,
+      settled: false,
+      human: true
+    };
+    capture.capTimer = setInterval(
+      () => this.sampleCaps(capture),
+      CAP_SAMPLE_MS
+    );
+    capture.capTimer.unref?.();
+    this.captures.set(tabId, capture);
+    return capture;
+  }
   /** One upload's own line (review round 1, U3).
    *
    * WHY AN UPLOAD HAS A NOTE AT ALL, when §16.4 deliberately has no upload
@@ -40777,7 +41191,7 @@ class DownloadArmer {
       if (entry.weCancelled) {
         if (state2 !== "completed") discardPartial(savePath, this.options.log);
       } else if (state2 === "completed") {
-        restrictMode(savePath, this.options.log);
+        if (!capture.human) restrictMode(savePath, this.options.log);
         capture.files.push(fileFact(item, savePath));
         this.note(capture, name, "saved", 1, "", null);
       } else {
@@ -40933,6 +41347,9 @@ class DownloadArmer {
     capture.settled = true;
     capture.active = null;
     this.clearTimers(capture);
+    if (this.captures.get(capture.tabId) === capture) {
+      this.captures.delete(capture.tabId);
+    }
     capture.finish?.();
     this.options.onActivity?.();
   }
@@ -40963,6 +41380,7 @@ class DownloadArmer {
     capture.refusals.push(reason);
     this.note(capture, clean, "refused", 1, reason, refusal);
     this.options.log(`[browser] ${reason}`);
+    this.options.onActivity?.();
     return { cancel: true, reason };
   }
   note(capture, name, outcome, count, reason, refusal) {
@@ -41215,7 +41633,7 @@ function registerBrowserIpc(options) {
     "browser-tab-action",
     (event, tabId, action) => {
       const host = authorize(event);
-      if (action !== "duplicate" && action !== "reload")
+      if (action !== "duplicate" && action !== "reload" && action !== "mute" && action !== "unmute")
         throw new Error(t("ui.browser.chrome.invalid_action"));
       return host.actOnChromeTab(numberOrThrow(tabId, "tabId"), action);
     }
@@ -41243,7 +41661,9 @@ function registerBrowserIpc(options) {
     "browser-page-control",
     (event, tabId, action, query, forward, next) => {
       const host = authorize(event);
-      if (typeof action !== "string" || !["open", "close", "search", "in", "out", "reset"].includes(action))
+      if (typeof action !== "string" || !["open", "close", "search", "print", "in", "out", "reset"].includes(
+        action
+      ))
         throw new Error("Invalid page control action.");
       if (typeof query !== "string" || query.length > 4096 || typeof forward !== "boolean" || typeof next !== "boolean")
         throw new Error("Invalid page search input.");
@@ -43623,6 +44043,17 @@ async function initializeBrowserHost(options, bindings) {
       // exists is a marker pointing at nothing. `null` when the lookup cannot answer
       // (a tab already gone), which the row renders the old way rather than guessing.
       ownerKindFor: (tabId) => registryForDownloads?.get(tabId)?.owner ?? null,
+      // The human download destination (LOH-13 slice C): the person's
+      // own downloads folder, read from the app at decision time. Main
+      // composes it here for the same reason the reveal channel takes
+      // no path: no renderer or page string ever becomes a directory.
+      humanDownloadDir: () => electron.app.getPath("downloads"),
+      // NO `humanDeadlineMs` WIRING (review round 2, MAJOR): the wall-clock
+      // budget this used to pass settled — and cancelled, discarding the
+      // partial — a legitimate in-flight human download at 120 s. A human
+      // capture now ends only on a guard, the quiet window, or the tab.
+      // `COMMAND_TIMEOUTS_S.download` remains the AGENT call's own budget,
+      // passed by its caller and unchanged.
       log: log2,
       onActivity: () => {
         if (options.window.isDestroyed()) return;
@@ -45640,7 +46071,13 @@ function miniGlassPlan(input) {
 function miniDocumentState(state2, launchedGlassOn) {
   return {
     ...state2,
-    restartRequired: !state2.capability.liveToggle && state2.active !== launchedGlassOn
+    /*
+     * Same rule as the main window's `stateFor`: a restart is only pending for a
+     * SUPPORTED change that cannot be applied live. Without the `supported` term a
+     * capability drop (`mechanism: "none"`, also `liveToggle: false`) reads as a
+     * restart-pending change in the popout as well.
+     */
+    restartRequired: state2.capability.supported && !state2.capability.liveToggle && state2.active !== launchedGlassOn
   };
 }
 function createMiniView(options) {
@@ -53901,21 +54338,46 @@ function attachWindowChrome(options) {
 function windowGlassFilePath(userDataDir) {
   return path$1.join(userDataDir, WINDOW_GLASS_FILE);
 }
+let gpuInfoReported = false;
+electron.app.on("gpu-info-update", () => {
+  gpuInfoReported = true;
+});
+function readGlassEnvironmentFacts() {
+  const facts = {};
+  try {
+    facts.accelerationDisabledByLaunch = electron.app.commandLine.hasSwitch("disable-gpu");
+  } catch {
+    facts.accelerationDisabledByLaunch = false;
+  }
+  try {
+    facts.hardwareAcceleration = electron.app.isHardwareAccelerationEnabled();
+  } catch {
+    facts.hardwareAcceleration = null;
+  }
+  try {
+    const status2 = gpuInfoReported ? electron.app.getGPUFeatureStatus() : null;
+    facts.gpu = status2 ? {
+      compositing: status2.gpu_compositing,
+      rasterization: status2.rasterization
+    } : null;
+  } catch {
+    facts.gpu = null;
+  }
+  return facts;
+}
 function readPersistedWindowGlass(userDataDir, capability) {
   const raw = readJson(
     windowGlassFilePath(userDataDir)
   );
-  if (raw === null || typeof raw !== "object") return null;
-  return {
-    settings: sanitizeGlassSettings(raw.settings, capability),
-    scheme: raw.scheme === "light" ? "light" : "dark"
-  };
+  return resolveStoredGlass(raw, capability);
 }
 function resolveLaunchWindowGlass(input) {
+  const environment = input.environment ?? readGlassEnvironmentFacts();
   const capability = glassCapabilityFor({
     platform: input.platform ?? process.platform,
     osVersion: input.osVersion ?? process.getSystemVersion(),
-    reducedTransparency: input.reducedTransparency ?? electron.nativeTheme.prefersReducedTransparency
+    reducedTransparency: input.reducedTransparency ?? electron.nativeTheme.prefersReducedTransparency,
+    environment
   });
   let persisted = null;
   try {
@@ -53923,13 +54385,16 @@ function resolveLaunchWindowGlass(input) {
   } catch {
     persisted = null;
   }
-  const settings = persisted?.settings ?? DEFAULT_GLASS_SETTINGS;
+  const settings = persisted?.settings ?? defaultGlassSettings(capability);
+  const explicit = persisted?.explicit ?? [];
   const scheme = persisted?.scheme ?? "dark";
   return {
     capability,
     settings,
+    explicit,
     scheme,
-    state: stateFor(settings, capability)
+    state: stateFor(settings, capability),
+    environment
   };
 }
 const stateFor = (settings, capability, launchedActive = glassIsActive(settings, capability)) => {
@@ -53938,7 +54403,16 @@ const stateFor = (settings, capability, launchedActive = glassIsActive(settings,
     capability,
     settings,
     active,
-    restartRequired: !capability.liveToggle && active !== launchedActive
+    /*
+     * A RESTART IS ONLY PENDING WHEN THE EFFECT IS AVAILABLE AND NOT LIVE.
+     * `liveToggle: false` is also true of `mechanism: "none"`, so a capability
+     * DROP (GPU software fallback, backdrop-filter report, Reduce transparency)
+     * satisfied the old expression and told the user to restart while the window
+     * had already fallen back to opaque. The unsupported state has its own
+     * cause line; this notice is only for a supported change that needs a new
+     * window (QA Q-1 / design D2).
+     */
+    restartRequired: capability.supported && !capability.liveToggle && active !== launchedActive
   };
 };
 function attachWindowGlass(options) {
@@ -53946,6 +54420,8 @@ function attachWindowGlass(options) {
   let capability = options.initial.capability;
   let settings = options.initial.settings;
   let scheme = options.initial.scheme;
+  const explicit = new Set(options.initial.explicit);
+  let environment = { ...options.initial.environment };
   const launchedActive = glassIsActive(settings, capability);
   let pinnedTheme = false;
   let appliedMechanism = launchedActive ? capability.mechanism : "none";
@@ -53989,7 +54465,17 @@ function attachWindowGlass(options) {
     }
   };
   const persist = () => {
-    if (!writeJsonAtomic(windowGlassFilePath(userDataDir), { settings, scheme }))
+    if (!writeJsonAtomic(windowGlassFilePath(userDataDir), {
+      /*
+       * Versioned and per-field: the next launch fills only what this list does
+       * not name from its own defaults. Writing the full `settings` object alone
+       * is what made an untouched OFF indistinguishable from a chosen one.
+       */
+      version: GLASS_FILE_VERSION,
+      settings,
+      explicit: GLASS_SETTINGS_FIELDS.filter((field) => explicit.has(field)),
+      scheme
+    }))
       log2(
         "[window-glass] the setting could not be saved - it applies to this run and will not survive a restart"
       );
@@ -54010,6 +54496,11 @@ function attachWindowGlass(options) {
     (event, patch) => {
       if (!fromOwnWindow(event)) return null;
       settings = sanitizeGlassSettings(patch, capability, settings);
+      if (patch !== null && typeof patch === "object") {
+        for (const field of Object.keys(patch))
+          if (GLASS_SETTINGS_FIELDS.includes(field))
+            explicit.add(field);
+      }
       applyToWindow();
       persist();
       push2();
@@ -54028,23 +54519,47 @@ function attachWindowGlass(options) {
     persist();
     return true;
   });
-  const onNativeThemeUpdated = () => {
+  electron.ipcMain.handle(WINDOW_GLASS_RENDERER_CHANNEL, (event, report) => {
+    if (!fromOwnWindow(event)) return null;
+    if (report !== null && typeof report === "object") {
+      const value = report.backdropFilter;
+      if (typeof value === "boolean")
+        environment = { ...environment, backdropFilter: value };
+    }
+    reevaluate();
+    return current();
+  });
+  function reevaluate() {
+    environment = {
+      ...readGlassEnvironmentFacts(),
+      ...environment.backdropFilter === void 0 ? {} : { backdropFilter: environment.backdropFilter }
+    };
     const next = glassCapabilityFor({
       platform: process.platform,
       osVersion: process.getSystemVersion(),
-      reducedTransparency: electron.nativeTheme.prefersReducedTransparency
+      reducedTransparency: electron.nativeTheme.prefersReducedTransparency,
+      environment
     });
-    if (next.supported === capability.supported && next.reason === capability.reason)
+    if (next.supported === capability.supported && next.reason === capability.reason && next.mechanism === capability.mechanism)
       return;
+    const wasSupported = capability.supported;
     capability = next;
     settings = sanitizeGlassSettings(settings, capability, settings);
+    if (next.supported && !wasSupported && !explicit.has("enabled"))
+      settings.enabled = defaultGlassSettings(next).enabled;
     applyToWindow();
     push2();
     log2(
       `[window-glass] capability changed supported=${next.supported} reason=${next.reason}`
     );
-  };
+  }
+  const onNativeThemeUpdated = () => reevaluate();
   electron.nativeTheme.on("updated", onNativeThemeUpdated);
+  electron.app.on("gpu-info-update", reevaluate);
+  const onChildProcessGone = (_event, details) => {
+    if (details?.type === "GPU") setTimeout(reevaluate, 0);
+  };
+  electron.app.on("child-process-gone", onChildProcessGone);
   if (glassIsActive(settings, capability)) {
     electron.nativeTheme.themeSource = scheme;
     pinnedTheme = true;
@@ -54055,7 +54570,10 @@ function attachWindowGlass(options) {
       electron.ipcMain.removeHandler(WINDOW_GLASS_GET_CHANNEL);
       electron.ipcMain.removeHandler(WINDOW_GLASS_SET_CHANNEL);
       electron.ipcMain.removeHandler(WINDOW_GLASS_SCHEME_CHANNEL);
+      electron.ipcMain.removeHandler(WINDOW_GLASS_RENDERER_CHANNEL);
       electron.nativeTheme.removeListener("updated", onNativeThemeUpdated);
+      electron.app.removeListener("gpu-info-update", reevaluate);
+      electron.app.removeListener("child-process-gone", onChildProcessGone);
       if (pinnedTheme) electron.nativeTheme.themeSource = "system";
     }
   };
@@ -54808,6 +55326,7 @@ const authPopupWindowOptions = {
     disableDialogs: true
   }
 };
+let glassGateLogged = false;
 function createWindow(initialSession = null, openCatalogue = false, request = ownLaunchRequest()) {
   const chrome = resolveLaunchWindowChrome({
     argv: process.argv,
@@ -54822,6 +55341,13 @@ function createWindow(initialSession = null, openCatalogue = false, request = ow
   const glass = resolveLaunchWindowGlass({
     userDataDir: electron.app.getPath("userData")
   });
+  if (!glassGateLogged) {
+    glassGateLogged = true;
+    logger.info(
+      glassGateLine(glass.capability, glass.settings, process.platform),
+      LogFileType.BACKEND
+    );
+  }
   const mainWindow2 = new electron.BrowserWindow({
     /*
      * The frame, per platform, from a pure function so the matrix is exercised on