local-operator-ui 0.34.44 → 0.34.46

package/out/main/index.js

@@ -92,6 +92,7 @@ const mcpCatalogCwdPattern = /^(\/|[A-Za-z]:[\\/])/;
 const mcpCatalogCwd = zod.z.string().min(1).max(4096).regex(mcpCatalogCwdPattern);
 const SUBSCRIPTION_ID_PATTERN = /^[a-f0-9]{32}$/;
 const requestId = zod.z.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
+const definitionRevision = zod.z.string().min(1).max(512).nullish();
 const meshId = zod.z.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
 const approvalId = zod.z.string().regex(/^ap_[0-9a-hjkmnp-tv-z]{1,64}$/);
 const sessionImage = zod.z.object({
@@ -262,6 +263,12 @@ const publicationDescription = zod.z.string().refine((description) => publicatio
 const publicationTools = zod.z.array(zod.z.string()).refine((tools) => publicationToolsRule(tools) === null, {
   message: "That tool list cannot be published."
 });
+const publicationPolicyFields = {
+  requestId: requestId.optional(),
+  subscribe: zod.z.boolean().optional(),
+  autoPush: zod.z.boolean().optional(),
+  confirmPublicEgress: zod.z.boolean().optional()
+};
 const publicationDocument = zod.z.object({
   name: publicationName,
   description: publicationDescription,
@@ -325,6 +332,21 @@ 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(),
+  /*
+   * Definition CAS (proposed additive wire, b-wire-receipt-definition-cas-and-adopt).
+   * `expectedDefinitionRevision` is an opaque echo of the `definition_revision` the
+   * editor was opened with; absent/null is the LEGACY unconditional write and is
+   * NOT a protected dirty-edit guarantee, so a caller that wants CAS protection
+   * must send it. Strict like every field here: a typo must 400, not silently
+   * become an unconditional write.
+   */
+  zod.z.object({
+    op: zod.z.literal("profiles.update"),
+    name: profileName,
+    requestId,
+    fields: profileFields,
+    expectedDefinitionRevision: definitionRevision.optional()
+  }).strict(),
   zod.z.object({ op: zod.z.literal("profiles.install"), name: profileName, requestId }).strict(),
   zod.z.object({
     op: zod.z.literal("profiles.create"),
@@ -335,12 +357,6 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
       instructions: zod.z.string().min(1).max(8e3)
     })
   }).strict(),
-  zod.z.object({
-    op: zod.z.literal("profiles.update"),
-    name: profileName,
-    requestId,
-    fields: profileFields
-  }).strict(),
   /*
    * THE HUB AUTO-UPDATE PLANE (backend `server/routes/desktop_hub.py`, gated by
    * the `hub_updates` capability). `hub.updates` is a STORE READ on the backend
@@ -356,20 +372,83 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
    * apply-all schema does not offer it.
    */
   zod.z.object({ op: zod.z.literal("hub.updates") }).strict(),
+  // Initial skill publication uses an actual discovered source and managed
+  // alias, never a synthetic link ID or a private-directory clone.
+  zod.z.object({
+    op: zod.z.literal("hub.skillPull"),
+    requestId,
+    hubId: id$1,
+    hubSource: zod.z.string().min(1).max(2048),
+    visibility: zod.z.enum(["public", "org"]),
+    tenantId: id$1.nullable(),
+    localAlias: profileName,
+    subscribe: zod.z.boolean().optional(),
+    autoPush: zod.z.boolean().optional(),
+    confirmPublicEgress: zod.z.boolean().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.skillPublish"),
+    requestId,
+    dryRun: zod.z.boolean(),
+    sourceSkill: profileName,
+    localAlias: profileName,
+    visibility: zod.z.enum(["public", "org"]),
+    tenantId: id$1.nullable(),
+    subscribe: zod.z.boolean(),
+    autoPush: zod.z.boolean(),
+    confirmPublicEgress: zod.z.boolean(),
+    previewReceipt: zod.z.string().min(1).max(4096).optional(),
+    confirmPublish: zod.z.literal(true).optional()
+  }).strict(),
+  // Full inventory is additive: old callers still receive pending agents/teams
+  // only. Policy revision is required even for a single independent toggle so
+  // an intervening direct config edit cannot be silently overwritten.
+  zod.z.object({
+    op: zod.z.literal("hub.links"),
+    kind: zod.z.enum(["agent", "team", "skill"]).optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.policy"),
+    requestId,
+    linkId: zod.z.string().min(1).max(256),
+    expectedPolicyRevision: zod.z.string().min(1).max(256),
+    subscribe: zod.z.boolean().optional(),
+    autoPush: zod.z.boolean().optional(),
+    confirmPublicEgress: zod.z.boolean().optional()
+  }).strict(),
   zod.z.object({
     op: zod.z.literal("hub.check"),
     requestId,
+    linkId: zod.z.string().min(1).max(256).optional(),
+    direction: zod.z.enum(["pull", "push"]).optional(),
     kind: hubItemKind.optional(),
     name: profileName.optional()
   }).strict(),
   zod.z.object({
     op: zod.z.literal("hub.apply"),
     requestId,
-    kind: hubItemKind,
-    name: profileName,
+    previewReceipt: zod.z.string().min(1).max(4096).optional(),
+    confirmApply: zod.z.literal(true).optional(),
+    linkId: zod.z.string().min(1).max(256).optional(),
+    direction: zod.z.literal("pull").optional(),
+    kind: hubItemKind.optional(),
+    name: profileName.optional(),
     prefer: zod.z.enum(["local", "remote"]).optional(),
     acknowledgeUnknownBaseline: zod.z.boolean().optional(),
-    dryRun: zod.z.boolean().optional()
+    dryRun: zod.z.boolean().optional(),
+    /*
+     * LEGACY UNKNOWN-ORIGIN SOURCE CONFIRMATION (proposed additive wire,
+     * b-wire-receipt §Part 2). An EXPLICIT act that states a destination the
+     * caller asserts: it materializes the real baseline identity and scope,
+     * it never infers Public or the active organization. `resolve_source`
+     * selects the branch; the source/scope triple is REQUIRED with it so a
+     * half-stated destination cannot compose a guessed origin. The service
+     * refuses a conflicting known scope with `origin-conflict`.
+     */
+    resolveSource: zod.z.literal(true).optional(),
+    hubSource: zod.z.string().min(1).max(2048).optional(),
+    visibility: zod.z.enum(["public", "org"]).optional(),
+    tenantId: zod.z.string().min(1).max(128).nullable().optional()
   }).strict(),
   zod.z.object({
     op: zod.z.literal("hub.applyAll"),
@@ -379,21 +458,38 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
   zod.z.object({
     op: zod.z.literal("hub.retry"),
     requestId,
-    kind: hubItemKind,
-    name: profileName
+    linkId: zod.z.string().min(1).max(256).optional(),
+    direction: zod.z.enum(["pull", "push"]).optional(),
+    kind: hubItemKind.optional(),
+    name: profileName.optional()
   }).strict(),
-  zod.z.object({ op: zod.z.literal("teams.list") }).strict(),
-  zod.z.object({ op: zod.z.literal("teams.get"), name: profileName }).strict(),
   zod.z.object({
-    op: zod.z.literal("teams.create"),
+    op: zod.z.literal("hub.push"),
     requestId,
-    fields: teamFields.extend({ name: zod.z.string().min(1).max(64) })
+    linkId: zod.z.string().min(1).max(256),
+    direction: zod.z.literal("push"),
+    dryRun: zod.z.boolean(),
+    previewReceipt: zod.z.string().min(1).max(4096).optional(),
+    confirmPublish: zod.z.literal(true).optional()
   }).strict(),
+  zod.z.object({ op: zod.z.literal("teams.list") }).strict(),
+  zod.z.object({ op: zod.z.literal("teams.get"), name: profileName }).strict(),
+  /*
+   * Team CAS is the same optional opaque echo as the profile arm: absent/null is
+   * the legacy unconditional write, a supplied stale/malformed value is refused
+   * 409 `local-concurrent-edit` before any write under the definition lock.
+   */
   zod.z.object({
     op: zod.z.literal("teams.update"),
     name: profileName,
     requestId,
-    fields: teamFields
+    fields: teamFields,
+    expectedDefinitionRevision: definitionRevision.optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("teams.create"),
+    requestId,
+    fields: teamFields.extend({ name: zod.z.string().min(1).max(64) })
   }).strict(),
   zod.z.object({
     op: zod.z.literal("sessions.list"),
@@ -702,6 +798,24 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
      */
     peerJournalSource: zod.z.boolean().optional()
   }).strict(),
+  // The inventory belongs to the backend, not to a renderer filesystem walk.
+  // Keep the cursor opaque: its query/revision binding is the service's decision.
+  zod.z.object({
+    op: zod.z.literal("sessions.files"),
+    sessionId,
+    scope: zod.z.enum(["family", "self"]).optional(),
+    kind: zod.z.string().max(256).optional(),
+    q: zod.z.string().max(256).optional(),
+    sort: zod.z.enum(["recent", "name", "kind", "modified", "created", "size"]).optional(),
+    order: zod.z.enum(["asc", "desc"]).optional(),
+    limit: zod.z.number().int().min(1).max(200).optional(),
+    cursor: zod.z.string().max(8192).optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("sessions.files.materialise"),
+    sessionId,
+    fileId: zod.z.string().regex(/^[a-f0-9]{16}$/)
+  }).strict(),
   zod.z.object({
     op: zod.z.literal("sessions.history"),
     sessionId,
@@ -1204,6 +1318,7 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     op: zod.z.literal("agent.publish"),
     agentId: id$1,
     document: publicationDocument.optional(),
+    ...publicationPolicyFields,
     /*
      * The publication TARGET (§4.4/§4.7). Both travel together or neither does,
      * and the rule is a `superRefine` on the whole UNION (below) rather than a
@@ -1235,11 +1350,20 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     // republish that did not name one would have to guess which public row to
     // overwrite — and guessing here overwrites somebody's listing.
     hubAgentId: id$1,
+    expectedRemoteRevision: zod.z.string().min(1).max(512).optional(),
     document: publicationDocument.optional(),
+    ...publicationPolicyFields,
     /** The publication target, on the same terms as `agent.publish` above. */
     visibility: zod.z.literal("org").optional(),
     tenantId: id$1.optional()
   }).strict(),
+  zod.z.object({
+    op: zod.z.literal("team.publish"),
+    teamId: id$1,
+    ...publicationPolicyFields,
+    visibility: zod.z.literal("org").optional(),
+    tenantId: id$1.optional()
+  }).strict(),
   /*
    * Pulling a published organization team into this machine's local registry
    * (§4.5/§8.4's "list + pull action").
@@ -1837,6 +1961,8 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
         "org_agents.list",
         "org_team.get",
         "org_teams.list",
+        "org_skills.list",
+        "org_skill.get",
         /*
          * The verification-email resend (core PR2,
          * `feat/quota-notice-resend`): it maps to the upstream's JWT-only
@@ -1854,6 +1980,7 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
       agent_id: id$1.optional(),
       comment_id: id$1.optional(),
       team_id: id$1.optional(),
+      skill_id: id$1.optional(),
       query: zod.z.record(zod.z.union([zod.z.string().max(1024), zod.z.number().int()])).optional(),
       payload: zod.z.record(zod.z.unknown()).optional(),
       confirmed: zod.z.boolean().optional()
@@ -1866,6 +1993,39 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     accountId: zod.z.number().int().positive(),
     confirmed: zod.z.literal(true)
   }).strict(),
+  /*
+   * PHONE ACCESS SETUP (`features.tunnel_setup`, local-operator
+   * `docs/DESKTOP_API.md` "Explicit phone setup"). Three ops over ONE route,
+   * split by authority so a caller cannot mutate by accident:
+   *
+   * - `tunnel.setup.read`: GET, local metadata only. No upstream read, no token
+   *   refresh, never `verified` and never a quote - the cheap poll that rebuilds
+   *   the block after a window close or a lost response.
+   * - `tunnel.setup.plan`: POST `{action:"plan"}`, a FRESH account/quote/
+   *   preparation observation that changes nothing.
+   * - `tunnel.setup.run`: POST `{action:"run"}`, the only op that can write. The
+   *   backend REFUSES it without an explicit owner (422), so `credentialId` is
+   *   required here rather than defaulted: an account is never picked for the
+   *   user. `acceptMonthlyPrice` is a STRING, the exact fresh amount the user
+   *   saw, because the backend compares it to a fresh quote and a number would
+   *   round-trip through float formatting.
+   *
+   * ONLY the capability gates these. An older backend 404s the route, so the
+   * renderer asks `features.tunnel_setup` first and sends nothing without it.
+   */
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.read"),
+    credentialId: zod.z.number().int().positive().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.plan"),
+    credentialId: zod.z.number().int().positive().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.run"),
+    credentialId: zod.z.number().int().positive(),
+    acceptMonthlyPrice: zod.z.string().min(1).max(64).optional()
+  }).strict(),
   zod.z.object({ op: zod.z.literal("auth.start"), provider: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("auth.status"), id: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("auth.input"), id: id$1, promptId: id$1, value: secret }).strict(),
@@ -2239,6 +2399,71 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
 ]);
 const desktopRequestSchema = desktopRequestUnion.superRefine(
   (request, ctx) => {
+    if (request.op === "hub.skillPull" || request.op === "hub.skillPublish") {
+      if (request.visibility === "public" && request.tenantId !== null || request.visibility === "org" && !request.tenantId) {
+        ctx.addIssue({
+          code: zod.z.ZodIssueCode.custom,
+          message: "A skill destination requires explicit paired scope",
+          path: ["tenantId"]
+        });
+        return;
+      }
+      if (request.op === "hub.skillPublish" && (request.dryRun ? request.previewReceipt !== void 0 || request.confirmPublish !== void 0 : !request.previewReceipt || request.confirmPublish !== true)) {
+        ctx.addIssue({
+          code: zod.z.ZodIssueCode.custom,
+          message: "An initial skill publication requires its reviewed draft receipt",
+          path: ["previewReceipt"]
+        });
+        return;
+      }
+    }
+    if (request.op === "hub.check" || request.op === "hub.apply" || request.op === "hub.retry") {
+      const hasLink = request.linkId !== void 0;
+      const hasLegacy = request.kind !== void 0 || request.name !== void 0;
+      if (hasLink && hasLegacy || request.op !== "hub.check" && !hasLink && (!request.kind || !request.name) || request.op === "hub.retry" && hasLink && !request.direction || request.direction === "push" && !hasLink) {
+        ctx.addIssue({
+          code: zod.z.ZodIssueCode.custom,
+          message: "A hub action requires one unambiguous selector and an explicit retry direction",
+          path: ["linkId"]
+        });
+        return;
+      }
+    }
+    if (request.op === "hub.apply" && (request.previewReceipt !== void 0 || request.confirmApply !== void 0) && (!request.linkId || request.dryRun || !request.previewReceipt || request.confirmApply !== true)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "A viewed incoming application requires its scoped preview receipt and confirmation",
+        path: ["previewReceipt"]
+      });
+      return;
+    }
+    if (request.op === "hub.apply" && request.resolveSource === true) {
+      const scopePaired = request.visibility === "public" && request.tenantId === null || request.visibility === "org" && typeof request.tenantId === "string" && request.tenantId.length > 0;
+      if (!request.hubSource || !scopePaired || request.acknowledgeUnknownBaseline !== true || request.linkId !== void 0 || request.previewReceipt !== void 0 || request.confirmApply !== void 0 || request.prefer !== void 0) {
+        ctx.addIssue({
+          code: zod.z.ZodIssueCode.custom,
+          message: "Confirming a source requires its exact stated destination and the unknown-baseline acknowledgement, with no link, preview or preference",
+          path: ["hubSource"]
+        });
+        return;
+      }
+    }
+    if (request.op === "hub.push" && (request.dryRun ? request.previewReceipt !== void 0 || request.confirmPublish !== void 0 : !request.previewReceipt || request.confirmPublish !== true)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "A confirmed publication requires its reviewed preview receipt",
+        path: ["previewReceipt"]
+      });
+      return;
+    }
+    if (request.op === "hub.policy" && request.subscribe === void 0 && request.autoPush === void 0) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "A hub policy change must name subscribe or autoPush",
+        path: ["subscribe"]
+      });
+      return;
+    }
     if (request.op === "sessions.answer") {
       if (request.askId !== void 0) {
         if (!request.askId)
@@ -2314,7 +2539,15 @@ const desktopRequestSchema = desktopRequestUnion.superRefine(
       }
       return;
     }
-    if (request.op !== "agent.publish" && request.op !== "agent.republish") {
+    if (request.op !== "agent.publish" && request.op !== "agent.republish" && request.op !== "team.publish") {
+      return;
+    }
+    if ((request.subscribe !== void 0 || request.autoPush !== void 0 || request.confirmPublicEgress !== void 0) && !request.requestId) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "Initial link policy needs a durable publication request ID",
+        path: ["requestId"]
+      });
       return;
     }
     if (Boolean(request.visibility === "org") !== Boolean(request.tenantId)) {
@@ -2373,6 +2606,44 @@ function desktopRefusalCodeForStatus(path2, status2) {
   if (status2 === 503) return DESKTOP_REFUSAL_CODE.planeClosed;
   return void 0;
 }
+zod.z.object({
+  step: zod.z.string(),
+  blocked_on: zod.z.string(),
+  configured: zod.z.boolean(),
+  ready: zod.z.boolean(),
+  verified: zod.z.boolean(),
+  url: zod.z.string().nullable(),
+  credential_id: zod.z.number().int().positive().nullable(),
+  identity_label: zod.z.string().nullable(),
+  credential_choices: zod.z.array(
+    zod.z.object({
+      id: zod.z.number().int().positive(),
+      identity_label: zod.z.string().nullable().optional()
+    }).passthrough()
+  ).default([]),
+  quote: zod.z.object({
+    monthly_price_usd: zod.z.string().nullable(),
+    positive_balance: zod.z.boolean(),
+    eligible: zod.z.boolean(),
+    account_valid: zod.z.boolean()
+  }).passthrough().nullable(),
+  receipts: zod.z.array(zod.z.object({ step: zod.z.string(), ok: zod.z.boolean(), text: zod.z.string() })).default([]),
+  remedy: zod.z.object({
+    kind: zod.z.string(),
+    text: zod.z.string(),
+    command: zod.z.string().nullable().optional(),
+    url: zod.z.string().nullable().optional()
+  }).nullable(),
+  source: zod.z.string(),
+  in_progress: zod.z.boolean().default(false),
+  progress: zod.z.array(zod.z.string()).default([]),
+  active_credential_id: zod.z.number().int().positive().nullable().default(null),
+  // Backend facts, separate from receipts: an emitted receipt does not prove
+  // an ambiguous activation succeeded or was rolled back.
+  billing_outcome: zod.z.string().optional(),
+  reservation_outcome: zod.z.string().optional(),
+  failure_stage: zod.z.string().optional()
+}).passthrough();
 const DESKTOP_MESSAGE_BYTE_BUDGET = 88e4;
 const DESKTOP_CONTROL_BYTE_BUDGET = 262144;
 const DESKTOP_SYSTEM_PROMPT_BYTE_BUDGET = 11e5;
@@ -2430,12 +2701,17 @@ function moveClientBoundMs(shape) {
 const PRESENCE_GESTURE_DEADLINE_MS = 18e4;
 const APPROVAL_APPROVE_DEADLINE_MS = PRESENCE_GESTURE_DEADLINE_MS + 15e3;
 const HUB_ITEM_MERGE_S = 120;
+const PHONE_SETUP_PLAN_DEADLINE_MS = 135e3;
+const PHONE_SETUP_RUN_DEADLINE_MS = 93e4;
 const HUB_ITEM_WRITE_DEADLINE_MS = (HUB_ITEM_MERGE_S + 30 + MOVE_CLIENT_MARGIN_S) * 1e3;
 const HUB_CHECK_DEADLINE_MS = 6e4;
 const HUB_APPLY_ALL_DEADLINE_MS = 5 * HUB_ITEM_WRITE_DEADLINE_MS;
 const HUB_WRITE_OPS = /* @__PURE__ */ new Set([
   "hub.apply",
   "hub.retry",
+  "hub.push",
+  "hub.skillPublish",
+  "hub.skillPull",
   "hub.check",
   "hub.applyAll"
 ]);
@@ -2443,6 +2719,9 @@ function hubWriteDeadlineMs(op) {
   switch (op) {
     case "hub.apply":
     case "hub.retry":
+    case "hub.push":
+    case "hub.skillPublish":
+    case "hub.skillPull":
       return HUB_ITEM_WRITE_DEADLINE_MS;
     case "hub.check":
       return HUB_CHECK_DEADLINE_MS;
@@ -2458,6 +2737,8 @@ function desktopRequestDeadlineMs(request) {
   }
   const op = typeof request === "string" ? request : request.op;
   if (op === "approvals.approve") return APPROVAL_APPROVE_DEADLINE_MS;
+  if (op === "tunnel.setup.run") return PHONE_SETUP_RUN_DEADLINE_MS;
+  if (op === "tunnel.setup.plan") return PHONE_SETUP_PLAN_DEADLINE_MS;
   const hub = hubWriteDeadlineMs(op);
   if (hub !== null) return hub;
   return LONG_READ_OPS.has(op) ? DESKTOP_LONG_READ_DEADLINE_MS : DESKTOP_CONTROL_DEADLINE_MS;
@@ -2475,6 +2756,7 @@ const READ_ONLY_OPS = /* @__PURE__ */ new Set([
   "config.get",
   "credentials.list",
   "hub.updates",
+  "hub.links",
   "info.get",
   "instructions.get",
   "legacy.agent.get",
@@ -2511,6 +2793,7 @@ const READ_ONLY_OPS = /* @__PURE__ */ new Set([
   "sessions.find",
   "sessions.get",
   "sessions.history",
+  "sessions.files",
   "sessions.list",
   "sessions.preview",
   "sessions.report",
@@ -2520,6 +2803,10 @@ const READ_ONLY_OPS = /* @__PURE__ */ new Set([
   "subagents.transcript",
   "teams.get",
   "teams.list",
+  // The two phone-setup observations change nothing on the server; `tunnel.setup.run`
+  // is deliberately absent so a run that ran out of time gets the cautious sentence.
+  "tunnel.setup.plan",
+  "tunnel.setup.read",
   "usage.get"
 ]);
 const PANEL_READ_OPS = /* @__PURE__ */ new Set([
@@ -2617,6 +2904,14 @@ function wakeTiming(request) {
     ...request.limit !== void 0 ? { limit: request.limit } : {}
   };
 }
+function publicationPolicyBody(request) {
+  return {
+    ...request.requestId ? { request_id: request.requestId } : {},
+    ...request.subscribe !== void 0 ? { subscribe: request.subscribe } : {},
+    ...request.autoPush !== void 0 ? { auto_push: request.autoPush } : {},
+    ...request.confirmPublicEgress !== void 0 ? { confirm_public_egress: request.confirmPublicEgress } : {}
+  };
+}
 function assertPairedPublicationTarget(request) {
   if (Boolean(request.visibility === "org") !== Boolean(request.tenantId)) {
     throw new Error(
@@ -2733,16 +3028,81 @@ function desktopEndpoint(request) {
       return {
         path: `/v1/desktop/profiles/${encodeURIComponent(request.name)}`,
         method: "PATCH",
-        body: { request_id: request.requestId, ...request.fields }
+        body: {
+          request_id: request.requestId,
+          ...request.fields,
+          /*
+           * The opaque echo travels ALONGSIDE the fields, never inside them: the
+           * edit body is `exclude_unset`-merged on the backend, so a revision
+           * nested in `fields` could be mistaken for an editable property. Sent
+           * only when present, so absence stays the legacy unconditional write.
+           */
+          ...request.expectedDefinitionRevision !== void 0 && request.expectedDefinitionRevision !== null ? {
+            expected_definition_revision: request.expectedDefinitionRevision
+          } : {}
+        }
       };
     case "hub.updates":
       return { path: "/v1/desktop/hub/updates", method: "GET" };
+    case "hub.skillPull":
+      return {
+        path: "/v1/desktop/hub/skills/pull",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          hub_id: request.hubId,
+          hub_source: request.hubSource,
+          visibility: request.visibility,
+          tenant_id: request.tenantId,
+          local_alias: request.localAlias,
+          ...request.subscribe !== void 0 ? { subscribe: request.subscribe } : {},
+          ...request.autoPush !== void 0 ? { auto_push: request.autoPush } : {},
+          ...request.confirmPublicEgress !== void 0 ? { confirm_public_egress: request.confirmPublicEgress } : {}
+        }
+      };
+    case "hub.skillPublish":
+      return {
+        path: "/v1/desktop/hub/skills/publish",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          dry_run: request.dryRun,
+          source_skill: request.sourceSkill,
+          local_alias: request.localAlias,
+          visibility: request.visibility,
+          tenant_id: request.tenantId,
+          subscribe: request.subscribe,
+          auto_push: request.autoPush,
+          confirm_public_egress: request.confirmPublicEgress,
+          ...request.previewReceipt ? { preview_receipt: request.previewReceipt } : {},
+          ...request.confirmPublish ? { confirm_publish: true } : {}
+        }
+      };
+    case "hub.links":
+      return {
+        path: `/v1/desktop/hub/links${request.kind ? `?kind=${request.kind}` : ""}`,
+        method: "GET"
+      };
+    case "hub.policy":
+      return {
+        path: `/v1/desktop/hub/links/${encodeURIComponent(request.linkId)}`,
+        method: "PATCH",
+        body: {
+          request_id: request.requestId,
+          expected_policy_revision: request.expectedPolicyRevision,
+          ...request.subscribe !== void 0 ? { subscribe: request.subscribe } : {},
+          ...request.autoPush !== void 0 ? { auto_push: request.autoPush } : {},
+          ...request.confirmPublicEgress !== void 0 ? { confirm_public_egress: request.confirmPublicEgress } : {}
+        }
+      };
     case "hub.check":
       return {
         path: "/v1/desktop/hub/updates/check",
         method: "POST",
         body: {
           request_id: request.requestId,
+          ...request.linkId ? { link_id: request.linkId } : {},
+          ...request.direction ? { direction: request.direction } : {},
           ...request.kind ? { kind: request.kind } : {},
           ...request.name ? { name: request.name } : {}
         }
@@ -2753,13 +3113,30 @@ function desktopEndpoint(request) {
         method: "POST",
         body: {
           request_id: request.requestId,
-          kind: request.kind,
-          name: request.name,
+          ...request.previewReceipt ? { preview_receipt: request.previewReceipt } : {},
+          ...request.confirmApply ? { confirm_apply: true } : {},
+          ...request.linkId ? { link_id: request.linkId } : {},
+          ...request.direction ? { direction: request.direction } : {},
+          ...request.kind ? { kind: request.kind } : {},
+          ...request.name ? { name: request.name } : {},
           ...request.prefer ? { prefer: request.prefer } : {},
           ...request.acknowledgeUnknownBaseline !== void 0 ? {
             acknowledge_unknown_baseline: request.acknowledgeUnknownBaseline
           } : {},
-          ...request.dryRun !== void 0 ? { dry_run: request.dryRun } : {}
+          ...request.dryRun !== void 0 ? { dry_run: request.dryRun } : {},
+          /*
+           * The source-confirmation branch travels on the SAME apply route with an
+           * explicit flag, never a new endpoint. `resolve_source:true` plus the
+           * stated scope triple is the whole act; the service materializes the
+           * real identity/link and preserves any known scope (refusing a conflict
+           * with `origin-conflict`), so nothing here infers Public or an org.
+           */
+          ...request.resolveSource === true ? {
+            resolve_source: true,
+            hub_source: request.hubSource,
+            visibility: request.visibility,
+            tenant_id: request.tenantId ?? null
+          } : {}
         }
       };
     case "hub.applyAll":
@@ -2777,8 +3154,23 @@ function desktopEndpoint(request) {
         method: "POST",
         body: {
           request_id: request.requestId,
-          kind: request.kind,
-          name: request.name
+          ...request.linkId ? { link_id: request.linkId } : {},
+          ...request.direction ? { direction: request.direction } : {},
+          ...request.kind ? { kind: request.kind } : {},
+          ...request.name ? { name: request.name } : {}
+        }
+      };
+    case "hub.push":
+      return {
+        path: "/v1/desktop/hub/updates/push",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          link_id: request.linkId,
+          direction: request.direction,
+          dry_run: request.dryRun,
+          ...request.previewReceipt ? { preview_receipt: request.previewReceipt } : {},
+          ...request.confirmPublish ? { confirm_publish: true } : {}
         }
       };
     case "teams.list":
@@ -2798,7 +3190,14 @@ function desktopEndpoint(request) {
       return {
         path: `/v1/desktop/teams/${encodeURIComponent(request.name)}`,
         method: "PATCH",
-        body: { request_id: request.requestId, ...request.fields }
+        body: {
+          request_id: request.requestId,
+          ...request.fields,
+          /* Opaque echo beside the fields; absent/null = legacy unconditional. */
+          ...request.expectedDefinitionRevision !== void 0 && request.expectedDefinitionRevision !== null ? {
+            expected_definition_revision: request.expectedDefinitionRevision
+          } : {}
+        }
       };
     case "sessions.list": {
       const params = new URLSearchParams();
@@ -2927,6 +3326,31 @@ function desktopEndpoint(request) {
         method: "GET"
       };
     }
+    case "sessions.files": {
+      const query = new URLSearchParams({
+        limit: String(request.limit ?? 200)
+      });
+      for (const key of [
+        "scope",
+        "kind",
+        "q",
+        "sort",
+        "order",
+        "cursor"
+      ]) {
+        const value = request[key];
+        if (value !== void 0) query.set(key, value);
+      }
+      return {
+        path: `/v1/desktop/sessions/${encodeURIComponent(request.sessionId)}/files?${query}`,
+        method: "GET"
+      };
+    }
+    case "sessions.files.materialise":
+      return {
+        path: `/v1/desktop/sessions/${encodeURIComponent(request.sessionId)}/files/${encodeURIComponent(request.fileId)}/materialise`,
+        method: "POST"
+      };
     case "sessions.history": {
       const query = new URLSearchParams({
         limit: String(request.limit ?? 100)
@@ -3241,7 +3665,10 @@ function desktopEndpoint(request) {
         // there is no override, because the route's input model forbids extras
         // and still wants a JSON OBJECT — an omitted body makes a legal call
         // answer 422.
-        body: { document: request.document ?? {} }
+        body: {
+          document: request.document ?? {},
+          ...publicationPolicyBody(request)
+        }
       };
     }
     case "agent.republish": {
@@ -3257,10 +3684,25 @@ function desktopEndpoint(request) {
         method: "PUT",
         body: {
           hub_agent_id: request.hubAgentId,
-          document: request.document ?? {}
+          document: request.document ?? {},
+          ...publicationPolicyBody(request),
+          ...request.expectedRemoteRevision ? { expected_remote_revision: request.expectedRemoteRevision } : {}
         }
       };
     }
+    case "team.publish": {
+      assertPairedPublicationTarget(request);
+      const query = new URLSearchParams();
+      if (request.visibility === "org" && request.tenantId) {
+        query.set("visibility", "org");
+        query.set("tenant_id", request.tenantId);
+      }
+      return {
+        path: `/v1/teams/${request.teamId}/publish${query.size ? `?${query}` : ""}`,
+        method: "POST",
+        body: publicationPolicyBody(request)
+      };
+    }
     case "team.pull": {
       const query = new URLSearchParams();
       if (request.tenantId) query.set("tenant_id", request.tenantId);
@@ -3660,6 +4102,30 @@ function desktopEndpoint(request) {
         path: `/v1/auth/accounts/${request.accountId}`,
         method: "DELETE"
       };
+    case "tunnel.setup.read":
+      return {
+        path: request.credentialId === void 0 ? "/v1/desktop/tunnel/setup" : `/v1/desktop/tunnel/setup?credential_id=${request.credentialId}`,
+        method: "GET"
+      };
+    case "tunnel.setup.plan":
+      return {
+        path: "/v1/desktop/tunnel/setup",
+        method: "POST",
+        body: {
+          action: "plan",
+          ...request.credentialId !== void 0 ? { credential_id: request.credentialId } : {}
+        }
+      };
+    case "tunnel.setup.run":
+      return {
+        path: "/v1/desktop/tunnel/setup",
+        method: "POST",
+        body: {
+          action: "run",
+          credential_id: request.credentialId,
+          ...request.acceptMonthlyPrice !== void 0 ? { accept_monthly_price: request.acceptMonthlyPrice } : {}
+        }
+      };
     case "auth.start":
       return {
         path: "/v1/auth/login",
@@ -13252,6 +13718,11 @@ function describeWindowLaunch(plan, platform = process.platform) {
   const suffix = extras.length === 0 ? "" : `, ${extras.join(", ")}`;
   return `window mode ${plan.mode}: ${plan.width}x${plan.height}, ${behaviour}, page throttling ${plan.backgroundThrottling ? "on" : "off"}${suffix}${assumption}`;
 }
+function focusBrowserChordTarget(window, target2, show) {
+  if (show !== "focus" || window.isDestroyed() || !window.isFocused() || target2.isDestroyed())
+    return;
+  target2.focus();
+}
 const MODE_OF_SHOW = {
   focus: "normal",
   inactive: "inactive",
@@ -14766,6 +15237,38 @@ ${result.stdout}`,
     });
   }
 }
+const DIGIT_KEY$1 = /^[1-9]$/;
+const DIGIT_CODE = /^Digit([1-9])$/;
+function browserChordIntent(input, platform) {
+  if (input.type !== "keyDown" || input.alt || input.isComposing) return null;
+  const key = input.key.toLowerCase();
+  let intent = null;
+  if (key === "tab" && input.control && !input.meta) {
+    intent = input.shift ? "prev-tab" : "next-tab";
+  } else {
+    const primary = platform === "darwin" ? input.meta && !input.control : input.control && !input.meta;
+    if (!primary) return null;
+    if (key === "+" || key === "=") intent = "zoom-in";
+    else if (key === "-" && !input.shift) intent = "zoom-out";
+    else if (key === "0" && !input.shift) intent = "zoom-reset";
+    else if (platform === "darwin" && input.shift && ["[", "]", "{", "}"].includes(key)) {
+      intent = key === "[" || key === "{" ? "prev-tab" : "next-tab";
+    } else if (key === "r") intent = input.shift ? "hard-reload" : "reload";
+    else if (key === "t") intent = input.shift ? "reopen-tab" : "new-tab";
+    else if (!input.shift) {
+      if (key === "f") intent = "find-page";
+      else if (key === "l") intent = "focus-address";
+      else if (key === "w") intent = "close-tab";
+      else if (key === "[") intent = "back";
+      else if (key === "]") intent = "forward";
+      else {
+        const digit = DIGIT_KEY$1.test(key) ? key : DIGIT_CODE.exec(input.code ?? "")?.[1];
+        if (digit) intent = `tab-${digit}`;
+      }
+    }
+  }
+  return input.isAutoRepeat && intent !== "next-tab" && intent !== "prev-tab" ? null : intent;
+}
 const CONSOLE_METHODS = [
   "console_list",
   "console_resources",
@@ -27844,6 +28347,53 @@ class ApprovalStore {
     );
   }
 }
+function runBrowserMenuAction(intent, target2, owner, route) {
+  if (!target2) return;
+  if (target2 === owner && route(intent)) return;
+  if (intent === "reload") target2.webContents?.reload();
+  else if (intent === "hard-reload") target2.webContents?.reloadIgnoringCache();
+  else target2.close();
+}
+function createBrowserChordRouter(options) {
+  function dispatch(intent, origin) {
+    if (intent === "reload" || intent === "hard-reload")
+      options.reload(intent === "hard-reload");
+    else if (intent === "back" || intent === "forward") options.history(intent);
+    else if (intent.startsWith("zoom-") && options.zoom) {
+      options.zoom(
+        intent === "zoom-in" ? "in" : intent === "zoom-out" ? "out" : "reset"
+      );
+    } else {
+      options.focusChrome();
+      options.send({ intent, origin });
+    }
+  }
+  return {
+    input(event, input, origin, owns) {
+      const intent = owns ? browserChordIntent(input, options.platform) : null;
+      if (!intent) {
+        const rejected = owns && input.type === "keyDown" && (input.isAutoRepeat || input.isComposing) && browserChordIntent(
+          { ...input, isAutoRepeat: false, isComposing: false },
+          options.platform
+        );
+        if (rejected) {
+          event.preventDefault();
+          return true;
+        }
+        return false;
+      }
+      event.preventDefault();
+      dispatch(intent, origin);
+      return true;
+    },
+    menu(intent) {
+      const page = options.ownsPage();
+      if (!page && !options.ownsChrome()) return false;
+      dispatch(intent, page ? "page" : "chrome");
+      return true;
+    }
+  };
+}
 const MAX_ENTRIES = 200;
 const MAX_BYTES = 256 * 1024;
 const MAX_ARG_CHARS = 2e3;
@@ -30881,6 +31431,168 @@ function factOf(path2) {
     sha256: ""
   };
 }
+const PAGE_ZOOM_STEPS = [
+  0.25,
+  0.33,
+  0.5,
+  0.67,
+  0.75,
+  0.8,
+  0.9,
+  1,
+  1.1,
+  1.25,
+  1.5,
+  1.75,
+  2,
+  2.5,
+  3,
+  4,
+  5
+];
+class PageControls {
+  constructor(changed, resultTimeoutMs = 5e3) {
+    this.changed = changed;
+    this.resultTimeoutMs = resultTimeoutMs;
+  }
+  find = null;
+  record = null;
+  epoch = -1;
+  requestId = null;
+  listener = null;
+  notice = null;
+  noticeTabId = null;
+  timer = null;
+  stopTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  reconcile(active) {
+    if (this.record && (active !== this.record || !active.presented || active.documentEpoch !== this.epoch || active.view.webContents.isDestroyed()))
+      this.clear();
+  }
+  state(active) {
+    this.reconcile(active);
+    if (active?.tabId !== this.noticeTabId || !active?.presented)
+      this.notice = null;
+    return {
+      find: this.find ? { ...this.find } : null,
+      zoom: active?.view.webContents.getZoomFactor?.() ?? 1,
+      zoomAllowed: active?.owner === "user" && !active.handedTo,
+      notice: this.notice
+    };
+  }
+  clear() {
+    this.stopTimer();
+    const old = this.record;
+    const listener = this.listener;
+    this.record = null;
+    this.find = null;
+    this.requestId = null;
+    this.listener = null;
+    if (old && listener)
+      old.view.webContents.removeListener("found-in-page", listener);
+    if (old && !old.view.webContents.isDestroyed())
+      old.view.webContents.stopFindInPage?.("clearSelection");
+  }
+  open(active) {
+    this.reconcile(active);
+    if (!active.presented) return;
+    if (this.record === active) return;
+    this.clear();
+    this.record = active;
+    this.epoch = active.documentEpoch;
+    this.find = {
+      tabId: active.tabId,
+      query: "",
+      ordinal: 0,
+      matches: 0,
+      pending: false,
+      unreported: false
+    };
+    this.listener = (_event, result) => {
+      if (this.record !== active || !active.presented || active.documentEpoch !== this.epoch || result.requestId !== this.requestId || !this.find)
+        return;
+      if (result.finalUpdate !== false) this.stopTimer();
+      this.find = {
+        ...this.find,
+        unreported: false,
+        ordinal: result.activeMatchOrdinal,
+        matches: result.matches,
+        pending: result.finalUpdate === false
+      };
+      this.changed();
+    };
+    active.view.webContents.on("found-in-page", this.listener);
+  }
+  search(active, query, forward, next) {
+    this.open(active);
+    if (!this.find || this.record !== active) return;
+    this.stopTimer();
+    const same = this.find.query === query;
+    const continuing = same && next && this.requestId !== null && !this.find.unreported;
+    this.requestId = null;
+    this.find = {
+      ...this.find,
+      query,
+      pending: query.length > 0,
+      unreported: false,
+      ...same ? {} : { ordinal: 0, matches: 0 }
+    };
+    if (!query) {
+      active.view.webContents.stopFindInPage?.("clearSelection");
+      return;
+    }
+    this.requestId = active.view.webContents.findInPage?.(query, {
+      forward,
+      // Electron's misleading name means NEW SESSION (44.3 native maps
+      // it to options->new_session), not "advance". Initial/changed/retry
+      // must be true; an existing query's next/previous must be false.
+      findNext: !continuing
+    }) ?? null;
+    const request = this.requestId;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (this.record !== active || !active.presented || active.documentEpoch !== this.epoch || this.requestId !== request || !this.find)
+        return;
+      this.requestId = null;
+      if (active.view.webContents.isDestroyed()) {
+        this.clear();
+        this.changed();
+        return;
+      }
+      active.view.webContents.stopFindInPage?.("clearSelection");
+      this.find = {
+        ...this.find,
+        pending: false,
+        unreported: true,
+        ordinal: 0,
+        matches: 0
+      };
+      this.changed();
+    }, this.resultTimeoutMs);
+    this.timer.unref?.();
+  }
+  zoom(active, command) {
+    if (active.owner !== "user" || active.handedTo) {
+      this.notice = "Zoom is off for tabs an agent is driving";
+      this.noticeTabId = active.tabId;
+      return;
+    }
+    this.notice = null;
+    const current = active.view.webContents.getZoomFactor?.() ?? 1;
+    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);
+  }
+  /** Call BEFORE a capability transfer. Isolated per-WebContents zoom means
+   * resetting this tab cannot alter another tab at the same origin. */
+  prepareAgent(record) {
+    const changed = this.record === record || (record.view.webContents.getZoomFactor?.() ?? 1) !== 1;
+    if (this.record === record) this.clear();
+    record.view.webContents.setZoomFactor?.(1);
+    if (changed) this.changed();
+  }
+}
 const DOCUMENT_SCOPED = /* @__PURE__ */ new Set([
   "read",
   // The structured reads (`styles`, `hit_test`, `ancestors`) describe the
@@ -30967,6 +31679,7 @@ function sessionRequesterOf(requester) {
 }
 class BrowserHost {
   registry;
+  pageControls;
   cdp;
   approvals;
   ownership;
@@ -30991,6 +31704,7 @@ class BrowserHost {
   hydration = Promise.resolve();
   constructor(options) {
     this.registry = options.registry;
+    this.pageControls = new PageControls(() => this.onChanged());
     this.cdp = options.cdp;
     this.approvals = options.approvals;
     this.ownership = options.ownership;
@@ -31014,6 +31728,10 @@ class BrowserHost {
     return run();
   }
   async authorizedPerform(method, params, requestId2) {
+    if (typeof params.tab === "string" && TAB_SCOPED.has(method)) {
+      const record2 = this.registry.requireSurface(params.tab);
+      this.pageControls.prepareAgent(record2);
+    }
     if (!DOCUMENT_SCOPED.has(method))
       return this.perform(method, params, requestId2);
     const token = String(params.tab ?? "");
@@ -31272,6 +31990,7 @@ class BrowserHost {
     const active = activeRecord && !activeRecord.view.webContents.isDestroyed() ? activeRecord : null;
     const navigation = active?.view.webContents.navigationHistory;
     return {
+      pageControls: this.pageControls.state(active),
       tabs: this.registry.snapshot().map((entry) => ({
         tabId: entry.tabId,
         title: this.titleForChrome(entry.title) || "New tab",
@@ -31389,16 +32108,94 @@ class BrowserHost {
    * one field.
    */
   async newTab(sessionId2) {
+    await this.createUserTab(sessionId2 ?? null);
+    return this.chromeState();
+  }
+  /** `newTab`'s body, returning the record so `reopenClosed` can navigate the tab
+   * it created rather than whichever tab is active by the time the await ends. */
+  async createUserTab(sessionId2) {
     const record = this.registry.create({
       owner: "user",
-      sessionId: sessionId2 ?? null
+      sessionId: sessionId2
     });
     await record.view.webContents.loadURL("about:blank");
     await this.cdp.attach(record.view.webContents);
     this.onChanged();
+    return record;
+  }
+  /** Main owns this short-lived UI focus fact; it conveys no page capability. */
+  chordFocus = false;
+  onChordFocusChanged;
+  /** An explicit tab id fences queued chrome intents: a switch between key
+   * delivery and IPC must never search/zoom the newly active tab instead. */
+  async controlPage(tabId, action, query = "", forward = true, next = false) {
+    return this.registry.lane(tabId, async () => {
+      const active = this.registry.activeTab;
+      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 === "close") this.pageControls.clear();
+      else if (action === "search")
+        this.pageControls.search(active, query, forward, next);
+      else this.pageControls.zoom(active, action);
+      this.onChanged();
+      return this.chromeState();
+    });
+  }
+  setChordFocus(focused) {
+    this.chordFocus = focused;
+    this.onChordFocusChanged?.(focused);
+  }
+  /** Only user URLs survive a close, never a capability, page state or nonce.
+   * Conversation attribution is retained only to find the appropriate scope. */
+  closedUserTabs = [];
+  rememberClosed(tabId) {
+    const record = this.registry.get(tabId);
+    if (!record || record.owner !== "user" || record.handedTo !== null) return;
+    const url = record.view.webContents.getURL();
+    try {
+      if (!permittedScheme(new URL(url))) return;
+    } catch {
+      return;
+    }
+    this.closedUserTabs.push({ url, sessionId: record.homeSessionId });
+    if (this.closedUserTabs.length > 10) this.closedUserTabs.shift();
+  }
+  clearChordState() {
+    this.pageControls.clear();
+    this.setChordFocus(false);
+    this.closedUserTabs = [];
+  }
+  /**
+   * Forget remembered closes. Called when the user clears browsing data or forgets
+   * a site, because a closed tab's URL can carry a one-time token or name a page
+   * the user just asked this app to erase: Cmd+Shift+T must not resurrect it
+   * (review R3). `origin` filters to one site; omitted forgets every entry. Clearing
+   * only cookies or only the cache leaves the stack alone: neither erases what the
+   * user visited, and a logged-out reopen simply lands on the site's own login.
+   */
+  forgetClosedTabs(origin) {
+    this.closedUserTabs = origin ? this.closedUserTabs.filter((entry) => {
+      try {
+        return new URL(entry.url).origin !== origin;
+      } catch {
+        return false;
+      }
+    }) : [];
+  }
+  async reopenClosed(sessionId2) {
+    const index = this.closedUserTabs.findLastIndex(
+      (entry2) => sessionId2 === null || entry2.sessionId === sessionId2
+    );
+    if (index < 0) return this.chromeState();
+    const [entry] = this.closedUserTabs.splice(index, 1);
+    const record = await this.createUserTab(sessionId2 ?? entry.sessionId);
+    await record.view.webContents.loadURL(entry.url);
+    this.onChanged();
     return this.chromeState();
   }
   closeTab(tabId) {
+    this.rememberClosed(tabId);
     this.dropReceipt(tabId);
     this.loadFailures.delete(tabId);
     this.registry.destroy(tabId);
@@ -31425,6 +32222,7 @@ class BrowserHost {
   closeTabs(intent) {
     const tabIds = intent.mode === "ids" ? intent.tabIds : this.registry.list().filter((record) => record.sessionId === intent.sessionId).map((record) => record.tabId);
     for (const tabId of tabIds) {
+      this.rememberClosed(tabId);
       this.dropReceipt(tabId);
       this.loadFailures.delete(tabId);
     }
@@ -31689,8 +32487,10 @@ class BrowserHost {
     this.onChanged();
     return this.chromeState();
   }
-  reloadActive() {
-    this.registry.activeTab?.view.webContents.reload();
+  reloadActive(hard = false) {
+    const contents = this.registry.activeTab?.view.webContents;
+    if (hard && contents?.reloadIgnoringCache) contents.reloadIgnoringCache();
+    else contents?.reload();
     return this.chromeState();
   }
   stopActive() {
@@ -31721,6 +32521,8 @@ class BrowserHost {
    * sees the nonce: it travels to the session through `tabs`, which is what keeps
    * this the one authority transfer rather than an exposure (design 6.3, 11.7). */
   handOver(tabId, sessionId2) {
+    const record = this.registry.get(tabId);
+    if (record) this.pageControls.prepareAgent(record);
     this.dropReceipt(tabId);
     this.registry.handOver(tabId, sessionId2);
     this.onChanged();
@@ -31784,6 +32586,7 @@ class BrowserHost {
     const origin = safeHttpUrl(rawOrigin).origin;
     const removed = this.approvals.revokeOrigin(origin);
     await this.forgetSiteData(origin);
+    this.forgetClosedTabs(origin);
     this.log(`[browser] forgot ${origin}: ${removed} approval(s) revoked`);
     this.onChanged();
     return { origin, removed, ...this.chromeState() };
@@ -32624,6 +33427,10 @@ async function startWithRetries(options) {
 }
 const BROWSER_IPC_CHANNELS = [
   "browser-state",
+  "browser-set-chord-focus",
+  "browser-page-control",
+  "browser-reopen-tab",
+  "browser-focus-page",
   "browser-new-tab",
   "browser-close-tab",
   "browser-close-tabs",
@@ -32713,7 +33520,43 @@ function registerBrowserIpc(options) {
     }
     return host.navigateActive(url.trim());
   });
-  electron.ipcMain.handle("browser-reload", (event) => authorize(event).reloadActive());
+  electron.ipcMain.handle(
+    "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))
+        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.");
+      return host.controlPage(
+        numberOrThrow(tabId, "tabId"),
+        action,
+        query,
+        forward,
+        next
+      );
+    }
+  );
+  electron.ipcMain.handle("browser-set-chord-focus", (event, focused) => {
+    const host = authorize(event);
+    if (typeof focused !== "boolean")
+      throw new Error("Browser focus must be a boolean.");
+    host.setChordFocus(focused);
+  });
+  electron.ipcMain.handle(
+    "browser-reopen-tab",
+    (event, sessionId2) => authorize(event).reopenClosed(optionalConversationOrThrow(sessionId2))
+  );
+  electron.ipcMain.handle("browser-focus-page", (event) => {
+    authorize(event);
+    options.focusPage?.();
+  });
+  electron.ipcMain.handle("browser-reload", (event, hard) => {
+    const host = authorize(event);
+    if (hard !== void 0 && typeof hard !== "boolean")
+      throw new Error("Hard reload must be a boolean.");
+    return host.reloadActive(hard === true);
+  });
   electron.ipcMain.handle("browser-stop", (event) => authorize(event).stopActive());
   electron.ipcMain.handle("browser-history", (event, direction) => {
     const host = authorize(event);
@@ -32798,11 +33641,12 @@ function registerBrowserIpc(options) {
     return host.forgetSite(origin.trim());
   });
   electron.ipcMain.handle("browser-clear-data", async (event, what) => {
-    authorize(event);
+    const host = authorize(event);
     if (what !== "cookies" && what !== "cache" && what !== "everything") {
       throw new Error("Unsupported clear-data request.");
     }
     await options.clearData(what);
+    if (what === "everything") host.forgetClosedTabs();
     options.log(`[browser] cleared browsing data: ${what}`);
     return { cleared: what };
   });
@@ -34595,6 +35439,22 @@ function refusesNavigation(rawUrl) {
   }
 }
 let activeHost = null;
+function routeBrowserZoomInput(event, input) {
+  const candidate = browserChordIntent(
+    { ...input, isAutoRepeat: false, isComposing: false },
+    process.platform
+  );
+  if (!candidate?.startsWith("zoom-") || !activeHost) return false;
+  return activeHost.chords.input(
+    event,
+    input,
+    "chrome",
+    activeHost.host.chordFocus
+  );
+}
+function routeBrowserMenu(intent) {
+  return activeHost?.chords.menu(intent) ?? false;
+}
 let stopping = null;
 function browserHostStopPending() {
   return activeHost !== null || stopping !== null || starting !== null;
@@ -34662,6 +35522,12 @@ function startBrowserHost(options) {
     expectedUrl: options.expectedUrl,
     host: () => bindings.host?.() ?? null,
     webauthn: () => bindings.webauthn?.() ?? null,
+    focusPage: () => {
+      const record = bindings.host?.()?.registry.activeTab;
+      const target2 = record?.presented ? electron.webContents.fromId(record.view.webContents.id) : null;
+      if (target2)
+        focusBrowserChordTarget(options.window, target2, options.windowShow);
+    },
     availability: () => availability,
     clearData: async (what) => {
       if (!bindings.clearData)
@@ -34741,6 +35607,8 @@ async function initializeBrowserHost(options, bindings) {
           // No `preload`: a driven page has no bridge to anything.
         }
       });
+      view.webContents.setZoomMode("isolated");
+      view.webContents.setZoomFactor(1);
       window.contentView.addChildView(view);
       view.setBounds(BACKGROUND_VIEWPORT);
       view.setVisible(false);
@@ -34818,10 +35686,10 @@ async function initializeBrowserHost(options, bindings) {
       contents.on("will-navigate", onWillNavigate);
       contents.on("will-redirect", onWillNavigate);
       contents.on("before-input-event", (event, input) => {
-        const direction = paneNavigationDirection(input);
-        if (!direction) return;
-        event.preventDefault();
-        host.historyActive(direction);
+        const record = registry.get(tabId);
+        const owns = record === registry.activeTab && record?.presented === true;
+        const handled = chords.input(event, input, "page", owns);
+        contents.setIgnoreMenuShortcuts(handled);
       });
       const notifyChrome = () => {
         options.window.webContents.send("browser-state-changed");
@@ -35125,6 +35993,75 @@ async function initializeBrowserHost(options, bindings) {
       facts: () => facts,
       forgetSiteData: (origin) => clearOriginData(browserSession, origin)
     });
+    const chords = createBrowserChordRouter({
+      platform: process.platform,
+      ownsChrome: () => host.chordFocus,
+      ownsPage: () => {
+        const record = registry.activeTab;
+        return Boolean(
+          record?.presented && electron.webContents.getFocusedWebContents()?.id === record.view.webContents.id
+        );
+      },
+      reload: (hard) => {
+        host.reloadActive(hard);
+      },
+      zoom: (command) => {
+        const tabId = registry.activeTab?.tabId;
+        if (tabId !== void 0)
+          void host.controlPage(tabId, command).catch(
+            (error) => log2(
+              `Page zoom refused: ${error instanceof Error ? error.message : "unavailable"}`
+            )
+          );
+      },
+      history: (direction) => {
+        host.historyActive(direction);
+      },
+      send: (message) => options.window.webContents.send("browser-chord", message),
+      focusChrome: () => focusBrowserChordTarget(
+        options.window,
+        options.window.webContents,
+        options.windowShow
+      )
+    });
+    const onChromeInput = (event, input) => {
+      if (event.defaultPrevented) return;
+      const handled = chords.input(event, input, "chrome", host.chordFocus);
+      options.window.webContents.setIgnoreMenuShortcuts(handled);
+    };
+    const resetChordFocus = () => {
+      host.setChordFocus(false);
+    };
+    host.onChordFocusChanged = (focused) => {
+      if (!focused && !options.window.webContents.isDestroyed())
+        options.window.webContents.setIgnoreMenuShortcuts(false);
+    };
+    options.window.webContents.on("before-input-event", onChromeInput);
+    options.window.on("blur", resetChordFocus);
+    options.window.on("closed", resetChordFocus);
+    const resetOnNavigation = (details) => {
+      if (details.isMainFrame && !details.isSameDocument) resetChordFocus();
+    };
+    options.window.webContents.on("did-start-navigation", resetOnNavigation);
+    options.window.webContents.on("render-process-gone", resetChordFocus);
+    const detachChords = () => {
+      host.clearChordState();
+      options.window.webContents.removeListener(
+        "before-input-event",
+        onChromeInput
+      );
+      options.window.removeListener("blur", resetChordFocus);
+      options.window.removeListener("closed", resetChordFocus);
+      options.window.webContents.removeListener(
+        "did-start-navigation",
+        resetOnNavigation
+      );
+      options.window.webContents.removeListener(
+        "render-process-gone",
+        resetChordFocus
+      );
+    };
+    rollback.add(detachChords);
     const recorded = readSession(sessionStore.filePath, log2);
     host.restoreTabs(recorded);
     if (recorded.length) {
@@ -35240,12 +36177,14 @@ async function initializeBrowserHost(options, bindings) {
       `[browser] host on ${server.address}:${server.port} (proto ${facts.proto}), profile ${profileDir || "(in-memory)"}, agent tabs ${registry.agentTabCount()}/${8}, console ${consoleStartup.ok ? `on (${consoleStartup.counts().total} surface(s))` : `off (${consoleStartup.reason})`}`
     );
     const handle2 = {
+      chords,
       host,
       port: server.port,
       profileDir,
       agentTabs: () => registry.agentTabCount(),
       sessionCookies: () => restoreReport,
       stop: async () => {
+        detachChords();
         const atStop = captureTabs(
           registry.list(),
           registry.activeTab?.tabId ?? null,
@@ -45492,25 +46431,6 @@ function configureAboutPanel() {
 }
 function createApplicationMenu() {
   const isDev = Boolean(process.env.ELECTRON_RENDERER_URL);
-  const zoomInHandler = () => {
-    if (mainWindow) {
-      const webContents2 = mainWindow.webContents;
-      const currentZoom = webContents2.getZoomFactor();
-      webContents2.setZoomFactor(currentZoom + 0.1);
-    }
-  };
-  const zoomOutHandler = () => {
-    if (mainWindow) {
-      const webContents2 = mainWindow.webContents;
-      const currentZoom = webContents2.getZoomFactor();
-      webContents2.setZoomFactor(currentZoom - 0.1);
-    }
-  };
-  const actualSizeHandler = () => {
-    if (mainWindow) {
-      mainWindow.webContents.setZoomFactor(1);
-    }
-  };
   const template = [
     {
       label: "File",
@@ -45534,29 +46454,62 @@ function createApplicationMenu() {
       label: "View",
       submenu: [
         {
-          role: "reload",
-          accelerator: "CmdOrCtrl+R"
+          id: "app-reload",
+          label: "Reload",
+          accelerator: "CmdOrCtrl+R",
+          click: (_item, target2) => runBrowserMenuAction(
+            "reload",
+            target2,
+            mainWindow,
+            routeBrowserMenu
+          )
         },
         {
-          role: "forceReload",
-          accelerator: "CmdOrCtrl+Shift+R"
+          id: "app-force-reload",
+          label: "Force Reload",
+          accelerator: "CmdOrCtrl+Shift+R",
+          click: (_item, target2) => runBrowserMenuAction(
+            "hard-reload",
+            target2,
+            mainWindow,
+            routeBrowserMenu
+          )
         },
         { type: "separator" },
         {
+          id: "app-actual-size",
           label: "Actual Size",
-          accelerator: "CmdOrCtrl+O",
-          click: actualSizeHandler
+          accelerator: "CmdOrCtrl+0",
+          click: (_item, target2) => {
+            if (!(target2 instanceof electron.BrowserWindow)) return;
+            if (target2 === mainWindow && routeBrowserMenu("zoom-reset")) return;
+            target2.webContents.setZoomFactor(1);
+          }
         },
         {
+          id: "app-zoom-in",
           label: "Zoom In",
           accelerator: "CmdOrCtrl+Plus",
           // On macOS, this often requires Shift as well (Cmd+Shift+=)
-          click: zoomInHandler
+          click: (_item, target2) => {
+            if (!(target2 instanceof electron.BrowserWindow)) return;
+            if (target2 === mainWindow && routeBrowserMenu("zoom-in")) return;
+            target2.webContents.setZoomFactor(
+              target2.webContents.getZoomFactor() + 0.1
+            );
+          }
         },
         {
+          id: "app-zoom-out",
           label: "Zoom Out",
           accelerator: "CmdOrCtrl+-",
-          click: zoomOutHandler
+          click: (_item, target2) => {
+            if (!(target2 instanceof electron.BrowserWindow)) return;
+            if (target2 === mainWindow && routeBrowserMenu("zoom-out")) return;
+            target2.webContents.setZoomFactor(
+              target2.webContents.getZoomFactor() - 0.1
+            );
+          }
         },
         { type: "separator" },
         { role: "togglefullscreen" }
@@ -45582,10 +46535,40 @@ function createApplicationMenu() {
            * `window-all-closed` path the red button takes, which is the one
            * this change made safe for an install in flight.
            */
-          { role: "close" },
+          {
+            id: "app-close",
+            // One honest label for both owners: the SAME accelerator closes a
+            // browser TAB while the browser has focus and the WINDOW elsewhere,
+            // and a menu label cannot follow focus that lives in a page view
+            // (UX r1 U4). The roles it replaced were "Close Window"/"Close".
+            label: "Close Tab or Window",
+            accelerator: "CmdOrCtrl+W",
+            click: (_item, target2) => runBrowserMenuAction(
+              "close-tab",
+              target2,
+              mainWindow,
+              routeBrowserMenu
+            )
+          },
           { type: "separator" },
           { role: "window" }
-        ] : [{ role: "close" }]
+        ] : [
+          {
+            id: "app-close",
+            // One honest label for both owners: the SAME accelerator closes a
+            // browser TAB while the browser has focus and the WINDOW elsewhere,
+            // and a menu label cannot follow focus that lives in a page view
+            // (UX r1 U4). The roles it replaced were "Close Window"/"Close".
+            label: "Close Tab or Window",
+            accelerator: "CmdOrCtrl+W",
+            click: (_item, target2) => runBrowserMenuAction(
+              "close-tab",
+              target2,
+              mainWindow,
+              routeBrowserMenu
+            )
+          }
+        ]
       ]
     },
     {
@@ -46966,14 +47949,16 @@ electron.app.whenReady().then(async () => {
     if (mainWindow) {
       mainWindow.webContents.on("before-input-event", (event, input) => {
         const isCmdOrCtrl = input.control || input.meta;
-        if (isCmdOrCtrl) {
+        if (event.defaultPrevented) return;
+        if (routeBrowserZoomInput(event, input)) return;
+        if (isCmdOrCtrl && input.type === "keyDown" && !input.alt && !input.isComposing) {
           if (input.key === "+" || input.key === "=") {
             zoomInFromEvent();
             event.preventDefault();
           } else if (input.key === "-") {
             zoomOutFromEvent();
             event.preventDefault();
-          } else if (input.key === "O") {
+          } else if (input.key === "0") {
             actualSizeFromEvent();
             event.preventDefault();
           }