pwragent 1.3.10 → 1.3.11

package/dist/federation-core.js

@@ -2274,7 +2274,7 @@ var require_websocket = __commonJS({
     var http2 = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash7 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash9 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2955,7 +2955,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3324,7 +3324,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash7 } = __require("crypto");
+    var { createHash: createHash9 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3631,7 +3631,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -9349,6 +9349,15 @@ function isFederationInstanceId(value) {
   }
   return true;
 }
+function isRemoteFederationTarget(target) {
+  return target.scope === "remote";
+}
+function federationTargetKey(target) {
+  return isRemoteFederationTarget(target) ? `remote:${target.instanceId}` : "local";
+}
+function federatedThreadIdentityKey(ref) {
+  return `${federationTargetKey(ref.target)}:${ref.backend}:${ref.threadId}`;
+}
 
 // ../shared/src/contracts/messaging-tools.ts
 var PWRAGENT_MESSAGING_TOOL_NAMESPACE = "pwragent_messaging";
@@ -9372,6 +9381,56 @@ var PWRAGENT_MESSAGING_CALLABLE_OPERATION_NAMES = [
   ...PWRAGENT_MESSAGING_LEGACY_OPERATION_NAMES
 ];
 
+// ../shared/src/contracts/navigation.ts
+var WORKTREE_IMAGE_MAX_BYTES = 16 * 1024 * 1024;
+function buildThreadIdentityKey(backend, threadId) {
+  return `${backend}:${threadId}`;
+}
+var NAVIGATION_QUERY_PROTOCOL_VERSION = 2;
+var NAVIGATION_QUERY_MAX_PAGE_ROWS = 100;
+var NAVIGATION_QUERY_MAX_RESULT_BYTES = 252 * 1024;
+
+// ../shared/src/navigation-star-map-filters.ts
+var NAVIGATION_STAR_MAP_FACETS = {
+  attention: ["attention", "approval", "pr", "unpushed"],
+  pinned: ["pinned"],
+  agent: ["agent"]
+};
+function passesNavigationStarMapFilters(signals, selection, exceptFacet) {
+  for (const [facet, keys] of Object.entries(NAVIGATION_STAR_MAP_FACETS)) {
+    if (facet === exceptFacet) continue;
+    let hasInclude = false;
+    let matchedInclude = false;
+    for (const key of keys) {
+      if (selection[key] === "exclude" && signals[key]) return false;
+      if (selection[key] === "include") {
+        hasInclude = true;
+        matchedInclude ||= signals[key];
+      }
+    }
+    if (hasInclude && !matchedInclude) return false;
+  }
+  return true;
+}
+function countNavigationStarMapFacets(signals, selection) {
+  const counts = {
+    matches: { attention: 0, approval: 0, pr: 0, unpushed: 0, pinned: 0, agent: 0 },
+    active: 0,
+    unread: 0
+  };
+  for (const signal of signals) {
+    for (const [facet, keys] of Object.entries(NAVIGATION_STAR_MAP_FACETS)) {
+      if (!passesNavigationStarMapFilters(signal, selection, facet)) continue;
+      for (const key of keys) if (signal[key]) counts.matches[key] += 1;
+      if (facet === "attention") {
+        if (signal.active) counts.active += 1;
+        if (signal.unread) counts.unread += 1;
+      }
+    }
+  }
+  return counts;
+}
+
 // ../shared/src/contracts/thread-todos.ts
 var THREAD_TODO_TITLE_MAX_LENGTH = 120;
 var THREAD_TODO_ORIGIN_ID_MAX_LENGTH = 200;
@@ -9385,7 +9444,40 @@ function threadTodoMessageOriginFromUnknown(value) {
   return { id, ...title ? { title } : {} };
 }
 
+// ../shared/src/thread-pins.ts
+var KEEP_AT_TOP_RANK_BOUNDARY = -(2 ** 39);
+var KEEP_AT_TOP_RANK_BASE = -(2 ** 40);
+function comparePinnedThreads(left, right) {
+  const rankComparison = comparePinRanks(left.pinnedRank, right.pinnedRank);
+  if (rankComparison !== 0) return rankComparison;
+  const updatedComparison = (right.updatedAt ?? 0) - (left.updatedAt ?? 0);
+  if (updatedComparison !== 0) return updatedComparison;
+  return left.id.localeCompare(right.id);
+}
+function comparePinRanks(left, right) {
+  const leftNumber = parsePinRank(left);
+  const rightNumber = parsePinRank(right);
+  if (leftNumber !== rightNumber) return leftNumber - rightNumber;
+  return (left ?? "").localeCompare(right ?? "");
+}
+function parsePinRank(rank) {
+  if (!rank?.trim()) return Number.POSITIVE_INFINITY;
+  const parsed = Number(rank);
+  return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
+}
+
 // ../shared/src/directory-navigation.ts
+function pathBaseName(value) {
+  if (!value) {
+    return value ?? "";
+  }
+  const normalized = value.replace(/[\\/]+$/, "");
+  const parts = normalized.split(/[\\/]/).filter(Boolean);
+  return parts.at(-1) ?? normalized;
+}
+function canonicalizeNavigationPath(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
 function normalizeGitOriginUrl(value) {
   const trimmed = value?.trim();
   if (!trimmed) {
@@ -9403,6 +9495,91 @@ function normalizeGitOriginUrl(value) {
   const normalized = candidate.replace(/\.git$/i, "").replace(/^ssh\//i, "").replace(/^\/+/, "").replace(/\/+$/, "").toLowerCase();
   return normalized || void 0;
 }
+function isInternalDirectoryLabel(value) {
+  return Boolean(value?.startsWith("directory:") || value?.startsWith("workspace:"));
+}
+function displayDirectoryLabel(params) {
+  const label = params.label?.trim();
+  if (label && !isInternalDirectoryLabel(label)) {
+    return label;
+  }
+  if (params.kind === "workspace") {
+    return "Workspaces";
+  }
+  return pathBaseName(params.path) || label || "Directory";
+}
+function matchScratchProjectsRoot(value) {
+  const scratchWorkspaceRootMatch = value.match(
+    /^(.*[\\/]\.pwrag(?:ent|nt)(?:[\\/]profiles[\\/][^\\/]+)?[\\/]projects)$/
+  );
+  if (scratchWorkspaceRootMatch) {
+    return scratchWorkspaceRootMatch[1];
+  }
+  const scratchWorkspaceMatch = value.match(
+    /^(.*[\\/]\.pwrag(?:ent|nt)(?:[\\/]profiles[\\/][^\\/]+)?[\\/]projects)[\\/][^\\/]+$/
+  );
+  return scratchWorkspaceMatch?.[1];
+}
+function matchCodexChatsRoot(value) {
+  const codexChatsRootMatch = value.match(
+    /^(.*[\\/]Documents[\\/]Codex)(?:[\\/]\d{4}-\d{2}-\d{2}(?:[\\/].*)?)?$/
+  );
+  return codexChatsRootMatch?.[1];
+}
+function classifyDirectory(directory) {
+  const path11 = canonicalizeNavigationPath(directory.path);
+  const scratchProjectsRoot = matchScratchProjectsRoot(path11);
+  if (scratchProjectsRoot) {
+    return {
+      key: `workspace:${scratchProjectsRoot}`,
+      kind: "workspace",
+      label: "Workspaces",
+      path: scratchProjectsRoot
+    };
+  }
+  const codexChatsRoot = matchCodexChatsRoot(path11);
+  if (codexChatsRoot) {
+    return {
+      key: `directory:${codexChatsRoot}`,
+      kind: "directory",
+      label: "Codex Chats",
+      path: codexChatsRoot
+    };
+  }
+  const repoWorktreeMatch = path11.match(
+    /^(.*)[\\/]\.worktrees[\\/][^\\/]+(?:[\\/].*)?$/
+  );
+  if (directory.kind === "worktree" && repoWorktreeMatch) {
+    const canonicalPath = repoWorktreeMatch[1];
+    return {
+      key: `directory:${canonicalPath}`,
+      kind: "directory",
+      label: pathBaseName(canonicalPath),
+      path: canonicalPath
+    };
+  }
+  const codexWorktreeMatch = path11.match(
+    /^(?:[A-Za-z]:)?[\\/].*[\\/]\.codex(?:[\\/]profiles[\\/][^\\/]+)?[\\/]worktrees[\\/][^\\/]+[\\/]([^\\/]+)(?:[\\/].*)?$/
+  );
+  if (codexWorktreeMatch) {
+    return {
+      key: `directory:${path11}`,
+      kind: "directory",
+      label: codexWorktreeMatch[1],
+      path: path11
+    };
+  }
+  return {
+    key: `directory:${path11}`,
+    kind: "directory",
+    label: displayDirectoryLabel({
+      kind: "directory",
+      label: directory.label,
+      path: path11
+    }),
+    path: path11
+  };
+}
 
 // ../shared/src/nested-worktree-pathspec.ts
 var EXCLUDE_MAGIC = ":(exclude,top,literal)";
@@ -9486,6 +9663,186 @@ async function readStatusWithoutNestedWorktrees(options) {
   return await options.git([...options.statusArgs, ...nestedWorktreePathspecArgs(excludes)]);
 }
 
+// ../shared/src/subthreads.ts
+function sortSubthreadSummaries(parent, children) {
+  const order = new Map(
+    (parent.subthreadOrder ?? []).map((threadId, index) => [threadId, index])
+  );
+  return [...children].sort((left, right) => {
+    const leftRank = order.get(left.id);
+    const rightRank = order.get(right.id);
+    if (leftRank !== void 0 || rightRank !== void 0) {
+      return (leftRank ?? Number.MAX_SAFE_INTEGER) - (rightRank ?? Number.MAX_SAFE_INTEGER);
+    }
+    return (right.createdAt ?? 0) - (left.createdAt ?? 0);
+  });
+}
+
+// ../shared/src/jump-search-text.ts
+function wordPrefixesMatch(words, needle) {
+  let offsets = /* @__PURE__ */ new Set([0]);
+  for (let index = 0; index < words.length; index += 1) {
+    const next = /* @__PURE__ */ new Set();
+    const word = words[index].toLowerCase();
+    for (const offset of offsets) {
+      for (let length = 1; length <= word.length && offset + length <= needle.length; length += 1) {
+        if (word[length - 1] !== needle[offset + length - 1]) break;
+        if (offset + length === needle.length && index > 0) return true;
+        next.add(offset + length);
+      }
+    }
+    if (!next.size) return false;
+    offsets = next;
+  }
+  return false;
+}
+function splitJumpWords(text) {
+  return text.replace(new RegExp("([\\p{Ll}\\p{N}])(\\p{Lu})", "gu"), "$1 $2").replace(new RegExp("(\\p{Lu})(\\p{Lu}\\p{Ll})", "gu"), "$1 $2").match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function textMatchesJumpQuery(text, query) {
+  const needle = query.trim().toLowerCase();
+  if (!text || !needle) return false;
+  if (text.toLowerCase().includes(needle)) return true;
+  if (!/^[\p{L}\p{N}]{2,32}$/u.test(needle)) return false;
+  return text.split(/[\\/]/).some((component) => {
+    const compounds = component.match(/[\p{L}\p{N}]+(?:[-_.:][\p{L}\p{N}]+)*/gu) ?? [];
+    return compounds.some((compound) => wordPrefixesMatch(splitJumpWords(compound), needle)) || wordPrefixesMatch(splitJumpWords(component), needle);
+  });
+}
+
+// ../shared/src/thread-search-query.ts
+function parseThreadSearchQuery(input) {
+  const projects = [];
+  const tokens = input.match(/(?:in:)?@"[^"]+"(?=\s|$)|"[^"]*"(?=\s|$)|\S+/gi) ?? [];
+  const text = tokens.filter((token) => {
+    const mention = /^(?:in:)?@(?:"([^"]+)"|([^\s"@]+))$/i.exec(token);
+    if (!mention) return true;
+    projects.push((mention[1] ?? mention[2]).toLowerCase());
+    return false;
+  });
+  return { query: projects.length ? text.join(" ") : input.trim(), projects: [...new Set(projects)] };
+}
+function matchesThreadSearchProjects(thread, projects) {
+  if (!projects.length) return true;
+  const values = [thread.projectKey, ...(thread.linkedDirectories ?? []).flatMap(
+    (directory) => [directory.label, directory.path, directory.worktreePath]
+  )].filter((value) => Boolean(value));
+  return projects.some((project) => values.some((value) => {
+    const path11 = value.replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+    const name = path11.slice(path11.lastIndexOf("/") + 1);
+    return name.startsWith(project) || path11.startsWith(project.replaceAll("\\", "/"));
+  }));
+}
+function threadSearchTextTerms(query) {
+  return (query.match(/"[^"]*"|[^\s"]+/g) ?? []).map((token) => ({
+    text: token.startsWith('"') ? token.slice(1, -1) : token,
+    quoted: token.startsWith('"')
+  })).filter((term) => term.text.length > 0);
+}
+
+// ../shared/src/thread-jump-match.ts
+var MIN_LONG_THREAD_ID_QUERY_LENGTH = 10;
+var MIN_UUID_FRAGMENT_HEX_CHARS = 8;
+function threadPrNumbers(thread) {
+  return (thread.prs ?? []).map((pr2) => pr2.number);
+}
+function threadHasExactPrNumberMatch(thread, query) {
+  const match = query.trim().match(/^#?(\d{1,7})$/);
+  if (!match) {
+    return false;
+  }
+  const number = Number(match[1]);
+  return Number.isInteger(number) && number > 0 && threadPrNumbers(thread).includes(number);
+}
+function threadIdMatchesQuery(threadId, query) {
+  const id = threadId.toLowerCase();
+  if (!id.includes(query)) {
+    return false;
+  }
+  const hexChars = query.match(/[0-9a-f]/g)?.length ?? 0;
+  const uuidFragment = /^[0-9a-f][0-9a-f-]{7,}$/i.test(query) && hexChars >= MIN_UUID_FRAGMENT_HEX_CHARS;
+  if (uuidFragment) {
+    return true;
+  }
+  return query.length >= MIN_LONG_THREAD_ID_QUERY_LENGTH;
+}
+function agentMetadataMatchesQuery(thread, query) {
+  if (!thread.agent) {
+    return false;
+  }
+  const tokens = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return false;
+  }
+  const haystack = [
+    "agent",
+    "agent thread",
+    thread.agent.name,
+    thread.agent.instructions
+  ].filter((value) => Boolean(value)).join(" ").toLowerCase();
+  return tokens.every((token) => haystack.includes(token));
+}
+function parseThreadJumpQuery(query) {
+  const parsed = parseThreadSearchQuery(query);
+  const terms = threadSearchTextTerms(parsed.query).map((term) => term.text);
+  if (!parsed.projects.length && !/"(?:in:)?@[^"]*"/i.test(parsed.query)) {
+    return { text: parsed.query, projects: [], terms };
+  }
+  return { text: terms.join(" "), projects: parsed.projects, terms };
+}
+function createThreadJumpMatcher(query) {
+  const { text, projects, terms } = parseThreadJumpQuery(query);
+  const needle = text.trim().toLowerCase();
+  const words = terms.map((term) => term.toLowerCase());
+  const wordsDiffer = words.join(" ") !== needle;
+  return (thread) => {
+    if (projects.length && !matchesThreadSearchProjects(thread, projects)) {
+      return false;
+    }
+    if (!needle) {
+      return projects.length > 0;
+    }
+    if (threadMatchesNeedle(thread, needle)) {
+      return true;
+    }
+    return words.length > 0 && (words.length > 1 || wordsDiffer) && words.every((word) => threadMatchesNeedle(thread, word));
+  };
+}
+function threadMatchesNeedle(thread, needle) {
+  if (textMatchesJumpQuery(thread.title, needle)) {
+    return true;
+  }
+  if (agentMetadataMatchesQuery(thread, needle)) {
+    return true;
+  }
+  if (threadIdMatchesQuery(thread.id, needle)) {
+    return true;
+  }
+  if (textMatchesJumpQuery(thread.gitBranch, needle)) {
+    return true;
+  }
+  const bareNeedle = needle.replace(/^#/, "");
+  if (bareNeedle.length > 0 && threadPrNumbers(thread).some((number) => String(number).includes(bareNeedle))) {
+    return true;
+  }
+  return (thread.linkedDirectories ?? []).some(
+    (directory) => [directory.label, directory.path, directory.worktreePath].some((value) => textMatchesJumpQuery(value, needle))
+  );
+}
+function rankThreadJumpMatches(threads, query) {
+  return sortThreadJumpMatches(threads.filter(createThreadJumpMatcher(query)), query);
+}
+function sortThreadJumpMatches(threads, query) {
+  const { text } = parseThreadJumpQuery(query);
+  return [...threads].sort((left, right) => {
+    const exactPrPriority = Number(threadHasExactPrNumberMatch(right, text)) - Number(threadHasExactPrNumberMatch(left, text));
+    if (exactPrPriority !== 0) {
+      return exactPrPriority;
+    }
+    return (right.updatedAt ?? right.createdAt ?? 0) - (left.updatedAt ?? left.createdAt ?? 0);
+  });
+}
+
 // ../shared/src/thread-titles.ts
 var MAX_DERIVED_THREAD_TITLE_LENGTH = 72;
 var MIN_PREFERRED_BREAK_INDEX = 36;
@@ -13088,10 +13445,10 @@ var FederationPtyService = class {
   async list(peerId, request) {
     await this.ready;
     if (this.options.allowOpen?.() === false) throw new Error("Remote shells are disabled.");
-    const threadKey = `${request.backend}:${request.threadId}`;
+    const threadKey2 = `${request.backend}:${request.threadId}`;
     return [
       ...[...this.sessionsById.values()].filter((session) => session.peerId === peerId && session.reapReason !== "close" && session.backend === request.backend && session.threadId === request.threadId).map((session) => this.summary(session)),
-      ...[...this.archived.values()].filter((record) => record.peerId === peerId && record.summary.threadKey === threadKey).map((record) => record.summary)
+      ...[...this.archived.values()].filter((record) => record.peerId === peerId && record.summary.threadKey === threadKey2).map((record) => record.summary)
     ];
   }
   async snapshot(peerId, request) {
@@ -18790,7 +19147,9 @@ var ThreadInstanceHandoffService = class {
 // ../federation/src/git-instance-handoff.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { realpath as realpath3, stat as stat2 } from "node:fs/promises";
+import os2 from "node:os";
 import path6 from "node:path";
+var DISABLE_HOOKS = ["-c", `core.hooksPath=${os2.devNull}`];
 function createGitHandoffService(runGitCommand) {
   function git(cwd, args) {
     return runGitCommand(cwd, args, { maxBuffer: 1024 * 1024 });
@@ -18887,7 +19246,7 @@ function createGitHandoffService(runGitCommand) {
     if (!remote) throw new Error("The receiving repository has no remote matching the sender. Clone the same repository or fix its remote before handing off.");
     const ref = `refs/pwragent/handoffs/${randomUUID6()}`;
     try {
-      await git(repository, ["-c", "core.hooksPath=", "fetch", "--no-tags", "--no-write-fetch-head", "--", remote, `${snapshot.ref}:${ref}`]).catch((error) => {
+      await git(repository, [...DISABLE_HOOKS, "fetch", "--no-tags", "--no-write-fetch-head", "--", remote, `${snapshot.ref}:${ref}`]).catch((error) => {
         throw new Error(`The receiving machine could not fetch ${snapshot.ref}. Check its Git access and push the source branch before handing off.`, { cause: error });
       });
       const fetchedHead = (await git(repository, ["rev-parse", `${ref}^{commit}`])).stdout.trim();
@@ -18929,11 +19288,11 @@ function createGitHandoffService(runGitCommand) {
             switchBranch = branchHead ? ["--no-guess", branch] : ["-c", branch, snapshot.head];
           }
         }
-        await git(repository, ["-c", "core.hooksPath=", "worktree", "add", "--detach", worktree, snapshot.head]);
+        await git(repository, [...DISABLE_HOOKS, "worktree", "add", "--detach", worktree, snapshot.head]);
         created = true;
         if (switchBranch && branch) {
           try {
-            await git(worktree, ["-c", "core.hooksPath=", "switch", ...switchBranch]);
+            await git(worktree, [...DISABLE_HOOKS, "switch", ...switchBranch]);
             if (switchBranch[0] === "-c") createdBranch = branch;
           } catch (error) {
             const ref = `refs/heads/${branch}`;
@@ -19283,7 +19642,7 @@ import path10 from "node:path";
 
 // ../agent-tools/src/local-file-access.ts
 import { realpath as realpath4 } from "node:fs/promises";
-import os2 from "node:os";
+import os3 from "node:os";
 import path8 from "node:path";
 var PRIVATE_STORAGE_DIRECTORIES = /* @__PURE__ */ new Set([
   "archived_sessions",
@@ -19346,7 +19705,7 @@ async function canonicalizeRoots(roots) {
 }
 function configuredPrivateStorageRoots(privateStorageRoots) {
   return [
-    path8.join(os2.homedir(), ".codex"),
+    path8.join(os3.homedir(), ".codex"),
     process.env.CODEX_HOME?.trim(),
     ...privateStorageRoots
   ].filter((root) => Boolean(root));
@@ -20103,6 +20462,1414 @@ var FEDERATION_BACKEND_METHOD_CAPABILITIES = {
   // instance — the same trust the materialize-launchpad path carries.
   [FEDERATION_BACKEND_METHODS.starMapIntake]: "environment_actions"
 };
+
+// ../owner-core/src/navigation-query-store.ts
+import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
+
+// ../owner-core/src/navigation-query-projection.ts
+import { createHash as createHash7 } from "node:crypto";
+
+// ../owner-core/src/navigation-attention-order.ts
+function observeNavigationAttentionTurn(params) {
+  const previous = params.previous.members.get(params.key);
+  const observedTurnIds = previous?.observedTurnIds ?? (previous?.eventTurnId ? [previous.eventTurnId] : []);
+  if (params.turnId && params.turnId !== previous?.eventTurnId && observedTurnIds.includes(params.turnId)) return params.previous;
+  if (previous?.active === params.active && (!params.turnId || previous.eventTurnId === params.turnId)) return params.previous;
+  if (!params.active && previous?.active && previous.eventTurnId && params.turnId && previous.eventTurnId !== params.turnId) return params.previous;
+  const newTurn = Boolean(params.turnId && previous?.eventTurnId !== params.turnId);
+  const move = !previous || (params.active ? !previous.active || newTurn && Boolean(previous.eventTurnId) : !previous.active && newTurn || params.promoteOnTurnEnd);
+  const rank = move ? params.previous.nextRank : previous.rank;
+  const members = new Map(params.previous.members);
+  members.set(params.key, {
+    active: params.active,
+    rank,
+    updatedAt: previous?.updatedAt ?? 0,
+    observedTurnIds: params.turnId && !observedTurnIds.includes(params.turnId) ? [...observedTurnIds, params.turnId] : observedTurnIds,
+    eventTurnId: params.active ? params.turnId : params.turnId ?? previous?.eventTurnId,
+    eventTracked: true,
+    awaitingBaseline: true,
+    ...params.observedAt !== void 0 ? { observedAt: params.observedAt } : {}
+  });
+  let removed = params.previous.removed;
+  if (removed?.has(params.key)) {
+    removed = new Map(removed);
+    removed.delete(params.key);
+  }
+  return {
+    members,
+    nextRank: params.previous.nextRank + Number(move),
+    ...removed?.size ? { removed } : {},
+    ...params.previous.listedAt !== void 0 ? { listedAt: params.previous.listedAt } : {}
+  };
+}
+function removeNavigationAttentionMember(params) {
+  const members = new Map(params.previous.members);
+  members.delete(params.key);
+  const removed = new Map(params.previous.removed);
+  removed.set(params.key, params.observedAt);
+  return { ...params.previous, members, removed };
+}
+function navigationAttentionOrderFollows(order, observedAt) {
+  if ((order.listedAt ?? 0) > observedAt) return true;
+  for (const member of order.members.values()) if ((member.observedAt ?? 0) > observedAt) return true;
+  for (const at2 of order.removed?.values() ?? []) if (at2 > observedAt) return true;
+  return false;
+}
+function navigationAttentionIdentity(thread) {
+  return JSON.stringify([
+    thread.federation?.ref.target.scope === "remote" ? thread.federation.ref.target.instanceId : null,
+    thread.source,
+    thread.id
+  ]);
+}
+function isLive(thread) {
+  return thread.threadStatus === "active" || thread.hasActiveSubAgent === true || thread.hasBackgroundTasks === true;
+}
+function reconcileNavigationAttentionOrder(params) {
+  const { observedAt } = params;
+  const follows = (at2) => observedAt !== void 0 && at2 !== void 0 && at2 > observedAt;
+  const members = params.complete === false ? new Map(params.previous?.members) : /* @__PURE__ */ new Map();
+  for (const [key, member] of params.previous?.members ?? []) {
+    if (member.awaitingBaseline || follows(member.observedAt)) members.set(key, member);
+  }
+  const removed = /* @__PURE__ */ new Map();
+  for (const [key, at2] of params.previous?.removed ?? []) {
+    if (follows(at2)) removed.set(key, at2);
+  }
+  const decides = (key) => {
+    const member = params.previous?.members.get(key);
+    return !follows(member?.observedAt) && !removed.has(key) && (member !== void 0 || !follows(params.previous?.listedAt));
+  };
+  for (const thread of params.threads) {
+    const key = navigationAttentionIdentity(thread);
+    const previous = params.previous?.members.get(key);
+    if (decides(key) && (thread.codexNativeSubAgent || !isLive(thread) && !thread.inbox.inInbox && (!previous?.awaitingBaseline || !previous.active))) members.delete(key);
+  }
+  let nextRank = params.previous?.nextRank ?? 1;
+  const eligible = params.threads.filter((thread) => !thread.codexNativeSubAgent && decides(navigationAttentionIdentity(thread)) && (isLive(thread) || thread.inbox.inInbox)).sort((left, right) => (left.updatedAt ?? 0) - (right.updatedAt ?? 0) || navigationAttentionIdentity(right).localeCompare(navigationAttentionIdentity(left)));
+  for (const thread of eligible) {
+    const key = navigationAttentionIdentity(thread);
+    const previous = params.previous?.members.get(key);
+    const observedActive = thread.threadStatus === "active";
+    const active = previous?.awaitingBaseline ? previous.active : observedActive;
+    const updatedAt = thread.updatedAt ?? 0;
+    const started = active && previous?.active === false;
+    const finished = !active && (previous?.active === true || previous?.active === false && !previous.eventTracked && updatedAt > previous.updatedAt);
+    const rank = !previous || started || finished && params.promoteOnTurnEnd ? nextRank++ : previous.rank;
+    const awaitingBaseline = previous?.awaitingBaseline && observedActive !== active;
+    const memberObservedAt = awaitingBaseline ? previous?.observedAt : observedAt ?? previous?.observedAt;
+    members.set(key, {
+      active,
+      rank,
+      updatedAt,
+      ...previous?.eventTurnId ? { eventTurnId: previous.eventTurnId } : {},
+      ...previous?.observedTurnIds ? { observedTurnIds: previous.observedTurnIds } : {},
+      ...previous?.eventTracked ? { eventTracked: true } : {},
+      ...awaitingBaseline ? { awaitingBaseline: true } : {},
+      ...memberObservedAt !== void 0 ? { observedAt: memberObservedAt } : {}
+    });
+  }
+  if (observedAt !== void 0) {
+    for (const key of params.previous?.members.keys() ?? []) {
+      if (!members.has(key)) removed.set(key, observedAt);
+    }
+  }
+  const listedAt = params.complete !== false && observedAt !== void 0 && !follows(params.previous?.listedAt) ? observedAt : params.previous?.listedAt;
+  return { members, nextRank, ...removed.size ? { removed } : {}, ...listedAt !== void 0 ? { listedAt } : {} };
+}
+function navigationAttentionOrderBytes(order) {
+  return Buffer.byteLength(JSON.stringify({
+    members: [...order.members],
+    nextRank: order.nextRank,
+    removed: [...order.removed ?? []],
+    listedAt: order.listedAt
+  }), "utf8");
+}
+
+// ../owner-core/src/navigation-query-projection.ts
+var MAX_ROW_NESTED_RECORDS = 16;
+function hashValue(value) {
+  return createHash7("sha256").update(JSON.stringify(value)).digest("base64url");
+}
+function navigationIdentity(thread) {
+  return {
+    backend: thread.source,
+    threadId: thread.id,
+    ...thread.federation?.ref.target.scope === "remote" ? { ownerInstanceId: thread.federation.ref.target.instanceId } : {}
+  };
+}
+function identityKey(identity) {
+  return [
+    identity.ownerInstanceId ?? "local",
+    identity.backend,
+    identity.threadId
+  ].join("\0");
+}
+function threadKey(thread) {
+  return identityKey(navigationIdentity(thread));
+}
+function parentIdentity(thread, candidatesByOwner) {
+  if (!thread.parentThreadId) {
+    return void 0;
+  }
+  let ownerInstanceId = thread.parentThreadInstanceId ?? (thread.federation?.ref.target.scope === "remote" ? thread.federation.ref.target.instanceId : void 0);
+  if (!ownerInstanceId && thread.handoffOrigin?.groupingMode === "subthread" && !(candidatesByOwner.get(JSON.stringify([null, thread.parentThreadId])) ?? []).some((candidate) => candidate.source === (thread.parentThreadBackend ?? thread.source))) {
+    const origin = thread.handoffOrigin;
+    const launcher = (candidatesByOwner.get(JSON.stringify([null, origin.sourceThreadId])) ?? []).find((candidate) => candidate.source === origin.sourceBackend);
+    if (launcher?.parentThreadId === thread.parentThreadId && (launcher.parentThreadBackend ?? launcher.source) === (thread.parentThreadBackend ?? thread.source)) {
+      ownerInstanceId = launcher.parentThreadInstanceId;
+    }
+  }
+  const candidates = candidatesByOwner.get(JSON.stringify([ownerInstanceId ?? null, thread.parentThreadId])) ?? [];
+  const parent = !thread.parentThreadBackend ? candidates.find((candidate) => candidate.source === thread.source) ?? (candidates.length === 1 ? candidates[0] : void 0) : void 0;
+  const backend = thread.parentThreadBackend ?? parent?.source ?? thread.source;
+  const resolvedParent = candidates.find((candidate) => candidate.source === backend);
+  if (resolvedParent) ownerInstanceId = navigationIdentity(resolvedParent).ownerInstanceId;
+  return {
+    backend,
+    threadId: thread.parentThreadId,
+    ...ownerInstanceId ? { ownerInstanceId } : {}
+  };
+}
+function isOrdinaryThread(thread) {
+  return thread.codexNativeSubAgent === void 0;
+}
+function lensRootResolver(params) {
+  const roots = /* @__PURE__ */ new Map();
+  return (thread) => {
+    const known = roots.get(thread);
+    if (known) return known;
+    let root = thread;
+    const visited = /* @__PURE__ */ new Set([thread]);
+    for (let depth = 0; depth < 32; depth += 1) {
+      const parent = parentIdentity(root, params.parentCandidates);
+      const parentThread = parent ? params.threadsByIdentity.get(identityKey(parent)) : void 0;
+      if (!parentThread || visited.has(parentThread)) break;
+      visited.add(parentThread);
+      root = parentThread;
+    }
+    roots.set(thread, root);
+    return root;
+  };
+}
+function availableParentIdentity(thread, candidatesByOwner, coverage) {
+  const parent = parentIdentity(thread, candidatesByOwner);
+  if (!parent) return void 0;
+  if (coverage && coverage.state !== "complete") return parent;
+  const candidates = candidatesByOwner.get(JSON.stringify([parent.ownerInstanceId ?? null, parent.threadId])) ?? [];
+  return candidates.some((candidate) => candidate.source === parent.backend) ? parent : void 0;
+}
+function directoryParentResolver(members, parentCandidates) {
+  const memberKeys = new Set(members.map(threadKey));
+  return (thread) => {
+    const parent = parentIdentity(thread, parentCandidates);
+    return parent && memberKeys.has(identityKey(parent)) ? parent : void 0;
+  };
+}
+function directoryMemberThreads(directory, threadsByLegacyKey) {
+  return directory?.threadKeys.map((key) => threadsByLegacyKey.get(key)).filter((thread) => Boolean(thread)) ?? [];
+}
+function isActive(thread) {
+  return thread.threadStatus === "active" || thread.hasActiveSubAgent === true || thread.hasBackgroundTasks === true;
+}
+function countsForThreads(threads, options = {}) {
+  const distinct = /* @__PURE__ */ new Map();
+  for (const thread of threads) {
+    if (!isOrdinaryThread(thread)) {
+      continue;
+    }
+    distinct.set(threadKey(thread), thread);
+  }
+  let active = 0;
+  let activeRemote = 0;
+  let pinned = 0;
+  let unread = 0;
+  let review = 0;
+  for (const thread of distinct.values()) {
+    const threadActive = isActive(thread);
+    const threadUnread = thread.inbox.inInbox;
+    if (threadActive) active += 1;
+    if (threadActive && thread.federation?.ref.target.scope === "remote") activeRemote += 1;
+    if (thread.pinnedRank) pinned += 1;
+    if (threadUnread) unread += 1;
+    if (threadUnread && !threadActive) review += 1;
+  }
+  const backends = options.backends ? [...new Set(
+    [...distinct.values()].map((thread) => thread.source)
+  )].sort() : void 0;
+  return {
+    total: distinct.size,
+    active,
+    ...activeRemote ? { activeRemote } : {},
+    ...pinned ? { pinned } : {},
+    unread,
+    review,
+    ...backends ? { backends } : {}
+  };
+}
+function limitRecords(items) {
+  if (!items || items.length === 0) {
+    return { truncated: false };
+  }
+  return {
+    items: items.slice(0, MAX_ROW_NESTED_RECORDS),
+    truncated: items.length > MAX_ROW_NESTED_RECORDS
+  };
+}
+function projectNavigationRow(params) {
+  const { thread } = params;
+  const linkedDirectories = limitRecords(thread.federation ? thread.linkedDirectories : withRepositoryIdentities(thread.linkedDirectories, params.repositories));
+  const reactions = limitRecords(thread.reactions);
+  const prs = limitRecords(thread.prs);
+  const messagingBindings = limitRecords(thread.messagingBindings);
+  const prCiWatches = limitRecords(thread.prCiWatches);
+  const nativeSubAgentCount = thread.nativeSubAgentCount ?? thread.codexNativeSubAgents?.length ?? 0;
+  const projected = {
+    ref: navigationIdentity(thread),
+    id: thread.id,
+    source: thread.source,
+    title: thread.title,
+    titleSource: thread.titleSource,
+    ...thread.createdAt !== void 0 ? { createdAt: thread.createdAt } : {},
+    ...thread.updatedAt !== void 0 ? { updatedAt: thread.updatedAt } : {},
+    ...thread.archivedAt !== void 0 ? { archivedAt: thread.archivedAt } : {},
+    ...thread.threadStatus ? { threadStatus: thread.threadStatus } : {},
+    ...thread.hasActiveSubAgent ? { hasActiveSubAgent: true } : {},
+    ...thread.hasBackgroundTasks ? { hasBackgroundTasks: true } : {},
+    ...thread.hasAgentCommands ? { hasAgentCommands: true } : {},
+    inbox: thread.inbox,
+    ...thread.projectKey ? { projectKey: thread.projectKey } : {},
+    linkedDirectories: linkedDirectories.items ?? [],
+    ...linkedDirectories.truncated ? { linkedDirectoriesTruncated: true } : {},
+    ...thread.gitBranch ? { gitBranch: thread.gitBranch } : {},
+    ...thread.gitOriginUrl ? { gitOriginUrl: thread.gitOriginUrl } : {},
+    ...thread.observedGitBranch ? { observedGitBranch: thread.observedGitBranch } : {},
+    ...thread.gitWorkingState ? { gitWorkingState: thread.gitWorkingState } : {},
+    ...thread.gitWorkingStateFetchedAt !== void 0 ? { gitWorkingStateFetchedAt: thread.gitWorkingStateFetchedAt } : {},
+    ...thread.primaryGitRepository ? { primaryGitRepository: thread.primaryGitRepository } : {},
+    ...thread.federation ? {
+      federation: {
+        ref: thread.federation.ref,
+        instanceLabel: thread.federation.instanceLabel,
+        ...thread.federation.peerStatus ? { peerStatus: thread.federation.peerStatus } : {},
+        ...thread.federation.capabilities ? { capabilities: thread.federation.capabilities } : {},
+        ...thread.federation.derivedFromMountedParent ? { derivedFromMountedParent: true } : {},
+        ...thread.federation.celestialIcon ? { celestialIcon: thread.federation.celestialIcon } : {}
+      }
+    } : {},
+    ...thread.pinnedRank ? { pinnedRank: thread.pinnedRank } : {},
+    ...thread.parentThreadId ? { parentThreadId: thread.parentThreadId } : {},
+    ...thread.parentThreadBackend ? { parentThreadBackend: thread.parentThreadBackend } : {},
+    ...thread.parentThreadInstanceId ? { parentThreadInstanceId: thread.parentThreadInstanceId } : {},
+    ordinaryChildCount: params.childCount,
+    ...params.viewerChildCount !== void 0 ? { viewerChildCount: params.viewerChildCount } : {},
+    nativeSubAgentGroupPresent: nativeSubAgentCount > 0,
+    ...nativeSubAgentCount > 0 ? { nativeSubAgentCount } : {},
+    ...thread.subthreadsCollapsed !== void 0 ? { subthreadsCollapsed: thread.subthreadsCollapsed } : {},
+    ...reactions.items ? { reactions: reactions.items } : {},
+    ...reactions.truncated ? { reactionsTruncated: true } : {},
+    ...thread.lock ? { lock: thread.lock } : {},
+    ...prs.items ? { prs: prs.items } : {},
+    ...prs.truncated ? { prsTruncated: true } : {},
+    ...messagingBindings.items ? { messagingBindings: messagingBindings.items } : {},
+    ...messagingBindings.truncated ? { messagingBindingsTruncated: true } : {},
+    ...thread.automationSummary ? { automationSummary: thread.automationSummary } : {},
+    ...thread.agentChange ? { agentChange: thread.agentChange } : {},
+    ...thread.agent ? {
+      agent: {
+        name: thread.agent.name,
+        instructionLineCount: thread.agent.instructionLineCount,
+        instructionsTooLong: thread.agent.instructionsTooLong,
+        updatedAt: thread.agent.updatedAt
+      }
+    } : {},
+    ...thread.executionMode ? { executionMode: thread.executionMode } : {},
+    ...thread.model ? { model: thread.model } : {},
+    ...thread.serviceTier ? { serviceTier: thread.serviceTier } : {},
+    ...thread.reasoningEffort ? { reasoningEffort: thread.reasoningEffort } : {},
+    ...thread.fastMode !== void 0 ? { fastMode: thread.fastMode } : {},
+    ...thread.workspaceHandoff ? { workspaceHandoff: thread.workspaceHandoff } : {},
+    needsInput: params.needsInput,
+    queueCount: thread.queuedTurns?.length ?? 0,
+    queueState: thread.queuedTurns ? "ready" : "unknown",
+    ...thread.queuedExecutionMode ? { queuedExecutionMode: thread.queuedExecutionMode } : {},
+    ...thread.prAutoDispatchEnabled !== void 0 ? { prAutoDispatchEnabled: thread.prAutoDispatchEnabled } : {},
+    ...prCiWatches.items ? { prCiWatches: prCiWatches.items } : {},
+    ...thread.scheduledStart ? { scheduledStart: thread.scheduledStart } : {},
+    ...params.homeProject ? { homeProject: params.homeProject } : {}
+  };
+  return {
+    ...projected,
+    rowRevision: hashValue(projected)
+  };
+}
+function projectDirectoryGitStatus(directory) {
+  const status = directory.gitStatus;
+  if (!status) {
+    return void 0;
+  }
+  return {
+    ...status.currentBranch ? { currentBranch: status.currentBranch } : {},
+    ...status.defaultBranch ? { defaultBranch: status.defaultBranch } : {},
+    ...status.upstreamBranch ? { upstreamBranch: status.upstreamBranch } : {},
+    ...status.ahead !== void 0 ? { ahead: status.ahead } : {},
+    ...status.behind !== void 0 ? { behind: status.behind } : {},
+    ...status.syncState ? { syncState: status.syncState } : {},
+    ...status.statusUnavailableReason ? { statusUnavailableReason: status.statusUnavailableReason } : {},
+    ...status.worktreeCreationAvailable !== void 0 ? { worktreeCreationAvailable: status.worktreeCreationAvailable } : {},
+    ...status.worktreeCreationUnavailableReason ? {
+      worktreeCreationUnavailableReason: status.worktreeCreationUnavailableReason
+    } : {}
+  };
+}
+function buildDirectoryRows(params) {
+  return params.snapshot.directories.map((directory) => {
+    const memberThreads = directoryMemberThreads(directory, params.threadsByLegacyKey);
+    const parentOf = directoryParentResolver(memberThreads, params.parentCandidates);
+    const rootThreads = memberThreads.filter((thread) => !parentOf(thread));
+    const pinnedRootCount = rootThreads.filter((thread) => thread.pinnedRank).length;
+    const gitStatus = projectDirectoryGitStatus(directory);
+    const repositoryKey = directory.gitStatus?.originRepository ?? directory.repositoryKey;
+    const repositoryKeys = directory.gitStatus?.remoteRepositories?.length ? directory.gitStatus.remoteRepositories : directory.repositoryKeys;
+    return {
+      key: directory.key,
+      kind: directory.kind,
+      label: directory.label,
+      ...directory.path ? { path: directory.path } : {},
+      ...repositoryKey ? { repositoryKey } : {},
+      ...repositoryKeys?.length ? { repositoryKeys } : {},
+      ...directory.localAvailability ? { localAvailability: directory.localAvailability } : {},
+      counts: countsForThreads(memberThreads),
+      pinnedRootCount,
+      unpinnedRootCount: rootThreads.length - pinnedRootCount,
+      ...directory.latestUpdatedAt !== void 0 ? { latestUpdatedAt: directory.latestUpdatedAt } : {},
+      ...directory.pinnedRank ? { pinnedRank: directory.pinnedRank } : {},
+      ...directory.directoryThreadsCollapsed !== void 0 ? { directoryThreadsCollapsed: directory.directoryThreadsCollapsed } : {},
+      // A placeholder row stands for a peer's project. It shows that
+      // project's setting only when its threads name one project on one peer.
+      ...directory.forgeAutomation && (!directory.localAvailability || directory.peerProject) ? { forgeAutomation: directory.forgeAutomation } : {},
+      ...directory.localAvailability && directory.peerProject ? { peerProject: directory.peerProject } : {},
+      ...gitStatus ? { gitStatus } : {},
+      launchpadPresent: Boolean(directory.launchpad),
+      ...directory.launchpad?.backend ? { launchpadBackend: directory.launchpad.backend } : {}
+    };
+  });
+}
+function repositoryIdentitiesByPath(index) {
+  const identities = /* @__PURE__ */ new Map();
+  for (const directory of index.directories) {
+    const path11 = directory.path;
+    const repositoryKey = directory.gitStatus?.originRepository;
+    const repositoryKeys = directory.gitStatus?.remoteRepositories;
+    if (!path11 || !repositoryKey && !repositoryKeys?.length) continue;
+    identities.set(path11, {
+      ...repositoryKey ? { repositoryKey } : {},
+      ...repositoryKeys?.length ? { repositoryKeys } : {}
+    });
+  }
+  return identities;
+}
+function withRepositoryIdentities(directories, repositories) {
+  if (!repositories.size) return directories;
+  return directories.map((directory) => {
+    const descriptor = classifyDirectory(directory);
+    if (descriptor.kind !== "directory") return directory;
+    const identity = (descriptor.path ? repositories.get(descriptor.path) : void 0) ?? repositories.get(directory.path);
+    return identity ? { ...directory, ...identity } : directory;
+  });
+}
+function buildProjectGeometry(index) {
+  const projects = /* @__PURE__ */ new Map();
+  const launchpads = new Set(index.directories.filter((directory) => directory.launchpad).map((directory) => directory.key));
+  const repositories = repositoryIdentitiesByPath(index);
+  const seen = /* @__PURE__ */ new Set();
+  for (const thread of index.threads) {
+    if (!isStarMapOwnerThread(thread) || seen.has(threadKey(thread))) continue;
+    seen.add(threadKey(thread));
+    const primary = thread.linkedDirectories[0];
+    const descriptor = primary ? classifyDirectory(primary) : void 0;
+    const key = descriptor?.key ?? "__no-project__";
+    let project = projects.get(key);
+    if (!project) {
+      const segments = (descriptor?.path ?? primary?.path)?.split(/[\\/]/).filter(Boolean);
+      const repositoryKey = (descriptor?.path ? repositories.get(descriptor.path)?.repositoryKey : void 0) ?? (primary?.path ? repositories.get(primary.path)?.repositoryKey : void 0);
+      project = {
+        key,
+        kind: descriptor?.kind ?? "unlinked",
+        label: descriptor ? descriptor.label !== primary?.label ? descriptor.label : segments?.at(-1) ?? descriptor.label : "No project",
+        path: descriptor?.path,
+        ...repositoryKey ? { repositoryKey } : {},
+        counts: { total: 0, active: 0, unread: 0, review: 0 },
+        pinnedRootCount: 0,
+        unpinnedRootCount: 0,
+        launchpadPresent: launchpads.has(key)
+      };
+      projects.set(key, project);
+    }
+    project.counts.total += 1;
+    const active = isActive(thread);
+    if (active) project.counts.active += 1;
+    if (thread.inbox.inInbox) {
+      project.counts.unread += 1;
+      if (!active) project.counts.review += 1;
+    }
+    if (!thread.parentThreadId) {
+      if (thread.pinnedRank !== void 0) project.pinnedRootCount += 1;
+      else project.unpinnedRootCount += 1;
+    }
+    project.latestUpdatedAt = Math.max(project.latestUpdatedAt ?? 0, thread.updatedAt ?? 0);
+  }
+  return [...projects.values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+function normalizeQuery(query) {
+  if (query.kind === "group-members") return { ...query, roots: [...query.roots].sort((left, right) => identityKey(left).localeCompare(identityKey(right))) };
+  if (query.kind === "messaging-threads" || query.kind === "messaging-projects") {
+    return {
+      ...query,
+      filter: query.filter?.trim().toLowerCase() || void 0,
+      ...query.allowedBackends ? { allowedBackends: [...new Set(query.allowedBackends)].sort() } : {}
+    };
+  }
+  if (query.kind === "star-map") {
+    return { kind: "star-map", ...query.projectKey !== void 0 ? { projectKey: query.projectKey } : {}, filters: Object.fromEntries(Object.entries(query.filters).filter(([, value]) => value !== "neutral").sort(([left], [right]) => left.localeCompare(right))) };
+  }
+  if (query.kind === "lens" || query.kind === "directory-index") {
+    return {
+      ...query,
+      ...query.kind === "directory-index" && query.keys ? { keys: [...new Set(query.keys)].sort() } : {},
+      ...query.kind === "directory-index" && query.paths ? { paths: [...new Set(query.paths)].sort() } : {},
+      ...query.filter?.trim().toLowerCase() ? { filter: query.filter.trim().toLowerCase() } : { filter: void 0 }
+    };
+  }
+  if (query.kind === "search") {
+    return { ...query, text: query.text.trim().toLowerCase() };
+  }
+  if (query.kind === "directory") {
+    return {
+      ...query,
+      roots: query.roots ?? "all",
+      disclosedParentThreadKeys: [
+        ...new Set(query.disclosedParentThreadKeys ?? [])
+      ].sort()
+    };
+  }
+  if (query.kind === "exact") {
+    return {
+      ...query,
+      identities: [...query.identities].sort((left, right) => identityKey(left).localeCompare(identityKey(right)))
+    };
+  }
+  return query;
+}
+function navigationQueryKey(request) {
+  return hashValue({
+    inventory: request.inventory ?? "owner",
+    backend: request.backend ?? "all",
+    attentionView: request.attentionView,
+    query: normalizeQuery(request.query)
+  });
+}
+function rowOrderKey(index) {
+  return index.toString(36).padStart(10, "0");
+}
+function compareUpdated(left, right) {
+  return (right.updatedAt ?? 0) - (left.updatedAt ?? 0) || threadKey(left).localeCompare(threadKey(right));
+}
+function compareCreated(left, right) {
+  return (right.createdAt ?? 0) - (left.createdAt ?? 0) || threadKey(left).localeCompare(threadKey(right));
+}
+function compareDirectoryMembers(left, right) {
+  if (Boolean(left.pinnedRank) !== Boolean(right.pinnedRank)) {
+    return left.pinnedRank ? -1 : 1;
+  }
+  if (left.pinnedRank && right.pinnedRank) {
+    const pinned = comparePinnedThreads(left, right);
+    if (pinned !== 0) return pinned;
+  }
+  return compareCreated(left, right);
+}
+function isStarMapOwnerThread(thread) {
+  return isOrdinaryThread(thread) && thread.archivedAt === void 0 && thread.federation?.ref.target.scope !== "remote";
+}
+function starMapProjectKey(thread) {
+  const primary = thread.linkedDirectories[0];
+  return primary ? classifyDirectory(primary).key : "__no-project__";
+}
+function starMapSignals(thread, index) {
+  const active = isActive(thread);
+  const unread = thread.inbox.inInbox && thread.inbox.reason === "updated-since-seen";
+  return {
+    active,
+    unread,
+    attention: active || unread,
+    approval: !thread.federation && (index.inputRequestThreadKeys?.has(buildThreadIdentityKey(thread.source, thread.id)) ?? false),
+    pr: thread.prs?.some((pr2) => pr2.state !== "merged" && pr2.state !== "closed" && pr2.lifecycleState !== "merged" && pr2.lifecycleState !== "closed") ?? false,
+    unpushed: (thread.gitWorkingState?.unpushedCommits ?? 0) > 0,
+    pinned: thread.pinnedRank !== void 0,
+    agent: thread.agent !== void 0
+  };
+}
+function selectQueryThreads(params) {
+  const ordinaryThreads = params.index.threads.filter(isOrdinaryThread);
+  const query = params.query;
+  if (query.kind === "messaging-threads" || query.kind === "messaging-projects") {
+    const directory = query.directoryKey ? params.index.directories.find((candidate) => candidate.key === query.directoryKey || candidate.path === query.directoryKey) : void 0;
+    const members = directory ? new Set(directory.threadKeys.flatMap((key) => {
+      const thread = params.threadsByLegacyKey.get(key);
+      return thread ? [threadKey(thread)] : [];
+    })) : void 0;
+    const filter = query.kind === "messaging-threads" ? query.filter?.trim().toLowerCase() : void 0;
+    return ordinaryThreads.filter((thread) => {
+      if (query.agentOnly && !thread.agent) return false;
+      if (query.excludeFullAccess && thread.executionMode === "full-access") return false;
+      if (query.allowedBackends && !query.allowedBackends.includes(thread.source)) return false;
+      if (query.directoryKey && (!members || !members.has(threadKey(thread)))) return false;
+      return !filter || [
+        thread.id,
+        thread.title,
+        thread.summary,
+        thread.agent?.name,
+        thread.agent?.instructions,
+        thread.projectKey,
+        ...thread.linkedDirectories.flatMap((linked) => [linked.label, linked.path, linked.worktreePath])
+      ].some((value) => value?.toLowerCase().includes(filter));
+    }).sort(compareUpdated);
+  }
+  if (query.kind === "directory-index" || query.kind === "star-map-geometry" || query.kind === "model-inventory") {
+    return [];
+  }
+  if (query.kind === "star-map") {
+    return ordinaryThreads.filter(isStarMapOwnerThread).filter((thread) => query.projectKey === void 0 || starMapProjectKey(thread) === query.projectKey).filter((thread) => thread.pinnedRank !== void 0 && query.filters.pinned !== "exclude" || passesNavigationStarMapFilters(starMapSignals(thread, params.index), query.filters)).sort((left, right) => {
+      if (left.pinnedRank !== void 0 !== (right.pinnedRank !== void 0)) return left.pinnedRank !== void 0 ? -1 : 1;
+      return left.pinnedRank !== void 0 && right.pinnedRank !== void 0 ? comparePinnedThreads(left, right) : compareUpdated(left, right);
+    });
+  }
+  if (query.kind === "lens") {
+    const filter = query.filter?.trim().toLowerCase();
+    const rootOf = params.lensRootOf;
+    const threads = ordinaryThreads.filter((thread) => {
+      if (query.lens === "attention") {
+        if (!isActive(thread) && !thread.inbox.inInbox) return false;
+      }
+      if (rootOf && rootOf(thread).pinnedRank !== void 0 !== (query.roots === "pinned")) return false;
+      if (!filter) return true;
+      return thread.title.toLowerCase().includes(filter) || thread.linkedDirectories.some((directory) => directory.path.toLowerCase().includes(filter));
+    });
+    if (rootOf && query.roots === "pinned") {
+      return threads.sort((left, right) => {
+        const leftRoot = rootOf(left);
+        const rightRoot = rootOf(right);
+        if (leftRoot !== rightRoot) return comparePinnedThreads(leftRoot, rightRoot);
+        if (left === leftRoot !== (right === rightRoot)) return left === leftRoot ? -1 : 1;
+        return compareCreated(left, right);
+      });
+    }
+    return threads.sort(query.lens === "recents" ? compareCreated : compareUpdated);
+  }
+  if (query.kind === "directory") {
+    const directory = params.index.directories.find(
+      (candidate) => candidate.key === query.directoryKey
+    );
+    if (!directory) return [];
+    const disclosedParents = new Set(query.disclosedParentThreadKeys ?? []);
+    const members = directoryMemberThreads(directory, params.threadsByLegacyKey);
+    const parentOf = directoryParentResolver(members, params.parentCandidates);
+    return members.filter((thread) => {
+      const parent = parentOf(thread);
+      if (parent) return disclosedParents.has(buildThreadIdentityKey(parent.backend, parent.threadId));
+      return query.roots === "pinned" ? thread.pinnedRank !== void 0 : query.roots === "unpinned" ? thread.pinnedRank === void 0 : true;
+    }).sort(compareDirectoryMembers);
+  }
+  if (query.kind === "group-members") {
+    const ordinary = new Set(ordinaryThreads);
+    const children = /* @__PURE__ */ new Map();
+    for (const thread of ordinaryThreads) {
+      const parent = parentIdentity(thread, params.parentCandidates);
+      if (!parent) continue;
+      const key = identityKey(parent);
+      const members = children.get(key) ?? [];
+      members.push(thread);
+      children.set(key, members);
+    }
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting2 = /* @__PURE__ */ new Set();
+    const visit = (ref, depth) => {
+      const key = identityKey(ref);
+      if (visited.has(key)) return;
+      if (visiting2.has(key) || depth > 32) throw new Error("Thread group has a cycle or exceeds the 32-level group budget.");
+      visiting2.add(key);
+      for (const child of children.get(key) ?? []) visit(navigationIdentity(child), depth + 1);
+      visiting2.delete(key);
+      visited.add(key);
+      const thread = params.threadsByIdentity.get(key);
+      if (thread && ordinary.has(thread)) result.push(thread);
+    };
+    for (const root of query.roots) visit(root, 0);
+    return result;
+  }
+  if (query.kind === "children") {
+    const parentThread = params.threadsByIdentity.get(identityKey(query.parent));
+    const children = ordinaryThreads.filter((thread) => {
+      const parent = parentIdentity(thread, params.parentCandidates);
+      return parent && identityKey(parent) === identityKey(query.parent);
+    });
+    return sortSubthreadSummaries(parentThread ?? {}, children);
+  }
+  if (query.kind === "search") {
+    const text = query.text.trim().toLowerCase();
+    if (!text) return [];
+    return rankThreadJumpMatches(ordinaryThreads, text);
+  }
+  const selected = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const addWithAncestry = (thread) => {
+    const key = threadKey(thread);
+    if (selected.has(key) || visiting.has(key)) return;
+    visiting.add(key);
+    const parent = parentIdentity(thread, params.parentCandidates);
+    if (query.includeAncestry && parent) {
+      const parentThread = params.threadsByIdentity.get(identityKey(parent));
+      if (parentThread) addWithAncestry(parentThread);
+    }
+    selected.set(key, thread);
+    visiting.delete(key);
+  };
+  for (const identity of query.identities.slice(0, NAVIGATION_QUERY_MAX_PAGE_ROWS)) {
+    const thread = params.threadsByIdentity.get(identityKey(identity));
+    if (thread) addWithAncestry(thread);
+  }
+  return [...selected.values()];
+}
+function buildModelInventory(threads) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const thread of threads) {
+    const model = thread.model?.trim() || void 0;
+    const key = JSON.stringify([thread.source, model, thread.modelMigrationRevision]);
+    const group = groups.get(key) ?? { backend: thread.source, model, modelMigrationRevision: thread.modelMigrationRevision, threadCount: 0, fastThreadCount: 0 };
+    group.threadCount += 1;
+    if (thread.fastMode === true || thread.serviceTier === "ultrafast") group.fastThreadCount += 1;
+    groups.set(key, group);
+  }
+  return [...groups].sort(([left], [right]) => left.localeCompare(right)).map(([, group]) => group);
+}
+function buildHomeProjects(directories, threadsByLegacyKey) {
+  const homes = /* @__PURE__ */ new Map();
+  for (const directory of directories) {
+    if (directory.kind !== "directory" || !directory.key.startsWith("directory:") || directory.localAvailability) continue;
+    const home = {
+      directoryKey: directory.key,
+      ...directory.forgeAutomation ? { forgeAutomation: directory.forgeAutomation } : {}
+    };
+    for (const key of directory.threadKeys) {
+      const thread = threadsByLegacyKey.get(key);
+      if (thread && !thread.federation && !homes.has(thread)) homes.set(thread, home);
+    }
+  }
+  return homes;
+}
+function buildThreadsByLegacyKey(index) {
+  return new Map(
+    index.threads.map((thread) => [
+      thread.federation?.ref.target.scope === "remote" ? federatedThreadIdentityKey(thread.federation.ref) : buildThreadIdentityKey(thread.source, thread.id),
+      thread
+    ])
+  );
+}
+function buildParentCandidates(index) {
+  const parentCandidates = /* @__PURE__ */ new Map();
+  for (const thread of index.threads) {
+    const ref = navigationIdentity(thread);
+    const key = JSON.stringify([ref.ownerInstanceId ?? null, ref.threadId]);
+    const candidates = parentCandidates.get(key) ?? [];
+    candidates.push(thread);
+    parentCandidates.set(key, candidates);
+    if (!ref.ownerInstanceId && index.localInstanceId) {
+      parentCandidates.set(JSON.stringify([index.localInstanceId, ref.threadId]), candidates);
+    }
+  }
+  return parentCandidates;
+}
+function explainMissingNavigationAnchor(params) {
+  const { anchor, query } = params.request;
+  if (anchor?.kind !== "thread") {
+    return anchor && !params.index.directories.some((directory2) => directory2.key === anchor.key) ? "directory-not-indexed" : "filtered";
+  }
+  const thread = params.index.threads.find((candidate) => threadKey(candidate) === identityKey(anchor.ref));
+  if (!thread) {
+    const sameId = params.index.threads.filter((candidate) => candidate.source === anchor.ref.backend && candidate.id === anchor.ref.threadId);
+    if (anchor.ref.ownerInstanceId && anchor.ref.ownerInstanceId === params.index.localInstanceId && sameId.some((candidate) => !navigationIdentity(candidate).ownerInstanceId)) return "ref-mismatch";
+    return sameId.length ? "other-owner" : "not-indexed";
+  }
+  if (query.kind !== "directory") return thread.archivedAt !== void 0 ? "archived" : "filtered";
+  const directory = params.index.directories.find((candidate) => candidate.key === query.directoryKey);
+  if (!directory) return "directory-not-indexed";
+  const threadsByLegacyKey = buildThreadsByLegacyKey(params.index);
+  if (!directory.threadKeys.some((key) => threadsByLegacyKey.get(key) === thread)) return "other-directory";
+  const parent = directoryParentResolver(directoryMemberThreads(directory, threadsByLegacyKey), buildParentCandidates(params.index))(thread);
+  if (parent) {
+    return query.disclosedParentThreadKeys?.includes(buildThreadIdentityKey(parent.backend, parent.threadId)) ? "ref-mismatch" : "child";
+  }
+  if (query.roots === "unpinned" && thread.pinnedRank !== void 0) return "pinned";
+  if (query.roots === "pinned" && thread.pinnedRank === void 0) return "unpinned";
+  return "ref-mismatch";
+}
+function projectNavigationQuery(params) {
+  const query = params.request.query;
+  if (query.kind === "model-inventory") {
+    const owned = params.index.threads.filter((thread) => isStarMapOwnerThread(thread) && (!params.request.backend || params.request.backend === "all" || params.request.backend === thread.source));
+    return { coverage: params.index.coverage ?? { state: "complete" }, counts: countsForThreads(owned), directories: [], entries: [], modelGroups: buildModelInventory(owned), queryKey: navigationQueryKey(params.request) };
+  }
+  const threadsByIdentity = new Map(
+    params.index.threads.map((thread) => [threadKey(thread), thread])
+  );
+  const threadsByLegacyKey = buildThreadsByLegacyKey(params.index);
+  const parentCandidates = buildParentCandidates(params.index);
+  const repositories = repositoryIdentitiesByPath(params.index);
+  const childCountByParent = /* @__PURE__ */ new Map();
+  const viewerChildCountByParent = /* @__PURE__ */ new Map();
+  for (const thread of params.index.threads) {
+    const parent = parentIdentity(thread, parentCandidates);
+    if (!parent || !isOrdinaryThread(thread)) continue;
+    const key = identityKey(parent);
+    childCountByParent.set(key, (childCountByParent.get(key) ?? 0) + 1);
+    if (parent.ownerInstanceId && navigationIdentity(thread).ownerInstanceId !== parent.ownerInstanceId) {
+      viewerChildCountByParent.set(key, (viewerChildCountByParent.get(key) ?? 0) + 1);
+    }
+  }
+  const lensRootOf = query.kind === "lens" && query.roots ? lensRootResolver({ threadsByIdentity, parentCandidates }) : void 0;
+  const selectedThreads = selectQueryThreads({
+    query,
+    index: params.index,
+    threadsByIdentity,
+    threadsByLegacyKey,
+    parentCandidates,
+    lensRootOf
+  });
+  if ((query.kind === "lens" && query.lens === "attention" || query.kind === "star-map" && query.filters.attention === "include") && params.attentionOrder) {
+    const members = params.attentionOrder.members;
+    selectedThreads.sort((left, right) => {
+      if (query.kind === "star-map") {
+        if (left.pinnedRank !== void 0 !== (right.pinnedRank !== void 0)) return left.pinnedRank !== void 0 ? -1 : 1;
+        if (left.pinnedRank !== void 0 && right.pinnedRank !== void 0) return comparePinnedThreads(left, right);
+      }
+      return (members.get(navigationAttentionIdentity(right))?.rank ?? 0) - (members.get(navigationAttentionIdentity(left))?.rank ?? 0);
+    });
+  }
+  if (query.kind === "messaging-projects") {
+    const eligibleKeys = new Set(selectedThreads.map(threadKey));
+    const eligibleByLegacyKey = new Map([...threadsByLegacyKey].filter(([, thread]) => eligibleKeys.has(threadKey(thread))));
+    let sourceDirectories = params.index.directories;
+    if (query.scratchpadFirst) {
+      const scratchpads = sourceDirectories.filter((directory) => directory.kind === "workspace").sort((left, right) => (right.latestUpdatedAt ?? 0) - (left.latestUpdatedAt ?? 0) || left.key.localeCompare(right.key));
+      if (scratchpads.length > 1) {
+        sourceDirectories = [
+          { ...scratchpads[0], threadKeys: [...new Set(scratchpads.flatMap((directory) => directory.threadKeys))] },
+          ...sourceDirectories.filter((directory) => directory.kind !== "workspace")
+        ];
+      }
+    }
+    const filter = query.filter?.trim().toLowerCase();
+    const directories = buildDirectoryRows({ snapshot: { ...params.index, directories: sourceDirectories }, threadsByLegacyKey: eligibleByLegacyKey, parentCandidates }).filter((directory) => !filter || [
+      directory.key,
+      directory.label,
+      directory.path,
+      query.scratchpadFirst && directory.kind === "workspace" ? "Workspaces Scratchpad" : void 0
+    ].some((value) => value?.toLowerCase().includes(filter))).sort((left, right) => (query.scratchpadFirst ? Number(right.kind === "workspace") - Number(left.kind === "workspace") : 0) || (right.latestUpdatedAt ?? 0) - (left.latestUpdatedAt ?? 0) || left.label.localeCompare(right.label));
+    return {
+      coverage: params.index.coverage ?? { state: "complete" },
+      counts: countsForThreads(selectedThreads),
+      collectionSize: directories.length,
+      collectionKind: "directories",
+      directories,
+      entries: [],
+      queryKey: navigationQueryKey(params.request)
+    };
+  }
+  const attentionMemberKeys = query.kind === "lens" && query.lens === "attention" ? new Set(selectedThreads.map(threadKey)) : void 0;
+  const directoryMembers = query.kind === "directory" ? directoryMemberThreads(params.index.directories.find((directory) => directory.key === query.directoryKey), threadsByLegacyKey) : void 0;
+  const directoryParentOf = directoryMembers ? directoryParentResolver(directoryMembers, parentCandidates) : void 0;
+  const homeProjects = query.kind === "group-members" ? buildHomeProjects(params.index.directories, threadsByLegacyKey) : void 0;
+  const entries = selectedThreads.map((thread, index) => {
+    const parent = parentIdentity(thread, parentCandidates);
+    const placementParent = attentionMemberKeys && parent && !attentionMemberKeys.has(identityKey(parent)) ? void 0 : directoryParentOf ? directoryParentOf(thread) : query.kind === "exact" && query.includeAncestry ? availableParentIdentity(thread, parentCandidates, params.index.coverage) : parent;
+    return {
+      row: projectNavigationRow({
+        childCount: childCountByParent.get(threadKey(thread)) ?? 0,
+        ...params.request.inventory === "viewer" && navigationIdentity(thread).ownerInstanceId ? { viewerChildCount: viewerChildCountByParent.get(threadKey(thread)) ?? 0 } : {},
+        needsInput: starMapSignals(thread, params.index).approval,
+        repositories,
+        thread: parent?.ownerInstanceId && !thread.parentThreadInstanceId ? { ...thread, parentThreadInstanceId: parent.ownerInstanceId } : thread,
+        homeProject: homeProjects?.get(thread)
+      }),
+      orderKey: rowOrderKey(index),
+      ...params.attentionOrder?.members.has(navigationAttentionIdentity(thread)) ? { attentionRank: params.attentionOrder.members.get(navigationAttentionIdentity(thread)).rank } : {},
+      placement: placementParent ? { kind: "child", parent: placementParent } : { kind: "root" }
+    };
+  });
+  const includeDirectories = query.kind === "directory-index" || query.kind === "star-map-geometry";
+  const countsThreads = query.kind === "directory" ? directoryMembers ?? [] : query.kind === "star-map" ? query.projectKey === void 0 ? params.index.threads.filter(isStarMapOwnerThread) : selectedThreads : query.kind === "exact" || query.kind === "search" || query.kind === "messaging-threads" || query.kind === "children" || query.kind === "group-members" || query.kind === "lens" && query.roots !== void 0 ? selectedThreads : params.index.threads;
+  return {
+    coverage: params.index.coverage ?? { state: "complete" },
+    // Both pages count every owner thread, so both can say which providers
+    // the owner uses. Provider chips hide while that is a single provider.
+    counts: countsForThreads(countsThreads, {
+      backends: query.kind === "directory-index" || query.kind === "star-map" && query.projectKey === void 0
+    }),
+    ...query.kind === "directory" ? {
+      selectionDirectory: buildDirectoryRows({ snapshot: {
+        ...params.index,
+        directories: params.index.directories.filter((directory) => directory.key === query.directoryKey)
+      }, threadsByLegacyKey, parentCandidates })[0]
+    } : {},
+    ...query.kind === "exact" && selectedThreads.length ? {
+      // Resolve the canonical home from the complete compact index. A linked
+      // worktree path is not necessarily the directory key shown by the viewer.
+      selectionDirectory: buildDirectoryRows({ snapshot: {
+        ...params.index,
+        directories: params.index.directories.filter((directory) => directory.threadKeys.some((key) => selectedThreads[0] === threadsByLegacyKey.get(key)))
+      }, threadsByLegacyKey, parentCandidates })[0]
+    } : {},
+    // The split's acknowledgment as well as its size: an owner that predates
+    // `roots` sets no collection size on a lens page, so the viewer knows to
+    // filter that page itself.
+    ...lensRootOf ? { collectionSize: selectedThreads.filter((thread) => lensRootOf(thread) === thread).length } : {},
+    ...query.kind === "messaging-threads" ? {
+      collectionSize: entries.length,
+      ...query.directoryKey ? { selectionDirectory: buildDirectoryRows({ snapshot: { ...params.index, directories: params.index.directories.filter((directory) => directory.key === query.directoryKey || directory.path === query.directoryKey) }, threadsByLegacyKey, parentCandidates }).find((directory) => directory.key === query.directoryKey || directory.path === query.directoryKey) } : {}
+    } : {},
+    ...query.kind === "star-map" ? {
+      facets: countNavigationStarMapFacets(
+        [...new Map(params.index.threads.filter(isStarMapOwnerThread).map((thread) => [threadKey(thread), thread])).values()].map((thread) => starMapSignals(thread, params.index)),
+        query.filters
+      )
+    } : {},
+    ...includeDirectories ? { collectionKind: "directories" } : {},
+    directories: includeDirectories ? (query.kind === "star-map-geometry" ? buildProjectGeometry(params.index) : buildDirectoryRows({ snapshot: params.index, threadsByLegacyKey, parentCandidates })).filter((directory) => query.kind !== "directory-index" || (!query.keys && !query.paths || query.keys?.includes(directory.key) || directory.path !== void 0 && query.paths?.includes(directory.path))).filter((directory) => query.kind !== "directory-index" || !query.filter?.trim() || [directory.label, directory.path].some((value) => textMatchesJumpQuery(value, query.filter ?? ""))) : [],
+    entries,
+    queryKey: navigationQueryKey(params.request)
+  };
+}
+
+// ../owner-core/src/navigation-observation-clock.ts
+var observation = 0;
+function nextNavigationObservation() {
+  return ++observation;
+}
+function currentNavigationObservation() {
+  return observation;
+}
+
+// ../owner-core/src/navigation-query-store.ts
+var NAVIGATION_QUERY_CURSOR_IDLE_MS = 6e4;
+var NAVIGATION_QUERY_MAX_GENERATIONS = 8;
+var NAVIGATION_QUERY_MAX_RETAINED_BYTES = 32 * 1024 * 1024;
+var NAVIGATION_ATTENTION_MAX_VIEWS = 64;
+var NAVIGATION_ATTENTION_MAX_BYTES = 8 * 1024 * 1024;
+var NavigationQueryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`[${code}] ${message}`);
+    this.name = "NavigationQueryError";
+    this.code = code;
+  }
+};
+function serializedBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(value, "base64url").toString("utf8")
+    );
+    if (typeof parsed.generation !== "string" || typeof parsed.offset !== "number" || !Number.isSafeInteger(parsed.offset) || parsed.offset < 0 || typeof parsed.queryKey !== "string" || typeof parsed.scopeKey !== "string") {
+      throw new Error("invalid cursor fields");
+    }
+    return parsed;
+  } catch {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "Navigation cursor is malformed."
+    );
+  }
+}
+function validateRequest(request) {
+  if (!request || request.protocol !== NAVIGATION_QUERY_PROTOCOL_VERSION) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      `Navigation query protocol ${NAVIGATION_QUERY_PROTOCOL_VERSION} is required.`
+    );
+  }
+  if (request.inventory !== void 0 && request.inventory !== "owner" && request.inventory !== "viewer") {
+    throw new NavigationQueryError("navigation_invalid_request", "Navigation inventory must be owner or viewer.");
+  }
+  if (request.inventory === "viewer" && request.federationTarget?.scope === "remote") {
+    throw new NavigationQueryError("navigation_invalid_request", "Viewer navigation inventory is available only on this machine.");
+  }
+  if (request.attentionView !== void 0 && (typeof request.attentionView.id !== "string" || request.attentionView.id.length < 1 || request.attentionView.id.length > 128 || typeof request.attentionView.promoteOnTurnEnd !== "boolean")) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "Navigation Attention requires a bounded view identity and promotion policy."
+    );
+  }
+  if (request.pageSize !== void 0 && (!Number.isSafeInteger(request.pageSize) || request.pageSize < 1 || request.pageSize > NAVIGATION_QUERY_MAX_PAGE_ROWS)) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "Navigation page size must be between 1 and 100."
+    );
+  }
+  const range = request.retainedRange;
+  if (range && (request.cursor || request.completeBaselineRevision || typeof range.revision !== "string" || range.revision.length > 128 || typeof range.ownerEpoch !== "string" || range.ownerEpoch.length > 128 || !Number.isSafeInteger(range.start) || range.start < 0 || !Number.isSafeInteger(range.count) || range.count < 1 || !Number.isSafeInteger(range.start + range.count))) {
+    throw new NavigationQueryError("navigation_invalid_request", "Invalid retained navigation range.");
+  }
+  if (request.anchor && (request.cursor || request.completeBaselineRevision || !["thread", "directory"].includes(request.anchor.kind) || request.anchor.kind === "thread" && (!request.anchor.ref?.backend || !request.anchor.ref.threadId) || request.anchor.kind === "directory" && !request.anchor.key)) {
+    throw new NavigationQueryError("navigation_invalid_request", "Navigation rebaseline requires one explicit anchor without a cursor or unchanged baseline.");
+  }
+  if (request.query.kind === "star-map") {
+    if (request.query.projectKey !== void 0 && (typeof request.query.projectKey !== "string" || !request.query.projectKey || request.query.projectKey.length > 4096)) {
+      throw new NavigationQueryError("navigation_invalid_request", "Invalid Star Map project key.");
+    }
+    const keys = /* @__PURE__ */ new Set(["attention", "approval", "pr", "unpushed", "pinned", "agent"]);
+    if (!request.query.filters || Object.entries(request.query.filters).some(([key, value]) => !keys.has(key) || !["neutral", "include", "exclude"].includes(value))) {
+      throw new NavigationQueryError("navigation_invalid_request", "Invalid Star Map filter selection.");
+    }
+  }
+  if (request.query.kind === "messaging-threads" || request.query.kind === "messaging-projects") {
+    const query = request.query;
+    if (query.allowedBackends !== void 0 && (!Array.isArray(query.allowedBackends) || query.allowedBackends.length > 64 || query.allowedBackends.some((backend) => typeof backend !== "string" || !backend)) || query.filter !== void 0 && (typeof query.filter !== "string" || query.filter.length > 256)) {
+      throw new NavigationQueryError("navigation_invalid_request", "Messaging queries accept at most 64 backends and a 256-character filter.");
+    }
+  }
+  if (request.query.kind === "directory-index") {
+    const { keys, paths } = request.query;
+    if (keys !== void 0 && !Array.isArray(keys) || paths !== void 0 && !Array.isArray(paths) || [...keys ?? [], ...paths ?? []].length > 100 || [...keys ?? [], ...paths ?? []].some((key) => typeof key !== "string" || !key)) {
+      throw new NavigationQueryError("navigation_invalid_request", "Exact directory metadata accepts at most 100 keys or paths.");
+    }
+  }
+  if (request.query.kind === "directory" && request.query.roots !== void 0 && !["all", "pinned", "unpinned"].includes(request.query.roots)) {
+    throw new NavigationQueryError("navigation_invalid_request", "Invalid directory root disclosure.");
+  }
+  if (request.query.kind === "lens" && request.query.roots !== void 0 && !["pinned", "unpinned"].includes(request.query.roots)) {
+    throw new NavigationQueryError("navigation_invalid_request", "Invalid lens root split.");
+  }
+  if (request.query.kind === "exact" && request.query.identities.length > 100) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "An exact navigation query accepts at most 100 identities."
+    );
+  }
+  if (request.query.kind === "exact" && request.query.resolveFromOwners && (request.inventory !== "viewer" || request.federationTarget?.scope === "remote")) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "Owner-resolved navigation is available only to this machine's viewer inventory."
+    );
+  }
+  if (request.query.kind === "group-members" && (!Array.isArray(request.query.roots) || !request.query.roots.length || request.query.roots.length > 100)) {
+    throw new NavigationQueryError("navigation_invalid_request", "Group discovery accepts one to 100 root identities.");
+  }
+  if (request.query.kind === "directory" && (request.query.disclosedParentThreadKeys?.length ?? 0) > 100) {
+    throw new NavigationQueryError(
+      "navigation_invalid_request",
+      "A directory navigation query accepts at most 100 disclosures."
+    );
+  }
+}
+function fingerprintNavigationMaterialization(materialization) {
+  const hash = createHash8("sha256");
+  let retainedBytes = 0;
+  const append = (value) => {
+    retainedBytes += Buffer.byteLength(value, "utf8");
+    if (retainedBytes > NAVIGATION_QUERY_MAX_RETAINED_BYTES) {
+      throw new NavigationQueryError("navigation_busy", "Navigation query exceeds the process retained-memory budget.");
+    }
+    hash.update(value);
+  };
+  append("{");
+  let first = true;
+  for (const [key, value] of Object.entries(materialization)) {
+    if (value === void 0) continue;
+    if (!first) append(",");
+    first = false;
+    append(JSON.stringify(key));
+    append(":");
+    if (Array.isArray(value)) {
+      append("[");
+      for (let index = 0; index < value.length; index += 1) {
+        if (index) append(",");
+        append(JSON.stringify(value[index]) ?? "null");
+      }
+      append("]");
+    } else append(JSON.stringify(value));
+  }
+  append("}");
+  return { revision: hash.digest("base64url"), retainedBytes };
+}
+function pageBase(params) {
+  const { generation } = params;
+  return {
+    protocol: NAVIGATION_QUERY_PROTOCOL_VERSION,
+    queryKey: generation.materialization.queryKey,
+    generation: generation.generation,
+    ownerEpoch: params.ownerEpoch,
+    countsRevision: generation.completeRevision,
+    coverage: generation.materialization.coverage,
+    counts: generation.materialization.counts,
+    ...generation.materialization.collectionSize !== void 0 ? { collectionSize: generation.materialization.collectionSize } : {},
+    ...generation.materialization.selectionDirectory ? { selectionDirectory: generation.materialization.selectionDirectory } : {},
+    ...generation.materialization.facets ? { facets: generation.materialization.facets } : {}
+  };
+}
+var NavigationQueryStore = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  ownerEpoch = randomUUID8();
+  attentionLifetimes = /* @__PURE__ */ new Map();
+  generations = /* @__PURE__ */ new Map();
+  currentGenerationByScopeAndQuery = /* @__PURE__ */ new Map();
+  attentionViews = /* @__PURE__ */ new Map();
+  async readPage(params) {
+    validateRequest(params.request);
+    const now = this.options.now?.() ?? Date.now();
+    this.expireIdle(now);
+    const attentionKey = params.request.attentionView ? JSON.stringify([params.scopeKey, params.request.attentionView.id]) : void 0;
+    let lifetime = attentionKey ? this.attentionLifetimes.get(attentionKey) : void 0;
+    if (attentionKey && !lifetime) {
+      const bytes = [...this.attentionLifetimes.keys(), attentionKey].reduce((total, key) => total + serializedBytes(key) + 32, 0);
+      if (this.attentionLifetimes.size >= 256 || bytes > 256 * 1024) throw new NavigationQueryError("navigation_busy", "Attention lifetime admission is occupied.");
+      lifetime = {};
+      this.attentionLifetimes.set(attentionKey, lifetime);
+    }
+    if (lifetime?.closedAt !== void 0) throw new NavigationQueryError("navigation_invalid_request", "This Attention view has closed. Open a new view lifetime.");
+    const queryKey = navigationQueryKey(params.request);
+    let generation;
+    let newCurrentKey;
+    let offset = 0;
+    let anchorIndex;
+    if (params.request.cursor) {
+      const cursor = decodeCursor(params.request.cursor);
+      if (cursor.scopeKey !== params.scopeKey || cursor.queryKey !== queryKey) {
+        throw new NavigationQueryError(
+          "navigation_invalid_request",
+          "Navigation cursor does not belong to this requester and query."
+        );
+      }
+      const retained = this.generations.get(cursor.generation);
+      if (!retained) {
+        throw new NavigationQueryError(
+          "navigation_cursor_expired",
+          "Navigation cursor expired; rebaseline around the visible anchor."
+        );
+      }
+      if (retained.scopeKey !== params.scopeKey || retained.materialization.queryKey !== queryKey) {
+        throw new NavigationQueryError(
+          "navigation_invalid_request",
+          "Navigation generation does not belong to this requester and query."
+        );
+      }
+      this.options.onCursorHit?.();
+      generation = retained;
+      offset = cursor.offset;
+    } else {
+      const readStartedAt = currentNavigationObservation();
+      const index = await params.loadIndex();
+      if (lifetime?.closedAt !== void 0) throw new NavigationQueryError("navigation_invalid_request", "This Attention view closed during its owner read.");
+      anchorIndex = index;
+      const attentionOrder = this.reconcileAttentionView(params.scopeKey, params.request, index, index.observedAt ?? readStartedAt);
+      const materialization = projectNavigationQuery({
+        index,
+        request: params.request,
+        attentionOrder
+      });
+      const { revision, retainedBytes } = fingerprintNavigationMaterialization(materialization);
+      const currentKey = `${params.scopeKey}\0${queryKey}`;
+      const currentId = this.currentGenerationByScopeAndQuery.get(currentKey);
+      const current = currentId ? this.generations.get(currentId) : void 0;
+      if (current?.completeRevision === revision) {
+        generation = current;
+      } else {
+        generation = {
+          completeRevision: revision,
+          createdAt: now,
+          generation: randomUUID8(),
+          lastAccessedAt: now,
+          materialization,
+          retainedBytes,
+          scopeKey: params.scopeKey,
+          attentionViewId: params.request.attentionView?.id
+        };
+        if (generation.retainedBytes > NAVIGATION_QUERY_MAX_RETAINED_BYTES) {
+          throw new NavigationQueryError("navigation_busy", "Navigation query exceeds the process retained-memory budget.");
+        }
+        newCurrentKey = currentKey;
+      }
+      if (params.request.completeBaselineRevision && params.request.completeBaselineRevision === generation.completeRevision) {
+        const unchanged = {
+          ...pageBase({ generation, ownerEpoch: this.ownerEpoch }),
+          entries: [],
+          directories: [],
+          complete: true,
+          unchanged: true
+        };
+        this.assertPageBudget(unchanged);
+        generation.lastAccessedAt = now;
+        return unchanged;
+      }
+    }
+    const range = params.request.retainedRange;
+    if (range && range.revision === generation.completeRevision && range.ownerEpoch === this.ownerEpoch) {
+      const size = generation.materialization.modelGroups?.length ?? (generation.materialization.directories.length || generation.materialization.entries.length);
+      if (range.start + range.count > size) {
+        throw new NavigationQueryError("navigation_invalid_request", "Retained range exceeds its matching generation.");
+      }
+      const page2 = this.buildPage({
+        generation,
+        offset: range.start + range.count,
+        ownerEpoch: this.ownerEpoch,
+        pageSize: 0
+      });
+      page2.rangeStart = range.start;
+      page2.rangeUnchanged = { start: range.start, count: range.count };
+      this.assertPageBudget(page2);
+      generation.lastAccessedAt = now;
+      if (newCurrentKey && page2.nextCursor) {
+        this.retainGeneration(generation);
+        this.currentGenerationByScopeAndQuery.set(newCurrentKey, generation.generation);
+      }
+      return page2;
+    }
+    if (params.request.anchor) {
+      const anchor = params.request.anchor;
+      offset = anchor.kind === "directory" ? generation.materialization.directories.findIndex((directory) => directory.key === anchor.key) : generation.materialization.entries.findIndex(({ row }) => row.ref.backend === anchor.ref.backend && row.ref.threadId === anchor.ref.threadId && row.ref.ownerInstanceId === anchor.ref.ownerInstanceId);
+      if (offset < 0) {
+        const reason = anchorIndex ? explainMissingNavigationAnchor({ index: anchorIndex, request: params.request }) : "filtered";
+        throw new NavigationQueryError("navigation_anchor_missing", `The visible navigation anchor is no longer in this query (reason: ${reason}). Choose another item or restart this list explicitly.`);
+      }
+    }
+    generation.lastAccessedAt = now;
+    const page = this.buildPage({
+      generation,
+      offset,
+      ownerEpoch: this.ownerEpoch,
+      pageSize: params.request.pageSize ?? NAVIGATION_QUERY_MAX_PAGE_ROWS
+    });
+    if (newCurrentKey && page.nextCursor) {
+      this.retainGeneration(generation);
+      this.currentGenerationByScopeAndQuery.set(newCurrentKey, generation.generation);
+    }
+    return page;
+  }
+  /** Window teardown releases order lifetime; page expiry deliberately does not. */
+  releaseAttentionView(scopeKey, viewId) {
+    const lifetime = this.attentionLifetimes.get(JSON.stringify([scopeKey, viewId]));
+    if (lifetime) lifetime.closedAt = this.options.now?.() ?? Date.now();
+    for (const [key, generation] of this.generations) {
+      if (generation.scopeKey === scopeKey && generation.attentionViewId === viewId) this.generations.delete(key);
+    }
+    for (const [key, generationId] of this.currentGenerationByScopeAndQuery) {
+      if (!this.generations.has(generationId)) this.currentGenerationByScopeAndQuery.delete(key);
+    }
+    this.attentionViews.delete(JSON.stringify([scopeKey, viewId]));
+  }
+  /**
+   * Reads for one view overlap, and a read can be served an index whose
+   * listing began before a boundary the store already applied. The index is
+   * served and reconciled, never reread: the reducer leaves alone whatever
+   * the order observed after that listing began (see the observation clock).
+   */
+  reconcileAttentionView(scopeKey, request, index, observedAt) {
+    if (!request.attentionView) return void 0;
+    const { id, promoteOnTurnEnd } = request.attentionView;
+    const key = JSON.stringify([scopeKey, id]);
+    const previous = this.attentionViews.get(key);
+    if (previous?.failed) throw new NavigationQueryError("navigation_busy", "Attention metadata exceeded its budget. Close this view and open a new one.");
+    if (!previous && this.attentionViews.size >= NAVIGATION_ATTENTION_MAX_VIEWS) {
+      throw new NavigationQueryError("navigation_busy", "Attention view budget is occupied.");
+    }
+    const order = reconcileNavigationAttentionOrder({
+      previous: previous?.order,
+      threads: index.threads,
+      complete: !index.coverage || index.coverage.state === "complete",
+      promoteOnTurnEnd,
+      observedAt
+    });
+    if (previous && navigationAttentionOrderFollows(previous.order, observedAt)) {
+      this.options.onOvertakenRead?.();
+    }
+    const remoteMembers = index.coverage && index.coverage.state !== "complete" ? new Set(previous?.remoteMembers) : /* @__PURE__ */ new Set();
+    for (const thread of index.threads) if (thread.federation?.ref.target.scope === "remote") remoteMembers.add(navigationAttentionIdentity(thread));
+    const bytes = navigationAttentionOrderBytes(order) + serializedBytes([...remoteMembers]);
+    let retainedBytes = bytes;
+    for (const [otherKey, view] of this.attentionViews) {
+      if (otherKey !== key) retainedBytes += view.bytes;
+    }
+    if (retainedBytes > NAVIGATION_ATTENTION_MAX_BYTES) {
+      throw new NavigationQueryError("navigation_busy", "Attention metadata exceeds its retained budget.");
+    }
+    this.attentionViews.set(key, { order, bytes, promoteOnTurnEnd, backend: request.backend, remoteMembers });
+    return order;
+  }
+  /** Boundary events maintain session ranks even while the viewer browses another lens. */
+  observeAttentionEvent(event) {
+    const method = event.notification.method;
+    const status = "status" in event.notification.params ? event.notification.params.status : void 0;
+    const active = method === "turn/started" ? true : ["turn/completed", "turn/failed", "turn/cancelled"].includes(method) ? false : method === "thread/status/changed" ? status?.type === "active" ? true : status?.type === "idle" ? false : void 0 : void 0;
+    const remove = method === "thread/archived";
+    const seen = method === "navigation/thread/seen";
+    if (active === void 0 && !remove && !seen) return;
+    const params = event.notification.params;
+    if (typeof params.threadId !== "string") return;
+    const owner = event.federationTarget?.scope === "remote" ? event.federationTarget.instanceId : null;
+    const key = JSON.stringify([owner, event.backend, params.threadId]);
+    if (owner && ![...this.attentionViews.values()].some((view) => view.remoteMembers.has(key))) return;
+    const observedAt = nextNavigationObservation();
+    let retainedBytes = [...this.attentionViews.values()].reduce((sum, view) => sum + view.bytes, 0);
+    for (const view of this.attentionViews.values()) {
+      if (view.failed || view.backend && view.backend !== "all" && view.backend !== event.backend || owner && !view.remoteMembers.has(key)) continue;
+      const member = view.order.members.get(key);
+      let order = view.order;
+      if (remove || seen && !member?.active) {
+        order = removeNavigationAttentionMember({ previous: order, key, observedAt });
+      } else if (active !== void 0) {
+        order = observeNavigationAttentionTurn({
+          previous: order,
+          key,
+          active,
+          turnId: params.turnId ?? params.turn?.id,
+          promoteOnTurnEnd: view.promoteOnTurnEnd,
+          observedAt
+        });
+      }
+      if (order === view.order) continue;
+      const bytes = navigationAttentionOrderBytes(order) + serializedBytes([...view.remoteMembers]);
+      if (retainedBytes - view.bytes + bytes > NAVIGATION_ATTENTION_MAX_BYTES) {
+        view.failed = true;
+        continue;
+      }
+      retainedBytes += bytes - view.bytes;
+      view.order = order;
+      view.bytes = bytes;
+    }
+  }
+  buildPage(params) {
+    const materialization = params.generation.materialization;
+    const collectionKind = materialization.modelGroups ? "models" : materialization.collectionKind === "directories" || materialization.directories.length > 0 ? "directories" : "entries";
+    const collection = materialization.modelGroups ?? (collectionKind === "directories" ? materialization.directories : materialization.entries);
+    if (params.offset > collection.length) {
+      throw new NavigationQueryError(
+        "navigation_invalid_request",
+        "Navigation cursor offset is outside its generation."
+      );
+    }
+    const page = {
+      ...pageBase({
+        generation: params.generation,
+        ownerEpoch: params.ownerEpoch
+      }),
+      entries: [],
+      ...params.offset ? { rangeStart: params.offset } : {},
+      ...collectionKind === "models" ? { modelGroups: [] } : collectionKind === "directories" ? { directories: [] } : {},
+      complete: false
+    };
+    let nextOffset = params.offset;
+    for (; nextOffset < collection.length && nextOffset - params.offset < params.pageSize; nextOffset += 1) {
+      const item = collection[nextOffset];
+      const candidate = collectionKind === "models" ? { ...page, modelGroups: [...page.modelGroups ?? [], item] } : collectionKind === "directories" ? {
+        ...page,
+        directories: [...page.directories ?? [], item]
+      } : {
+        ...page,
+        entries: [...page.entries, item]
+      };
+      const candidateNextOffset = nextOffset + 1;
+      if (candidateNextOffset < collection.length) {
+        candidate.nextCursor = encodeCursor({
+          generation: params.generation.generation,
+          offset: candidateNextOffset,
+          queryKey: params.generation.materialization.queryKey,
+          scopeKey: params.generation.scopeKey
+        });
+      }
+      if (serializedBytes(candidate) > NAVIGATION_QUERY_MAX_RESULT_BYTES) {
+        if (nextOffset === params.offset) {
+          throw new NavigationQueryError(
+            "navigation_item_too_large",
+            "One navigation row exceeds the result budget; read its exact detail."
+          );
+        }
+        break;
+      }
+      if (collectionKind === "models") {
+        page.modelGroups.push(item);
+      } else if (collectionKind === "directories") {
+        page.directories.push(item);
+      } else {
+        page.entries.push(item);
+      }
+    }
+    page.complete = nextOffset >= collection.length;
+    if (!page.complete) {
+      page.nextCursor = encodeCursor({
+        generation: params.generation.generation,
+        offset: nextOffset,
+        queryKey: params.generation.materialization.queryKey,
+        scopeKey: params.generation.scopeKey
+      });
+    }
+    this.assertPageBudget(page);
+    return page;
+  }
+  retainGeneration(generation) {
+    if (generation.retainedBytes > NAVIGATION_QUERY_MAX_RETAINED_BYTES) {
+      throw new NavigationQueryError(
+        "navigation_busy",
+        "Navigation query exceeds the process retained-memory budget."
+      );
+    }
+    let retainedBytes = [...this.generations.values()].reduce((total, item) => total + item.retainedBytes, 0);
+    const currentIds = new Set(this.currentGenerationByScopeAndQuery.values());
+    const evictable = [...this.generations.values()].sort((left, right) => Number(currentIds.has(left.generation)) - Number(currentIds.has(right.generation)) || left.lastAccessedAt - right.lastAccessedAt);
+    while (this.generations.size >= NAVIGATION_QUERY_MAX_GENERATIONS || retainedBytes + generation.retainedBytes > NAVIGATION_QUERY_MAX_RETAINED_BYTES) {
+      const oldest = evictable.shift();
+      if (!oldest) break;
+      this.generations.delete(oldest.generation);
+      retainedBytes -= oldest.retainedBytes;
+      for (const [key, id] of this.currentGenerationByScopeAndQuery) {
+        if (id === oldest.generation) this.currentGenerationByScopeAndQuery.delete(key);
+      }
+    }
+    this.generations.set(generation.generation, generation);
+    return generation;
+  }
+  expireIdle(now) {
+    for (const [key, lifetime] of this.attentionLifetimes) {
+      if (lifetime.closedAt !== void 0 && now - lifetime.closedAt > NAVIGATION_QUERY_CURSOR_IDLE_MS) this.attentionLifetimes.delete(key);
+    }
+    for (const generation of this.generations.values()) {
+      if (now - generation.lastAccessedAt <= NAVIGATION_QUERY_CURSOR_IDLE_MS) {
+        continue;
+      }
+      this.generations.delete(generation.generation);
+    }
+    for (const [key, generationId] of this.currentGenerationByScopeAndQuery) {
+      if (!this.generations.has(generationId)) {
+        this.currentGenerationByScopeAndQuery.delete(key);
+      }
+    }
+  }
+  assertPageBudget(page) {
+    if (serializedBytes(page) > NAVIGATION_QUERY_MAX_RESULT_BYTES) {
+      throw new NavigationQueryError(
+        "navigation_item_too_large",
+        "Navigation response exceeds the result budget."
+      );
+    }
+  }
+};
 export {
   AgentToolRouter,
   FEDERATION_BACKEND_METHOD_CAPABILITIES,
@@ -20140,6 +21907,8 @@ export {
   FederationRouter,
   FederationRpcEndpoint,
   FederationSocketKeepalive,
+  NAVIGATION_QUERY_MAX_RESULT_BYTES,
+  NavigationQueryStore,
   NoiseIKHandshake,
   PWRAGENT_MESSAGING_UNAVAILABLE_MESSAGE,
   PWRAGENT_MODEL_DIRECTED_PDF_OPERATION_NAMES,
@@ -20158,6 +21927,7 @@ export {
   buildPwrAgentMessagingPdfToolRouter,
   buildPwrAgentMessagingToolDefinitions,
   buildPwrAgentMessagingToolRouter,
+  buildThreadIdentityKey,
   completeFederationEnrollment,
   connectFederationClient,
   createFederationEnrollmentInvite,