overlord-cli 0.2608120914.0 → 0.2608121828.0

package/dist/index.js

@@ -262,16 +262,16 @@ function resolveCommandArgs({
   return parsed;
 }
 function normalizeVersion(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
+  const trimmed5 = raw.trim();
+  if (!trimmed5) {
     throw new CliError({ message: "Received an empty version from npm." });
   }
   try {
-    const parsed = JSON.parse(trimmed);
+    const parsed = JSON.parse(trimmed5);
     if (typeof parsed === "string" && parsed.trim()) return parsed.trim();
   } catch {
   }
-  return trimmed.replace(/^"+|"+$/g, "");
+  return trimmed5.replace(/^"+|"+$/g, "");
 }
 function compareVersions(left, right) {
   const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
@@ -1330,11 +1330,11 @@ import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, wr
 import os from "node:os";
 import path3 from "node:path";
 function normalizeBackendUrl(value) {
-  const trimmed = value.trim().replace(/\/+$/, "");
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
-    return trimmed;
+  const trimmed5 = value.trim().replace(/\/+$/, "");
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed5)) {
+    return trimmed5;
   }
-  return `http://${trimmed}`;
+  return `http://${trimmed5}`;
 }
 function isLoopbackBackendUrl(backendUrl) {
   try {
@@ -2396,12 +2396,12 @@ function parseConnectorManifestYaml(text) {
   };
   for (const rawLine of text.split("\n")) {
     const line = rawLine.replace(/\r$/, "");
-    const trimmed = line.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const trimmed5 = line.trim();
+    if (trimmed5 === "" || trimmed5.startsWith("#")) continue;
     const indent = line.length - line.trimStart().length;
     if (pending) {
       if (indent > pending.indent) {
-        const container = trimmed.startsWith("- ") ? [] : {};
+        const container = trimmed5.startsWith("- ") ? [] : {};
         pending.parent[pending.key] = container;
         stack.push({ indent, container });
         pending = null;
@@ -2414,16 +2414,16 @@ function parseConnectorManifestYaml(text) {
       stack.pop();
     }
     const frame = stack[stack.length - 1];
-    if (trimmed.startsWith("- ")) {
+    if (trimmed5.startsWith("- ")) {
       if (Array.isArray(frame.container)) {
-        frame.container.push(parseScalar(trimmed.slice(2)));
+        frame.container.push(parseScalar(trimmed5.slice(2)));
       }
       continue;
     }
-    const colon = trimmed.indexOf(":");
+    const colon = trimmed5.indexOf(":");
     if (colon < 0 || Array.isArray(frame.container)) continue;
-    const key = trimmed.slice(0, colon).trim();
-    const rest = trimmed.slice(colon + 1).trim();
+    const key = trimmed5.slice(0, colon).trim();
+    const rest = trimmed5.slice(colon + 1).trim();
     if (rest === "") {
       pending = { parent: frame.container, key, indent };
     } else {
@@ -2645,10 +2645,10 @@ ${managedBlock}
 
 ${after}`;
   }
-  const trimmed = existingContent.trimEnd();
-  if (!trimmed) return `${managedBlock}
+  const trimmed5 = existingContent.trimEnd();
+  if (!trimmed5) return `${managedBlock}
 `;
-  return `${trimmed}
+  return `${trimmed5}
 
 ${managedBlock}
 `;
@@ -3158,12 +3158,12 @@ function createBackendClient() {
   const clientDevice = clientDeviceIdentity();
   async function request({
     method,
-    path: path32,
+    path: path34,
     body,
     extraHeaders,
     rawBody
   }) {
-    const url = `${baseUrl}${path32.startsWith("/") ? path32 : `/${path32}`}`;
+    const url = `${baseUrl}${path34.startsWith("/") ? path34 : `/${path34}`}`;
     const auth = resolveAuthHeaders({ baseUrl });
     let response;
     try {
@@ -3190,14 +3190,14 @@ Start the Desktop/local backend or run \`ovld config set cloud <url>\`.
     const payload = await readResponseJson2(response);
     if (!response.ok) {
       if (response.status === 401 && auth.headers.Authorization) {
-        const detail = errorMessageFromJson2(payload) ?? `Backend request failed: ${method} ${path32} (${response.status})`;
+        const detail = errorMessageFromJson2(payload) ?? `Backend request failed: ${method} ${path34} (${response.status})`;
         throw new CliError({
           message: `${detail}
 ` + (auth.fromStored ? "Your saved credentials were rejected. Run `ovld auth login` to sign in again." : "Run `ovld auth login` or refresh your USER_TOKEN environment variable.")
         });
       }
       throw new CliError({
-        message: errorMessageFromJson2(payload) ?? `Backend request failed: ${method} ${path32} (${response.status})`
+        message: errorMessageFromJson2(payload) ?? `Backend request failed: ${method} ${path34} (${response.status})`
       });
     }
     return payload;
@@ -3205,13 +3205,13 @@ Start the Desktop/local backend or run \`ovld config set cloud <url>\`.
   return {
     baseUrl,
     health: () => request({ method: "GET", path: "/api/health" }),
-    get: (path32) => request({ method: "GET", path: path32 }),
-    post: ({ path: path32, body }) => request({ method: "POST", path: path32, body }),
-    patch: ({ path: path32, body }) => request({ method: "PATCH", path: path32, body }),
-    delete: (path32) => request({ method: "DELETE", path: path32 }),
-    postRaw: ({ path: path32, body, contentType, filename }) => request({
+    get: (path34) => request({ method: "GET", path: path34 }),
+    post: ({ path: path34, body }) => request({ method: "POST", path: path34, body }),
+    patch: ({ path: path34, body }) => request({ method: "PATCH", path: path34, body }),
+    delete: (path34) => request({ method: "DELETE", path: path34 }),
+    postRaw: ({ path: path34, body, contentType, filename }) => request({
       method: "POST",
-      path: path32,
+      path: path34,
       rawBody: body,
       extraHeaders: {
         "Content-Type": contentType || "application/octet-stream",
@@ -5574,8 +5574,8 @@ function resolveNativeSessionId({
   env = process.env
 }) {
   if (explicit !== void 0) {
-    const trimmed = explicit.trim();
-    return trimmed === "null" ? null : trimmed || void 0;
+    const trimmed5 = explicit.trim();
+    return trimmed5 === "null" ? null : trimmed5 || void 0;
   }
   const normalizedAgent = agent.toLowerCase();
   if (normalizedAgent === "codex") {
@@ -6443,11 +6443,11 @@ function createChannelClient({
   token
 }) {
   const root = `${baseUrl.replace(/\/+$/, "")}/api/agent-session-channels/v1`;
-  async function request(method, path32, body, timeoutMs) {
+  async function request(method, path34, body, timeoutMs) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await fetch(`${root}${path32}`, {
+      const response = await fetch(`${root}${path34}`, {
         method,
         // The credential travels here and only here: an Authorization header on a request the
         // CLI itself constructs. Not in the URL, which lands in access logs; not in the body,
@@ -6473,8 +6473,8 @@ function createChannelClient({
     }
   }
   return {
-    post: (path32, body, options) => request("POST", path32, body ?? {}, options?.timeoutMs ?? DEFAULT_TIMEOUT_MS),
-    get: (path32, options) => request("GET", path32, void 0, options?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    post: (path34, body, options) => request("POST", path34, body ?? {}, options?.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    get: (path34, options) => request("GET", path34, void 0, options?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
   };
 }
 var DEFAULT_TIMEOUT_MS;
@@ -6573,9 +6573,9 @@ function reduceUrl(rawUrl) {
   try {
     const url = new URL(raw);
     const hadQuery = url.search !== "" || url.hash !== "";
-    const path32 = url.pathname === "/" ? "" : url.pathname;
+    const path34 = url.pathname === "/" ? "" : url.pathname;
     return {
-      display: safeText(`${url.protocol}//${url.host}${path32}`).text,
+      display: safeText(`${url.protocol}//${url.host}${path34}`).text,
       host: url.host || null,
       scheme: url.protocol.replace(/:$/, ""),
       hadQuery
@@ -6740,17 +6740,17 @@ var init_mcp = __esm({
 function describeRead({ input, projectRoot }) {
   const record = input && typeof input === "object" ? input : {};
   const raw = typeof record.file_path === "string" && record.file_path || typeof record.filePath === "string" && record.filePath || typeof record.path === "string" && record.path || typeof record.notebook_path === "string" && record.notebook_path || null;
-  const path32 = reducePath(raw, projectRoot);
+  const path34 = reducePath(raw, projectRoot);
   const markers = [
-    path32?.outsideProject && "outside-project-directory",
-    path32?.nonAscii && "non-ascii-path"
+    path34?.outsideProject && "outside-project-directory",
+    path34?.nonAscii && "non-ascii-path"
   ];
-  if (path32 && /(^|\/)(\.env|\.npmrc|\.netrc|id_rsa|id_ed25519|credentials)(\.|$)/.test(path32.display)) {
+  if (path34 && /(^|\/)(\.env|\.npmrc|\.netrc|id_rsa|id_ed25519|credentials)(\.|$)/.test(path34.display)) {
     markers.push("secret-adjacent");
   }
   return {
     action: "Read a file",
-    subject: path32?.display ?? null,
+    subject: path34?.display ?? null,
     detail: null,
     riskMarkers: normalizeMarkers(markers)
   };
@@ -6892,21 +6892,21 @@ function isOverwrite(record) {
 }
 function describeWrite({ input, projectRoot }) {
   const record = input && typeof input === "object" ? input : {};
-  const path32 = reducePath(readPath(record), projectRoot);
+  const path34 = reducePath(readPath(record), projectRoot);
   const overwrite = isOverwrite(record);
   const bytes = byteLength(readContent(record));
   const markers = [
     overwrite && "overwrites-existing",
-    path32?.outsideProject && "outside-project-directory",
-    path32?.nonAscii && "non-ascii-path"
+    path34?.outsideProject && "outside-project-directory",
+    path34?.nonAscii && "non-ascii-path"
   ];
-  if (path32 && /(^|\/)(\.env|\.npmrc|\.netrc|id_rsa|id_ed25519|credentials)(\.|$)/.test(path32.display)) {
+  if (path34 && /(^|\/)(\.env|\.npmrc|\.netrc|id_rsa|id_ed25519|credentials)(\.|$)/.test(path34.display)) {
     markers.push("secret-adjacent");
   }
   const detail = bytes === null ? overwrite ? "replacing existing text" : null : `${bytes} byte${bytes === 1 ? "" : "s"}${overwrite ? ", replacing existing text" : ""}`;
   return {
     action: overwrite ? "Overwrite a file" : "Write a file",
-    subject: path32?.display ?? null,
+    subject: path34?.display ?? null,
     detail,
     riskMarkers: normalizeMarkers(markers)
   };
@@ -7107,8 +7107,8 @@ function readPath2(source, dotted) {
   return current;
 }
 function firstString(source, paths) {
-  for (const path32 of paths ?? []) {
-    const value = readPath2(source, path32);
+  for (const path34 of paths ?? []) {
+    const value = readPath2(source, path34);
     if (typeof value === "string" && value.trim() !== "")
       return value.trim();
   }
@@ -7187,9 +7187,9 @@ function normalizeNativeEvent({ codec, payload, nativeEventName, nativeSessionId
     sealedInput.formatterVersion = FORMATTER_VERSION;
     if (rule.fileEditKind && (tool === "write" || tool === "edit")) {
       kind = rule.fileEditKind;
-      const path32 = reducePath(readPath2(input, "file_path") ?? readPath2(input, "filePath") ?? readPath2(input, "path") ?? readPath2(input, "notebook_path"), projectRoot);
-      if (path32)
-        sealedInput.paths = [path32.display];
+      const path34 = reducePath(readPath2(input, "file_path") ?? readPath2(input, "filePath") ?? readPath2(input, "path") ?? readPath2(input, "notebook_path"), projectRoot);
+      if (path34)
+        sealedInput.paths = [path34.display];
     }
     idParts.push(tool, description.subject ?? "", description.detail ?? "");
   }
@@ -7619,8 +7619,8 @@ async function runAgentSessionInbox({
   const scope = resolveAgentSessionScope({ agent, env });
   if (!scope) return emptyResult("Empty");
   const payload = payloadRaw === void 0 ? parseNativePayload(readBoundedStdin()) : parseNativePayload(payloadRaw);
-  const path32 = resolveInjectPath({ agent, payload });
-  if (path32 === "unsupported") return emptyResult("Unsupported");
+  const path34 = resolveInjectPath({ agent, payload });
+  if (path34 === "unsupported") return emptyResult("Unsupported");
   const baseUrl = env.OVERLORD_BACKEND_URL?.trim();
   if (!baseUrl && !injectedClient) return emptyResult("Empty");
   const client = injectedClient ?? createChannelClient({ baseUrl, channelId: scope.channelId, token: scope.token });
@@ -7634,15 +7634,15 @@ async function runAgentSessionInbox({
   );
   if (!claimed.ok || !claimed.value.input) return emptyResult("Empty");
   const input = claimed.value.input;
-  return await emitClaimedInput({ agent, path: path32, input, client });
+  return await emitClaimedInput({ agent, path: path34, input, client });
 }
 async function emitClaimedInput({
   agent,
-  path: path32,
+  path: path34,
   input,
   client
 }) {
-  if (path32 === "claude-mid-turn") {
+  if (path34 === "claude-mid-turn") {
     const emitted = await client.post(`/inputs/${input.id}/emitted`, {
       leaseId: input.leaseId,
       deliveryOutcome: "delivered"
@@ -7657,7 +7657,7 @@ async function emitClaimedInput({
       inputId: input.id
     };
   }
-  if (path32 === "claude-turn-boundary") {
+  if (path34 === "claude-turn-boundary") {
     const emitted = await client.post(`/inputs/${input.id}/emitted`, {
       leaseId: input.leaseId,
       deliveryOutcome: "delivered"
@@ -7672,7 +7672,7 @@ async function emitClaimedInput({
       inputId: input.id
     };
   }
-  if (path32 === "cursor-turn-boundary") {
+  if (path34 === "cursor-turn-boundary") {
     const emitted = await client.post(`/inputs/${input.id}/emitted`, {
       leaseId: input.leaseId,
       deliveryOutcome: "queued_turn_boundary"
@@ -7686,7 +7686,7 @@ async function emitClaimedInput({
       inputId: input.id
     };
   }
-  if (path32 === "codex-turn-boundary") {
+  if (path34 === "codex-turn-boundary") {
     const emitted = await client.post(`/inputs/${input.id}/emitted`, {
       leaseId: input.leaseId,
       deliveryOutcome: "delivered"
@@ -7701,7 +7701,7 @@ async function emitClaimedInput({
       inputId: input.id
     };
   }
-  if (path32 === "pi-mid-turn") {
+  if (path34 === "pi-mid-turn") {
     return {
       report: "Empty",
       exitCode: 0,
@@ -7806,8 +7806,8 @@ var init_inbox = __esm({
 
 // ../packages/core/dist/service/agent-session/pure/decision.js
 function firstValue(source, paths) {
-  for (const path32 of paths ?? []) {
-    const value = readPath2(source, path32);
+  for (const path34 of paths ?? []) {
+    const value = readPath2(source, path34);
     if (value !== void 0 && value !== null)
       return value;
   }
@@ -8397,10 +8397,10 @@ async function reconcileState({
 }) {
   let posted = 0;
   let duplicates = 0;
-  for (const path32 of ["/permission", "/question"]) {
+  for (const path34 of ["/permission", "/question"]) {
     let entries;
     try {
-      const response = await doFetch(`${controlPlaneBaseUrl(port)}${path32}`, {
+      const response = await doFetch(`${controlPlaneBaseUrl(port)}${path34}`, {
         headers: authHeaders(password)
       });
       if (!response.ok) continue;
@@ -8410,7 +8410,7 @@ async function reconcileState({
       continue;
     }
     for (const entry of entries) {
-      if (path32 === "/permission") {
+      if (path34 === "/permission") {
         await syncOpenCodePermission({
           client,
           frame: { event: "permission.updated", data: JSON.stringify(entry) },
@@ -8933,17 +8933,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path32) {
-      const ctrl = callVisitor(key, node, visitor, path32);
+    function visit_(key, node, visitor, path34) {
+      const ctrl = callVisitor(key, node, visitor, path34);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path32, ctrl);
-        return visit_(key, ctrl, visitor, path32);
+        replaceNode(key, path34, ctrl);
+        return visit_(key, ctrl, visitor, path34);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path32 = Object.freeze(path32.concat(node));
+          path34 = Object.freeze(path34.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path32);
+            const ci = visit_(i, node.items[i], visitor, path34);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -8954,13 +8954,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path32 = Object.freeze(path32.concat(node));
-          const ck = visit_("key", node.key, visitor, path32);
+          path34 = Object.freeze(path34.concat(node));
+          const ck = visit_("key", node.key, visitor, path34);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path32);
+          const cv = visit_("value", node.value, visitor, path34);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -8981,17 +8981,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path32) {
-      const ctrl = await callVisitor(key, node, visitor, path32);
+    async function visitAsync_(key, node, visitor, path34) {
+      const ctrl = await callVisitor(key, node, visitor, path34);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path32, ctrl);
-        return visitAsync_(key, ctrl, visitor, path32);
+        replaceNode(key, path34, ctrl);
+        return visitAsync_(key, ctrl, visitor, path34);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path32 = Object.freeze(path32.concat(node));
+          path34 = Object.freeze(path34.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path32);
+            const ci = await visitAsync_(i, node.items[i], visitor, path34);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -9002,13 +9002,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path32 = Object.freeze(path32.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path32);
+          path34 = Object.freeze(path34.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path34);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path32);
+          const cv = await visitAsync_("value", node.value, visitor, path34);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -9035,23 +9035,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path32) {
+    function callVisitor(key, node, visitor, path34) {
       if (typeof visitor === "function")
-        return visitor(key, node, path32);
+        return visitor(key, node, path34);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path32);
+        return visitor.Map?.(key, node, path34);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path32);
+        return visitor.Seq?.(key, node, path34);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path32);
+        return visitor.Pair?.(key, node, path34);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path32);
+        return visitor.Scalar?.(key, node, path34);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path32);
+        return visitor.Alias?.(key, node, path34);
       return void 0;
     }
-    function replaceNode(key, path32, node) {
-      const parent = path32[path32.length - 1];
+    function replaceNode(key, path34, node) {
+      const parent = path34[path34.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -9661,10 +9661,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path32, value) {
+    function collectionFromPath(schema, path34, value) {
       let v = value;
-      for (let i = path32.length - 1; i >= 0; --i) {
-        const k = path32[i];
+      for (let i = path34.length - 1; i >= 0; --i) {
+        const k = path34[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -9683,7 +9683,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path32) => path32 == null || typeof path32 === "object" && !!path32[Symbol.iterator]().next().done;
+    var isEmptyPath = (path34) => path34 == null || typeof path34 === "object" && !!path34[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -9713,11 +9713,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path32, value) {
-        if (isEmptyPath(path32))
+      addIn(path34, value) {
+        if (isEmptyPath(path34))
           this.add(value);
         else {
-          const [key, ...rest] = path32;
+          const [key, ...rest] = path34;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -9731,8 +9731,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path32) {
-        const [key, ...rest] = path32;
+      deleteIn(path34) {
+        const [key, ...rest] = path34;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -9746,8 +9746,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path32, keepScalar) {
-        const [key, ...rest] = path32;
+      getIn(path34, keepScalar) {
+        const [key, ...rest] = path34;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -9765,8 +9765,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path32) {
-        const [key, ...rest] = path32;
+      hasIn(path34) {
+        const [key, ...rest] = path34;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -9776,8 +9776,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path32, value) {
-        const [key, ...rest] = path32;
+      setIn(path34, value) {
+        const [key, ...rest] = path34;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -12292,9 +12292,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path32, value) {
+      addIn(path34, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path32, value);
+          this.contents.addIn(path34, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -12369,14 +12369,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path32) {
-        if (Collection.isEmptyPath(path32)) {
+      deleteIn(path34) {
+        if (Collection.isEmptyPath(path34)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path32) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path34) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -12391,10 +12391,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path32, keepScalar) {
-        if (Collection.isEmptyPath(path32))
+      getIn(path34, keepScalar) {
+        if (Collection.isEmptyPath(path34))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path32, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path34, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -12405,10 +12405,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path32) {
-        if (Collection.isEmptyPath(path32))
+      hasIn(path34) {
+        if (Collection.isEmptyPath(path34))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path32) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path34) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -12425,13 +12425,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path32, value) {
-        if (Collection.isEmptyPath(path32)) {
+      setIn(path34, value) {
+        if (Collection.isEmptyPath(path34)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path32), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path34), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path32, value);
+          this.contents.setIn(path34, value);
         }
       }
       /**
@@ -14391,9 +14391,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path32) => {
+    visit.itemAtPath = (cst, path34) => {
       let item = cst;
-      for (const [field, index] of path32) {
+      for (const [field, index] of path34) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -14402,23 +14402,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path32) => {
-      const parent = visit.itemAtPath(cst, path32.slice(0, -1));
-      const field = path32[path32.length - 1][0];
+    visit.parentCollection = (cst, path34) => {
+      const parent = visit.itemAtPath(cst, path34.slice(0, -1));
+      const field = path34[path34.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path32, item, visitor) {
-      let ctrl = visitor(item, path32);
+    function _visit(path34, item, visitor) {
+      let ctrl = visitor(item, path34);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path32.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path34.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -14429,10 +14429,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path32);
+            ctrl = ctrl(item, path34);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path32) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path34) : ctrl;
     }
     exports.visit = visit;
   }
@@ -16343,22 +16343,22 @@ var init_contract = __esm({
 
 // ../packages/contract/dist/agent-launch-flags.js
 function parseAgentLaunchFlagText(text) {
-  const trimmed = text.trim();
-  if (!trimmed)
+  const trimmed5 = text.trim();
+  if (!trimmed5)
     return null;
-  const eqIndex = trimmed.indexOf("=");
-  if (eqIndex > 0 && trimmed.startsWith("--")) {
-    const name = trimmed.slice(0, eqIndex).trim();
-    const value = trimmed.slice(eqIndex + 1).trim();
+  const eqIndex = trimmed5.indexOf("=");
+  if (eqIndex > 0 && trimmed5.startsWith("--")) {
+    const name = trimmed5.slice(0, eqIndex).trim();
+    const value = trimmed5.slice(eqIndex + 1).trim();
     return name ? { name, value: value.length > 0 ? value : null } : null;
   }
-  const spaceIndex = trimmed.indexOf(" ");
-  if (spaceIndex > 0 && trimmed.startsWith("--")) {
-    const name = trimmed.slice(0, spaceIndex).trim();
-    const value = trimmed.slice(spaceIndex + 1).trim();
+  const spaceIndex = trimmed5.indexOf(" ");
+  if (spaceIndex > 0 && trimmed5.startsWith("--")) {
+    const name = trimmed5.slice(0, spaceIndex).trim();
+    const value = trimmed5.slice(spaceIndex + 1).trim();
     return name ? { name, value: value.length > 0 ? value : null } : null;
   }
-  return { name: trimmed };
+  return { name: trimmed5 };
 }
 function normalizeAgentLaunchFlags(input) {
   if (!Array.isArray(input))
@@ -16508,12 +16508,12 @@ function accessModeToResourcePathPermission({ accessMode, isPrimary = false }) {
     return "rw";
   return accessMode === "read" ? "ro" : "rw";
 }
-function formatResourcePathWithPermission({ path: path32, accessMode, isPrimary = false }) {
-  const trimmed = path32.trim();
-  if (!trimmed)
+function formatResourcePathWithPermission({ path: path34, accessMode, isPrimary = false }) {
+  const trimmed5 = path34.trim();
+  if (!trimmed5)
     return "";
   const permission = accessModeToResourcePathPermission({ accessMode, isPrimary });
-  return `${trimmed}:${permission}`;
+  return `${trimmed5}:${permission}`;
 }
 function formatProjectResourcePathsFromManifest(projectResources) {
   if (!Array.isArray(projectResources))
@@ -16523,11 +16523,11 @@ function formatProjectResourcePathsFromManifest(projectResources) {
     if (!entry || typeof entry !== "object")
       continue;
     const record = entry;
-    const path32 = typeof record.path === "string" ? record.path.trim() : "";
-    if (!path32)
+    const path34 = typeof record.path === "string" ? record.path.trim() : "";
+    if (!path34)
       continue;
     paths.push(formatResourcePathWithPermission({
-      path: path32,
+      path: path34,
       accessMode: typeof record.accessMode === "string" ? record.accessMode : null,
       isPrimary: record.isPrimary === true
     }));
@@ -16784,11 +16784,545 @@ var init_git_tree = __esm({
   }
 });
 
-// ../packages/core/dist/service/local-target/git-run.js
+// ../packages/core/dist/service/terminal-profile-types.js
+function trimmed(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function viewerKindForLauncher(launcher) {
+  const value = trimmed(launcher);
+  if (!value)
+    return "inline";
+  const lowered = value.toLowerCase();
+  if (lowered === "iterm2" || lowered === "iterm")
+    return "iterm";
+  if (lowered === "terminal")
+    return "terminal";
+  return "custom";
+}
+function normalizeExecutionProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const cast = value;
+  const kind = trimmed(cast.kind)?.toLowerCase() === "latch" ? "latch" : "direct";
+  return {
+    kind,
+    executable: trimmed(cast.executable) ?? DEFAULT_LATCH_EXECUTABLE
+  };
+}
+function launchSessionSnapshotFromMetadata(metadata) {
+  const raw = metadata?.[LAUNCH_SESSION_METADATA_KEY];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  const cast = raw;
+  if (cast.version !== TERMINAL_PROFILE_VERSION)
+    return null;
+  const viewer = cast.viewer && typeof cast.viewer === "object" && !Array.isArray(cast.viewer) ? cast.viewer : null;
+  const launcher = trimmed(viewer?.launcher);
+  const source = (value) => trimmed(value) === "target" ? "target" : "user_default";
+  return {
+    version: TERMINAL_PROFILE_VERSION,
+    executionProvider: normalizeExecutionProvider(cast.executionProvider) ?? {
+      ...DEFAULT_EXECUTION_PROVIDER
+    },
+    viewer: {
+      kind: trimmed(viewer?.kind) ? trimmed(viewer?.kind) : viewerKindForLauncher(launcher),
+      launcher,
+      openOnLaunch: viewer?.openOnLaunch !== false
+    },
+    executionProviderSource: source(cast.executionProviderSource),
+    viewerOpenSource: source(cast.viewerOpenSource),
+    resolvedAt: trimmed(cast.resolvedAt) ?? ""
+  };
+}
+var TERMINAL_PROFILE_VERSION, DEFAULT_LATCH_EXECUTABLE, DEFAULT_EXECUTION_PROVIDER, DEFAULT_OPEN_VIEWER_ON_LAUNCH, DEFAULT_LAUNCH_SESSION_DEFAULTS, LAUNCH_SESSION_METADATA_KEY;
+var init_terminal_profile_types2 = __esm({
+  "../packages/core/dist/service/terminal-profile-types.js"() {
+    "use strict";
+    TERMINAL_PROFILE_VERSION = 1;
+    DEFAULT_LATCH_EXECUTABLE = "latch";
+    DEFAULT_EXECUTION_PROVIDER = {
+      kind: "direct",
+      executable: DEFAULT_LATCH_EXECUTABLE
+    };
+    DEFAULT_OPEN_VIEWER_ON_LAUNCH = true;
+    DEFAULT_LAUNCH_SESSION_DEFAULTS = {
+      executionProvider: { ...DEFAULT_EXECUTION_PROVIDER },
+      openViewerOnLaunch: DEFAULT_OPEN_VIEWER_ON_LAUNCH
+    };
+    LAUNCH_SESSION_METADATA_KEY = "launchSession";
+  }
+});
+
+// ../packages/core/dist/service/latch-discovery.js
 import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync15, statSync as statSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import os3 from "node:os";
+import path17 from "node:path";
+function defaultLatchDiscoveryCachePath() {
+  const home = process.env.OVLD_HOME?.trim() || path17.join(os3.homedir(), ".ovld");
+  return path17.join(home, LATCH_DISCOVERY_CACHE_FILENAME);
+}
+function trimmed2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function asBoolean(value) {
+  return value === true;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function parseLatchCapabilitiesReport(raw) {
+  const text = raw.trim();
+  if (!text)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return null;
+  const cast = parsed;
+  const protocolVersion = typeof cast.protocolVersion === "number" && Number.isFinite(cast.protocolVersion) ? Math.trunc(cast.protocolVersion) : null;
+  const productVersion = trimmed2(cast.productVersion);
+  if (protocolVersion === null || !productVersion)
+    return null;
+  if (!cast.capabilities || typeof cast.capabilities !== "object" || Array.isArray(cast.capabilities)) {
+    return null;
+  }
+  const caps = cast.capabilities;
+  return {
+    protocolVersion,
+    productVersion,
+    capabilities: {
+      create: asBoolean(caps.create),
+      openViewer: asBoolean(caps.openViewer),
+      localAttach: asBoolean(caps.localAttach),
+      cloudAttach: asBoolean(caps.cloudAttach),
+      selfUpdate: asBoolean(caps.selfUpdate),
+      extensions: asStringArray(caps.extensions)
+    }
+  };
+}
+function evaluateLatchCapabilities({ report, executable, resolvedPath, checkedAt = (/* @__PURE__ */ new Date()).toISOString() }) {
+  if (report.protocolVersion !== SUPPORTED_LATCH_PROTOCOL_VERSION) {
+    return {
+      state: "incompatible",
+      executable,
+      resolvedPath,
+      protocolVersion: report.protocolVersion,
+      productVersion: report.productVersion,
+      missingCapability: "protocolVersion",
+      detail: `Latch protocolVersion ${report.protocolVersion} is not supported (need ${SUPPORTED_LATCH_PROTOCOL_VERSION}).`,
+      checkedAt,
+      latchSelectable: false,
+      directSelectable: true
+    };
+  }
+  for (const required of REQUIRED_LATCH_CAPABILITIES) {
+    if (!report.capabilities[required]) {
+      return {
+        state: "incompatible",
+        executable,
+        resolvedPath,
+        protocolVersion: report.protocolVersion,
+        productVersion: report.productVersion,
+        missingCapability: required,
+        detail: `Latch is missing required capability \`${required}\`.`,
+        checkedAt,
+        latchSelectable: false,
+        directSelectable: true
+      };
+    }
+  }
+  return {
+    state: "found",
+    executable,
+    resolvedPath,
+    protocolVersion: report.protocolVersion,
+    productVersion: report.productVersion,
+    capabilities: report.capabilities,
+    checkedAt,
+    latchSelectable: true,
+    directSelectable: true
+  };
+}
+function resolveLatchExecutablePath(executable) {
+  const name = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  if (path17.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    return existsSync16(name) ? path17.resolve(name) : null;
+  }
+  try {
+    const found = execFileSync3("which", [name], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return found || null;
+  } catch {
+    return null;
+  }
+}
+function notInstalledResult({ executable, checkedAt }) {
+  return {
+    state: "not_installed",
+    executable,
+    installCommand: LATCH_STANDALONE_INSTALL_COMMAND,
+    checkedAt,
+    latchSelectable: false,
+    directSelectable: true
+  };
+}
+function probeLatchCapabilities({ executable = DEFAULT_LATCH_EXECUTABLE, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() } = {}) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  const checkedAt = now();
+  const resolvedPath = resolvePath(exe);
+  if (!resolvedPath) {
+    return notInstalledResult({ executable: exe, checkedAt });
+  }
+  const ran = runCommand2({ executable: resolvedPath, argv: ["capabilities", "--json"] });
+  if (ran.status === null && ran.stderr === "ENOENT") {
+    return notInstalledResult({ executable: exe, checkedAt });
+  }
+  const report = parseLatchCapabilitiesReport(ran.stdout);
+  if (!report) {
+    return {
+      state: "incompatible",
+      executable: exe,
+      resolvedPath,
+      protocolVersion: null,
+      productVersion: null,
+      missingCapability: "capabilities",
+      detail: ran.status === 0 ? "Latch capabilities output was not valid JSON in the expected shape." : `Latch capabilities failed (exit ${ran.status ?? "null"}).`,
+      checkedAt,
+      latchSelectable: false,
+      directSelectable: true
+    };
+  }
+  return evaluateLatchCapabilities({ report, executable: exe, resolvedPath, checkedAt });
+}
+function latchDiscoveryCacheKey({ executionTargetId, executable }) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  return `${executionTargetId}::${exe}`;
+}
+function readBinaryMtimeMs(resolvedPath) {
+  if (!resolvedPath)
+    return null;
+  try {
+    return statSync4(resolvedPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function isLatchDiscoveryCacheFresh({ entry, resolvePath = resolveLatchExecutablePath }) {
+  const { result } = entry;
+  if (result.state === "not_installed") {
+    return resolvePath(result.executable) === null;
+  }
+  const pathStill = result.resolvedPath;
+  if (!pathStill || !existsSync16(pathStill))
+    return false;
+  const mtime = readBinaryMtimeMs(pathStill);
+  if (mtime === null || entry.binaryMtimeMs === null)
+    return false;
+  return mtime === entry.binaryMtimeMs;
+}
+function readLatchDiscoveryCacheFile(filePath) {
+  if (!existsSync16(filePath))
+    return { version: 1, entries: {} };
+  try {
+    const parsed = JSON.parse(readFileSync15(filePath, "utf8"));
+    if (parsed.version !== 1 || !parsed.entries || typeof parsed.entries !== "object") {
+      return { version: 1, entries: {} };
+    }
+    return { version: 1, entries: parsed.entries };
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+function writeLatchDiscoveryCacheFile({ filePath, cache }) {
+  mkdirSync9(path17.dirname(filePath), { recursive: true });
+  writeFileSync8(filePath, `${JSON.stringify(cache, null, 2)}
+`, { mode: 384 });
+}
+function discoverLatchForExecutionTarget({ executionTargetId, executable = DEFAULT_LATCH_EXECUTABLE, cacheFilePath, force = false, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() }) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  const key = latchDiscoveryCacheKey({ executionTargetId, executable: exe });
+  const cache = readLatchDiscoveryCacheFile(cacheFilePath);
+  const existing = cache.entries[key];
+  if (!force && existing && isLatchDiscoveryCacheFresh({ entry: existing, resolvePath })) {
+    return { ...existing.result, checkedAt: existing.result.checkedAt, directSelectable: true };
+  }
+  const result = probeLatchCapabilities({ executable: exe, resolvePath, runCommand: runCommand2, now });
+  const binaryMtimeMs = result.state === "not_installed" ? null : readBinaryMtimeMs(result.resolvedPath);
+  cache.entries[key] = {
+    result,
+    binaryMtimeMs,
+    cachedAt: result.checkedAt
+  };
+  writeLatchDiscoveryCacheFile({ filePath: cacheFilePath, cache });
+  return result;
+}
+var SUPPORTED_LATCH_PROTOCOL_VERSION, REQUIRED_LATCH_CAPABILITIES, LATCH_STANDALONE_INSTALL_COMMAND, LATCH_DISCOVERY_CACHE_FILENAME, defaultCommandRunner;
+var init_latch_discovery = __esm({
+  "../packages/core/dist/service/latch-discovery.js"() {
+    "use strict";
+    init_terminal_profile_types2();
+    SUPPORTED_LATCH_PROTOCOL_VERSION = 1;
+    REQUIRED_LATCH_CAPABILITIES = ["create"];
+    LATCH_STANDALONE_INSTALL_COMMAND = "curl -fsSL https://raw.githubusercontent.com/jchaselubitz/Latch/main/scripts/install-cli.sh | bash";
+    LATCH_DISCOVERY_CACHE_FILENAME = "latch-discovery.json";
+    defaultCommandRunner = ({ executable, argv }) => {
+      try {
+        const stdout = execFileSync3(executable, argv, {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"],
+          timeout: 5e3
+        });
+        return { status: 0, stdout: String(stdout), stderr: "" };
+      } catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+          return { status: null, stdout: "", stderr: "ENOENT" };
+        }
+        return {
+          status: typeof err.status === "number" ? err.status : 1,
+          stdout: err.stdout ? String(err.stdout) : "",
+          stderr: err.stderr ? String(err.stderr) : String(error)
+        };
+      }
+    };
+  }
+});
+
+// ../packages/core/dist/service/latch-launch.js
+function trimmed3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.trim() || "/bin/bash", cwd, env, size = DEFAULT_LATCH_TERMINAL_SIZE, title, name, commandLabel, externalRunId }) {
+  const shellPath = trimmed3(shell) ?? "/bin/bash";
+  const cleanedEnv = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (key.trim() && typeof value === "string")
+      cleanedEnv[key] = value;
+  }
+  const display = {
+    source: {
+      kind: "overlord",
+      ...trimmed3(externalRunId) ? { external_run_id: trimmed3(externalRunId) } : {}
+    }
+  };
+  if (trimmed3(title))
+    display.title = trimmed3(title);
+  if (trimmed3(name))
+    display.name = trimmed3(name);
+  if (trimmed3(commandLabel))
+    display.command_label = trimmed3(commandLabel);
+  return {
+    format_version: LATCH_MANIFEST_FORMAT_VERSION,
+    launch: {
+      argv: [shellPath, "-lc", commandString],
+      cwd,
+      env: cleanedEnv,
+      inherit_env: true,
+      size: {
+        cols: Math.max(1, Math.floor(size.cols) || DEFAULT_LATCH_TERMINAL_SIZE.cols),
+        rows: Math.max(1, Math.floor(size.rows) || DEFAULT_LATCH_TERMINAL_SIZE.rows)
+      }
+    },
+    display
+  };
+}
+function parseLatchCreateReport(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const id = trimmed3(parsed.session?.id);
+    if (!id)
+      return null;
+    const protocolVersion = typeof parsed.protocolVersion === "number" && Number.isFinite(parsed.protocolVersion) ? parsed.protocolVersion : LATCH_MANIFEST_FORMAT_VERSION;
+    return {
+      protocolVersion,
+      session: {
+        id,
+        name: trimmed3(parsed.session?.name) ?? id,
+        state: trimmed3(parsed.session?.state) ?? "running",
+        createdAt: trimmed3(parsed.session?.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function toExecutionProviderSession({ createReport, executionTargetId, createdAt }) {
+  return {
+    provider: "latch",
+    providerSessionId: createReport.session.id,
+    sessionName: createReport.session.name,
+    executionTargetId: trimmed3(executionTargetId),
+    agentSessionId: null,
+    createdAt: createdAt ?? createReport.session.createdAt,
+    lastObservedState: createReport.session.state
+  };
+}
+function existingLatchProviderSession({ latchSessionId, executionTargetId, createdAt = (/* @__PURE__ */ new Date()).toISOString() }) {
+  const providerSessionId = trimmed3(latchSessionId);
+  if (!providerSessionId)
+    return null;
+  return {
+    provider: "latch",
+    providerSessionId,
+    sessionName: null,
+    executionTargetId: trimmed3(executionTargetId),
+    agentSessionId: null,
+    createdAt,
+    lastObservedState: "running"
+  };
+}
+function latchViewerFlagForKind(kind) {
+  switch (trimmed3(kind)?.toLowerCase()) {
+    case "iterm":
+    case "iterm2":
+      return "iterm";
+    default:
+      return null;
+  }
+}
+function latchAttachCommand({ executable = "latch", providerSessionId }) {
+  return `${trimmed3(executable) ?? "latch"} attach ${providerSessionId}`;
+}
+function shouldUseLatchProvider({ providerKind, latchSelectable }) {
+  return trimmed3(providerKind)?.toLowerCase() === "latch" && latchSelectable === true;
+}
+var LATCH_MANIFEST_FORMAT_VERSION, DEFAULT_LATCH_TERMINAL_SIZE;
+var init_latch_launch = __esm({
+  "../packages/core/dist/service/latch-launch.js"() {
+    "use strict";
+    LATCH_MANIFEST_FORMAT_VERSION = 1;
+    DEFAULT_LATCH_TERMINAL_SIZE = { cols: 120, rows: 36 };
+  }
+});
+
+// ../packages/core/dist/service/latch-session.js
+import { spawnSync as spawnSync2 } from "node:child_process";
+function trimmed4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function parseState(value) {
+  switch (trimmed4(value)) {
+    case "running":
+      return "running";
+    case "exited":
+      return "exited";
+    case "stopping":
+      return "stopping";
+    case "lost":
+      return "lost";
+    default:
+      return null;
+  }
+}
+function runLatchJson({ executable, args }) {
+  const result = spawnSync2(executable, args, {
+    encoding: "utf8",
+    shell: false,
+    timeout: 1e4,
+    maxBuffer: 1024 * 1024
+  });
+  if (result.error) {
+    throw new LatchSessionCommandError(result.error.message);
+  }
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim().slice(0, 500);
+    throw new LatchSessionCommandError(detail || "Latch command failed.");
+  }
+  try {
+    const parsed = JSON.parse(result.stdout);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("not an object");
+    }
+    return parsed;
+  } catch {
+    throw new LatchSessionCommandError("Latch returned an invalid JSON response.");
+  }
+}
+function inspectLatchSession({ executable = "latch", providerSessionId }) {
+  const sessionId = trimmed4(providerSessionId);
+  if (!sessionId)
+    throw new LatchSessionCommandError("A Latch session id is required.");
+  const report = runLatchJson({
+    executable: trimmed4(executable) ?? "latch",
+    args: ["inspect", sessionId, "--json"]
+  });
+  const state = parseState(report.state);
+  if (!state)
+    throw new LatchSessionCommandError("Latch returned an unsupported session state.");
+  const exit = report.exit && typeof report.exit === "object" && !Array.isArray(report.exit) ? report.exit : null;
+  return {
+    providerSessionId: trimmed4(report.id) ?? sessionId,
+    name: trimmed4(report.name) ?? sessionId,
+    state,
+    exitCode: typeof exit?.code === "number" && Number.isFinite(exit.code) ? exit.code : null,
+    inspectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function openLatchSession({ executable = "latch", providerSessionId, viewerKind }) {
+  const sessionId = trimmed4(providerSessionId);
+  if (!sessionId)
+    throw new LatchSessionCommandError("A Latch session id is required.");
+  const viewer = latchViewerFlagForKind(viewerKind);
+  if (!viewer) {
+    throw new LatchSessionCommandError(`Latch cannot open the configured viewer "${viewerKind}".`);
+  }
+  const report = runLatchJson({
+    executable: trimmed4(executable) ?? "latch",
+    args: ["open", sessionId, "--with", viewer, "--json"]
+  });
+  if (report.opened !== true) {
+    throw new LatchSessionCommandError(`Latch did not open the ${viewer} viewer.`);
+  }
+  return {
+    providerSessionId: trimmed4(report.id) ?? sessionId,
+    viewer: trimmed4(report.viewer) ?? viewer,
+    opened: true
+  };
+}
+function stopLatchSession({ executable = "latch", providerSessionId }) {
+  const sessionId = trimmed4(providerSessionId);
+  if (!sessionId)
+    throw new LatchSessionCommandError("A Latch session id is required.");
+  const report = runLatchJson({
+    executable: trimmed4(executable) ?? "latch",
+    args: ["stop", sessionId, "--json"]
+  });
+  const state = parseState(report.state);
+  if (!state)
+    throw new LatchSessionCommandError("Latch returned an unsupported session state.");
+  return {
+    providerSessionId: trimmed4(report.id) ?? sessionId,
+    state
+  };
+}
+var LatchSessionCommandError;
+var init_latch_session = __esm({
+  "../packages/core/dist/service/latch-session.js"() {
+    "use strict";
+    init_latch_launch();
+    LatchSessionCommandError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "LatchSessionCommandError";
+      }
+    };
+  }
+});
+
+// ../packages/core/dist/service/local-target/git-run.js
+import { execFileSync as execFileSync4 } from "node:child_process";
 function runGit2(cwd, args) {
   try {
-    return execFileSync3("git", args, {
+    return execFileSync4("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -16800,7 +17334,7 @@ function runGit2(cwd, args) {
 }
 function runGitResult(cwd, args) {
   try {
-    const stdout = execFileSync3("git", args, {
+    const stdout = execFileSync4("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -16823,13 +17357,13 @@ var init_git_run = __esm({
 });
 
 // ../packages/core/dist/service/local-target/worktree-git.js
-import { existsSync as existsSync16, realpathSync as realpathSync2 } from "node:fs";
-import path17 from "node:path";
+import { existsSync as existsSync17, realpathSync as realpathSync2 } from "node:fs";
+import path18 from "node:path";
 function resolveRealPath(targetPath) {
   try {
     return realpathSync2.native(targetPath);
   } catch {
-    return path17.resolve(targetPath);
+    return path18.resolve(targetPath);
   }
 }
 function worktreeIsDirty(worktreePath) {
@@ -16859,7 +17393,7 @@ function removeGitWorktree({ primaryRepoPath, worktreePath, force }) {
   args.push(worktreePath);
   runGitResult(primaryRepoPath, args);
   runGitResult(primaryRepoPath, ["worktree", "prune"]);
-  return !existsSync16(worktreePath);
+  return !existsSync17(worktreePath);
 }
 function collectManagedWorktrees({ worktreeRoot, projects }) {
   const resolvedRoot = resolveRealPath(worktreeRoot);
@@ -16867,7 +17401,7 @@ function collectManagedWorktrees({ worktreeRoot, projects }) {
   const seen = /* @__PURE__ */ new Set();
   for (const project of projects) {
     const repoPath = project.primaryRepoPath;
-    if (!repoPath || !existsSync16(repoPath))
+    if (!repoPath || !existsSync17(repoPath))
       continue;
     const out = runGitResult(repoPath, ["worktree", "list", "--porcelain"]);
     if (!out.ok)
@@ -16878,7 +17412,7 @@ function collectManagedWorktrees({ worktreeRoot, projects }) {
       if (!currentPath)
         return;
       const resolved = resolveRealPath(currentPath);
-      const underRoot = resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path17.sep);
+      const underRoot = resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path18.sep);
       if (underRoot && !seen.has(resolved)) {
         seen.add(resolved);
         entries.push({
@@ -16906,7 +17440,7 @@ function collectManagedWorktrees({ worktreeRoot, projects }) {
   return entries;
 }
 function removeManagedWorktree({ path: worktreePath, primaryRepoPath, force }) {
-  const target = path17.resolve(worktreePath);
+  const target = path18.resolve(worktreePath);
   if (!force && worktreeIsDirty(target)) {
     return {
       removed: [],
@@ -16920,7 +17454,7 @@ function purgeManagedWorktrees({ entries }) {
   const removed = [];
   const skipped = [];
   for (const entry of entries) {
-    const target = path17.resolve(entry.path);
+    const target = path18.resolve(entry.path);
     if (worktreeIsDirty(target)) {
       skipped.push({ path: target, reason: "uncommitted changes" });
       continue;
@@ -16945,10 +17479,10 @@ var init_worktree_git = __esm({
 });
 
 // ../packages/core/dist/service/local-target/branch-actions-git.js
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 function integrateBranch(input) {
   const { branchName, baseBranch, worktreePath, primaryRepoPath } = input;
-  if (!existsSync17(worktreePath)) {
+  if (!existsSync18(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -17022,15 +17556,15 @@ function integrateBranch(input) {
 }
 function commitBranch(input) {
   const { branchName, worktreePath } = input;
-  const trimmed = (input.message ?? "").trim();
-  if (!trimmed) {
+  const trimmed5 = (input.message ?? "").trim();
+  if (!trimmed5) {
     return {
       ok: false,
       code: "BRANCH_COMMIT_MESSAGE_REQUIRED",
       message: "A commit message is required."
     };
   }
-  if (!existsSync17(worktreePath)) {
+  if (!existsSync18(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -17062,7 +17596,7 @@ function commitBranch(input) {
       detail: staged.stderr || staged.stdout
     };
   }
-  const commit = runGitResult(worktreePath, ["commit", "-m", trimmed]);
+  const commit = runGitResult(worktreePath, ["commit", "-m", trimmed5]);
   if (!commit.ok) {
     return {
       ok: false,
@@ -17086,7 +17620,7 @@ function pushParent(input) {
     };
   }
   let summary = `Pushed ${baseBranch} to origin.`;
-  if (existsSync17(worktreePath) && !worktreeIsDirty(worktreePath)) {
+  if (existsSync18(worktreePath) && !worktreeIsDirty(worktreePath)) {
     if (removeGitWorktree({ primaryRepoPath, worktreePath, force: false })) {
       summary += ` Removed the merged worktree for ${branchName}.`;
     }
@@ -17095,7 +17629,7 @@ function pushParent(input) {
 }
 function publishBranch(input) {
   const { branchName, worktreePath, primaryRepoPath } = input;
-  const repo = existsSync17(worktreePath) ? worktreePath : primaryRepoPath;
+  const repo = existsSync18(worktreePath) ? worktreePath : primaryRepoPath;
   const push = runGitResult(repo, ["push", "-u", "origin", branchName]);
   if (!push.ok) {
     return {
@@ -17145,7 +17679,7 @@ var init_branch_status_git = __esm({
 });
 
 // ../packages/core/dist/service/local-target/commit-message-diff-git.js
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 function collectWorktreeChanges(worktreePath) {
   const status = runGitResult(worktreePath, ["status", "--porcelain"]);
   const diff = runGitResult(worktreePath, ["diff", "HEAD"]);
@@ -17161,7 +17695,7 @@ ${diff.stdout}`);
   return sections.join("\n\n");
 }
 function gatherCommitMessageDiff(worktreePath) {
-  if (!existsSync18(worktreePath)) {
+  if (!existsSync19(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -17187,10 +17721,10 @@ var init_commit_message_diff_git = __esm({
 });
 
 // ../packages/core/dist/service/local-target/doctor-checks.js
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 function commandOnPath(command, args) {
   try {
-    const detail = execFileSync4(command, args, {
+    const detail = execFileSync5(command, args, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -17222,12 +17756,15 @@ var init_result = __esm({
 });
 
 // ../packages/core/dist/service/local-target/in-process-provider.js
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 var InProcessProvider;
 var init_in_process_provider = __esm({
   "../packages/core/dist/service/local-target/in-process-provider.js"() {
     "use strict";
     init_git_tree();
+    init_latch_discovery();
+    init_latch_session();
+    init_terminal_profile_types2();
     init_branch_actions_git();
     init_branch_status_git();
     init_commit_message_diff_git();
@@ -17250,7 +17787,7 @@ var init_in_process_provider = __esm({
        */
       async observeResource(input) {
         const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const state = existsSync19(input.path) ? "available" : "missing";
+        const state = existsSync20(input.path) ? "available" : "missing";
         return ok(this.target, { state, observedAt });
       }
       /**
@@ -17357,6 +17894,50 @@ var init_in_process_provider = __esm({
       async launchAgent(_input) {
         return fail(this.target, "CAPABILITY_NOT_IMPLEMENTED", "Agent launch is owned by the CLI runner (`ovld runner` / `ovld launch`).");
       }
+      // ---- routed (coo:702) ------------------------------------------------
+      /**
+       * Read-only Latch probe on this machine. In-process is the transport that can
+       * honestly answer it: the provider only exists here when the caller device is
+       * the execution target, so the probe runs where the agent process would run.
+       */
+      async discoverLatch(input) {
+        const executable = input.executable?.trim() || DEFAULT_LATCH_EXECUTABLE;
+        try {
+          const result = discoverLatchForExecutionTarget({
+            // A resolved provider carries the target id; the desktop bridge and dev
+            // proxy do not, so they pass the caller's id to share one cache entry
+            // with the runner probe on the same device.
+            executionTargetId: this.target.executionTargetId ?? (input.executionTargetId?.trim() || "local"),
+            executable,
+            cacheFilePath: defaultLatchDiscoveryCachePath(),
+            force: input.force === true
+          });
+          return ok(this.target, result);
+        } catch (error) {
+          return fail(this.target, "TARGET_OPERATION_FAILED", error instanceof Error ? error.message : "Latch discovery failed on this device.");
+        }
+      }
+      async inspectLatchSession(input) {
+        try {
+          return ok(this.target, inspectLatchSession(input));
+        } catch (error) {
+          return fail(this.target, "TARGET_OPERATION_FAILED", error instanceof Error ? error.message : "Could not inspect the Latch session.");
+        }
+      }
+      async openLatchSession(input) {
+        try {
+          return ok(this.target, openLatchSession(input));
+        } catch (error) {
+          return fail(this.target, "TARGET_OPERATION_FAILED", error instanceof Error ? error.message : "Could not open the Latch session.");
+        }
+      }
+      async stopLatchSession(input) {
+        try {
+          return ok(this.target, stopLatchSession(input));
+        } catch (error) {
+          return fail(this.target, "TARGET_OPERATION_FAILED", error instanceof Error ? error.message : "Could not stop the Latch session.");
+        }
+      }
       async doctor() {
         return ok(this.target, { checks: runLocalTargetDoctorChecks() });
       }
@@ -17497,7 +18078,7 @@ var init_local_target_mutation_runner = __esm({
 });
 
 // ../packages/core/dist/service/project-resource-key.js
-import path18 from "node:path";
+import path19 from "node:path";
 function deriveProjectResourceKey({ resourceKey, label, directoryPath }) {
   const explicit = resourceKey?.trim();
   if (explicit)
@@ -17505,7 +18086,7 @@ function deriveProjectResourceKey({ resourceKey, label, directoryPath }) {
   const labelKey = label?.trim();
   if (labelKey)
     return slugify(labelKey);
-  return slugify(path18.basename(path18.resolve(directoryPath)));
+  return slugify(path19.basename(path19.resolve(directoryPath)));
 }
 var init_project_resource_key = __esm({
   "../packages/core/dist/service/project-resource-key.js"() {
@@ -17515,7 +18096,7 @@ var init_project_resource_key = __esm({
 });
 
 // src/branch-planning.ts
-import path19 from "node:path";
+import path20 from "node:path";
 function stripCombiningMarks(value) {
   return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
 }
@@ -17548,7 +18129,7 @@ function missionWorktreePath({
   branch
 }) {
   const key = resourceKey.trim() || "project";
-  return path19.join(worktreeRoot, projectSlug || "project", key, branchLeaf(branch));
+  return path20.join(worktreeRoot, projectSlug || "project", key, branchLeaf(branch));
 }
 function normalizeRemoteRef(ref) {
   return ref.replace(/^origin\//, "").replace(/^refs\/heads\//, "").replace(/^refs\/remotes\/origin\//, "");
@@ -17622,13 +18203,13 @@ var init_branch_planning = __esm({
 });
 
 // src/branch-preparation.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, statSync as statSync4 } from "node:fs";
-import os3 from "node:os";
-import path20 from "node:path";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { existsSync as existsSync21, mkdirSync as mkdirSync10, statSync as statSync5 } from "node:fs";
+import os4 from "node:os";
+import path21 from "node:path";
 function runGit3(cwd, args, options = {}) {
   try {
-    return execFileSync5("git", args, {
+    return execFileSync6("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -17646,7 +18227,7 @@ function lines(value) {
 function resolveGitRoot2(workingDirectory) {
   const root = runGit3(workingDirectory, ["rev-parse", "--show-toplevel"]);
   if (!root) throw new Error(`${workingDirectory} is not inside a git repository.`);
-  return path20.resolve(root);
+  return path21.resolve(root);
 }
 function repoDefaultBranch(gitRoot) {
   const symbolic = runGit3(gitRoot, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], {
@@ -17781,9 +18362,9 @@ function missionSequence(mission, missionId) {
 }
 function resolveWorktreeRoot() {
   const override = process.env.OVERLORD_WORKTREE_ROOT?.trim();
-  if (override) return path20.resolve(override);
+  if (override) return path21.resolve(override);
   const home = process.env.OVLD_HOME?.trim() || process.env.OVERLORD_HOME?.trim();
-  return path20.join(home ? path20.resolve(home) : path20.join(os3.homedir(), ".ovld"), "worktrees");
+  return path21.join(home ? path21.resolve(home) : path21.join(os4.homedir(), ".ovld"), "worktrees");
 }
 function ensureBranchRef(gitRoot, decision) {
   if (decision.action === "reuse") return;
@@ -17794,9 +18375,9 @@ function ensureBranchRef(gitRoot, decision) {
 }
 function ensureWorktree(gitRoot, decision) {
   ensureBranchRef(gitRoot, decision);
-  mkdirSync9(path20.dirname(decision.worktreePath), { recursive: true });
-  if (existsSync20(decision.worktreePath)) {
-    if (!statSync4(decision.worktreePath).isDirectory()) {
+  mkdirSync10(path21.dirname(decision.worktreePath), { recursive: true });
+  if (existsSync21(decision.worktreePath)) {
+    if (!statSync5(decision.worktreePath).isDirectory()) {
       throw new Error(`Worktree path exists and is not a directory: ${decision.worktreePath}`);
     }
     const existingBranch = worktreeBranch(decision.worktreePath);
@@ -17936,7 +18517,7 @@ var init_branch_preparation = __esm({
 });
 
 // src/discover-project-local.ts
-import path21 from "node:path";
+import path22 from "node:path";
 async function resolvePreferredExecutionTargetId({
   backend
 }) {
@@ -17953,9 +18534,9 @@ function discoverProjectJsonFromFilesystem({
   workingDirectory,
   preferredExecutionTargetId
 }) {
-  let current = path21.resolve(workingDirectory);
+  let current = path22.resolve(workingDirectory);
   while (true) {
-    const projectJsonPath = path21.join(current, ".overlord", "project.json");
+    const projectJsonPath = path22.join(current, ".overlord", "project.json");
     const raw = readProjectJsonLink(projectJsonPath, { preferredExecutionTargetId });
     if (raw) {
       return {
@@ -17965,7 +18546,7 @@ function discoverProjectJsonFromFilesystem({
         isPrimary: raw.isPrimary
       };
     }
-    const parent = path21.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -17975,16 +18556,16 @@ async function resolveProjectByIdOrName({
   backend,
   projectRef
 }) {
-  const trimmed = projectRef.trim();
+  const trimmed5 = projectRef.trim();
   try {
-    return await backend.get(`/api/projects/${encodeURIComponent(trimmed)}`);
+    return await backend.get(`/api/projects/${encodeURIComponent(trimmed5)}`);
   } catch (error) {
     if (!(error instanceof CliError) || !/project not found/i.test(error.message)) throw error;
   }
   const projects = await listAccessibleProjects({ backend });
-  const match = projects.find((project) => project.name === trimmed) ?? projects.find((project) => project.slug === trimmed);
+  const match = projects.find((project) => project.name === trimmed5) ?? projects.find((project) => project.slug === trimmed5);
   if (!match) {
-    throw new CliError({ message: `Project not found: ${trimmed}` });
+    throw new CliError({ message: `Project not found: ${trimmed5}` });
   }
   return match;
 }
@@ -18025,7 +18606,7 @@ async function discoverProjectOnClient({
   const resolvedLocal = localWithTarget ?? local;
   if (!resolvedLocal) {
     throw new CliError({
-      message: `No linked Overlord project found for ${path21.resolve(workingDirectory)}. Run \`ovld add-cwd\` or \`ovld create-project\`.`
+      message: `No linked Overlord project found for ${path22.resolve(workingDirectory)}. Run \`ovld add-cwd\` or \`ovld create-project\`.`
     });
   }
   const project = await resolveProjectByIdOrName({ backend, projectRef: resolvedLocal.projectId });
@@ -18045,6 +18626,134 @@ var init_discover_project_local = __esm({
   }
 });
 
+// src/latch-discovery.ts
+import path23 from "node:path";
+function latchDiscoveryCachePath(dataDir = resolveGlobalDataDir()) {
+  return path23.join(dataDir, LATCH_DISCOVERY_CACHE_FILENAME);
+}
+function discoverLatchOnThisDevice({
+  executionTargetId,
+  executable = DEFAULT_LATCH_EXECUTABLE,
+  force = false
+}) {
+  return discoverLatchForExecutionTarget({
+    executionTargetId,
+    executable,
+    cacheFilePath: latchDiscoveryCachePath(),
+    force
+  });
+}
+var init_latch_discovery2 = __esm({
+  "src/latch-discovery.ts"() {
+    "use strict";
+    init_latch_discovery();
+    init_terminal_profile_types2();
+    init_config();
+  }
+});
+
+// src/latch-launch.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+function spawnLatchJson({
+  executable,
+  args,
+  stdin
+}) {
+  const result = spawnSync3(executable, args, {
+    encoding: "utf8",
+    input: stdin,
+    env: process.env,
+    maxBuffer: 2 * 1024 * 1024
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function createLatchSession({
+  executable = DEFAULT_LATCH_EXECUTABLE,
+  commandString,
+  cwd,
+  env,
+  title,
+  name,
+  commandLabel,
+  externalRunId,
+  executionTargetId,
+  shell = process.env.SHELL?.trim() || "/bin/bash"
+}) {
+  const manifest = buildLatchCreateManifest({
+    commandString,
+    shell,
+    cwd,
+    env,
+    title,
+    name,
+    commandLabel,
+    externalRunId
+  });
+  const result = spawnLatchJson({
+    executable,
+    args: ["create", "--manifest-file", "-", "--json"],
+    stdin: `${JSON.stringify(manifest)}
+`
+  });
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.stdout || `exit ${result.status ?? "null"}`).trim();
+    throw new Error(`latch create failed: ${detail}`);
+  }
+  const report = parseLatchCreateReport(result.stdout);
+  if (!report) {
+    throw new Error(
+      `latch create returned unusable JSON: ${(result.stdout || result.stderr).trim() || "(empty)"}`
+    );
+  }
+  return {
+    report,
+    providerSession: toExecutionProviderSession({
+      createReport: report,
+      executionTargetId
+    }),
+    executable
+  };
+}
+function openLatchViewer({
+  executable = DEFAULT_LATCH_EXECUTABLE,
+  providerSessionId,
+  viewerKind
+}) {
+  const viewer = latchViewerFlagForKind(viewerKind);
+  const attachCommand = latchAttachCommand({ executable, providerSessionId });
+  if (!viewer) {
+    return {
+      ok: false,
+      warning: `Latch has no viewer for kind "${viewerKind ?? "unknown"}"; session is running \u2014 attach with: ${attachCommand}`,
+      attachCommand
+    };
+  }
+  const result = spawnLatchJson({
+    executable,
+    args: ["open", providerSessionId, "--with", viewer, "--json"]
+  });
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.stdout || `exit ${result.status ?? "null"}`).trim();
+    return {
+      ok: false,
+      warning: `latch open failed (${detail}); session is running \u2014 attach with: ${attachCommand}`,
+      attachCommand
+    };
+  }
+  return { ok: true, viewer };
+}
+var init_latch_launch2 = __esm({
+  "src/latch-launch.ts"() {
+    "use strict";
+    init_latch_launch();
+    init_terminal_profile_types2();
+  }
+});
+
 // src/pre-launch.ts
 function substitutePreLaunchVariables(commands, variables) {
   return commands.map(
@@ -18072,10 +18781,10 @@ function primaryResourcePath(projectResources) {
   for (const entry of projectResources) {
     if (!entry || typeof entry !== "object") continue;
     const record = entry;
-    const path32 = typeof record.path === "string" ? record.path.trim() : "";
-    if (!path32) continue;
-    if (record.isPrimary === true) return path32;
-    if (record.isCurrent === true && !currentPath) currentPath = path32;
+    const path34 = typeof record.path === "string" ? record.path.trim() : "";
+    if (!path34) continue;
+    if (record.isPrimary === true) return path34;
+    if (record.isCurrent === true && !currentPath) currentPath = path34;
   }
   return currentPath;
 }
@@ -18175,7 +18884,7 @@ function terminalInnerCommand({
   const invocation = withPreLaunchCommands(agentCommand, preLaunchCommands);
   return `cd ${shellQuote2(workingDirectory)} && ${exports}; ${invocation}`;
 }
-function terminalLaunchScriptContent({
+function composeAgentTerminalCommand({
   command,
   args,
   workingDirectory,
@@ -18184,8 +18893,25 @@ function terminalLaunchScriptContent({
   preLaunchCommands
 }) {
   const agentCommand = agentShellCommand({ command, args, preCommand });
+  return terminalInnerCommand({ workingDirectory, agentCommand, extraEnv, preLaunchCommands });
+}
+function terminalLaunchScriptContent({
+  command,
+  args,
+  workingDirectory,
+  preCommand,
+  extraEnv = {},
+  preLaunchCommands
+}) {
   return `#!/usr/bin/env bash
-${terminalInnerCommand({ workingDirectory, agentCommand, extraEnv, preLaunchCommands })}
+${composeAgentTerminalCommand({
+    command,
+    args,
+    workingDirectory,
+    preCommand,
+    extraEnv,
+    preLaunchCommands
+  })}
 `;
 }
 function terminalScriptCommand(scriptPath) {
@@ -18426,9 +19152,9 @@ var init_terminal_launcher = __esm({
 });
 
 // src/launch.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { chmodSync as chmodSync4, writeFileSync as writeFileSync8 } from "node:fs";
-import path22 from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { chmodSync as chmodSync4, writeFileSync as writeFileSync9 } from "node:fs";
+import path24 from "node:path";
 function overlordLaunchEnv({
   backendUrl,
   missionId,
@@ -18594,7 +19320,7 @@ function launchScriptPath({
   executionRequestId
 }) {
   const requestPart = executionRequestId ? safeLaunchScriptPart(executionRequestId) : `${process.pid}`;
-  return path22.join(tmpDir, `launch-${safeLaunchScriptPart(displayId)}-${requestPart}.sh`);
+  return path24.join(tmpDir, `launch-${safeLaunchScriptPart(displayId)}-${requestPart}.sh`);
 }
 async function buildLaunchPlan({
   runtime,
@@ -18603,12 +19329,12 @@ async function buildLaunchPlan({
   const context = await loadMissionContext({ runtime, missionId: options.missionId });
   pruneStaleProjectTmp({ workingDirectory: options.workingDirectory, create: true });
   const tmpDir = ensureProjectTmpDir(options.workingDirectory);
-  const contextFile = path22.join(
+  const contextFile = path24.join(
     tmpDir,
     `mission-${context.displayId.replace(/[^a-zA-Z0-9_-]/g, "-")}.md`
   );
   const launchContext = context.launchContext;
-  writeFileSync8(contextFile, `${launchContext}
+  writeFileSync9(contextFile, `${launchContext}
 `);
   const projectResources = await loadProjectResourcesForLaunch({
     runtime,
@@ -18653,13 +19379,21 @@ async function buildLaunchPlan({
     contextFile,
     launchMessage: `Attach to ovld mission ${context.displayId}, then immediately execute ${context.title}. Do not wait for more instructions.`
   });
+  const latchCommandString = composeAgentTerminalCommand({
+    command: command.command,
+    args: command.args,
+    workingDirectory: options.workingDirectory,
+    preCommand: options.preCommand,
+    extraEnv: exportedEnv,
+    preLaunchCommands
+  });
   const terminalScriptPath = options.terminalLauncher?.trim() ? launchScriptPath({
     tmpDir,
     displayId: context.displayId,
     executionRequestId: options.executionRequestId
   }) : null;
   if (terminalScriptPath) {
-    writeFileSync8(
+    writeFileSync9(
       terminalScriptPath,
       terminalLaunchScriptContent({
         command: command.command,
@@ -18691,7 +19425,11 @@ async function buildLaunchPlan({
     contextFile,
     workingDirectory: options.workingDirectory,
     execution,
-    env: exportedEnv
+    env: exportedEnv,
+    latchCommandString,
+    launchSession: options.launchSession ?? null,
+    missionTitle: options.missionTitle ?? context.title,
+    missionDisplayId: options.missionDisplayId ?? context.displayId
   };
 }
 async function launchAgent({
@@ -18707,26 +19445,126 @@ async function launchAgent({
     ...tmpEnvFor(options.workingDirectory),
     ...plan.env
   };
+  const snapshot = options.launchSession ?? plan.launchSession ?? null;
+  const providerKind = snapshot?.executionProvider.kind ?? "direct";
+  const executable = snapshot?.executionProvider.executable ?? "latch";
+  let providerFallbackWarning = null;
+  let useLatch = false;
+  const existingProviderSession = providerKind === "latch" ? existingLatchProviderSession({
+    latchSessionId: process.env.LATCH_SESSION_ID,
+    executionTargetId: options.executionTargetId
+  }) : null;
+  if (existingProviderSession && plan.latchCommandString) {
+    const shell = process.env.SHELL?.trim() || "/bin/bash";
+    const result2 = spawnSync4(shell, ["-lc", plan.latchCommandString], {
+      cwd: options.workingDirectory,
+      env,
+      stdio: "inherit"
+    });
+    return {
+      plan: {
+        ...plan,
+        execution: {
+          command: shell,
+          args: ["-lc", plan.latchCommandString],
+          useShell: false,
+          terminal: null,
+          display: `Latch session ${existingProviderSession.providerSessionId} (inline) \u203A ${plan.latchCommandString}`
+        }
+      },
+      status: result2.status,
+      signal: result2.signal,
+      providerSession: existingProviderSession,
+      viewerOpen: null,
+      providerFallbackWarning
+    };
+  }
+  if (providerKind === "latch") {
+    if (!options.executionTargetId) {
+      providerFallbackWarning = "Latch provider selected but no execution target id is available; falling back to direct launch.";
+    } else {
+      const discovery = discoverLatchOnThisDevice({
+        executionTargetId: options.executionTargetId,
+        executable
+      });
+      useLatch = shouldUseLatchProvider({
+        providerKind,
+        latchSelectable: discovery.latchSelectable
+      });
+      if (!useLatch) {
+        providerFallbackWarning = discovery.state === "not_installed" ? `Latch is not installed on this execution target (${discovery.installCommand}); falling back to direct launch.` : discovery.state === "incompatible" ? `Latch is incompatible (${discovery.missingCapability}: ${discovery.detail}); falling back to direct launch.` : "Latch is unavailable; falling back to direct launch.";
+      }
+    }
+  }
+  if (useLatch && plan.latchCommandString) {
+    const created = createLatchSession({
+      executable,
+      commandString: plan.latchCommandString,
+      cwd: options.workingDirectory,
+      env: plan.env,
+      title: plan.missionTitle,
+      name: plan.missionDisplayId,
+      commandLabel: options.agent,
+      externalRunId: options.executionRequestId,
+      executionTargetId: options.executionTargetId
+    });
+    let viewerOpen = null;
+    const openOnLaunch = snapshot?.viewer.openOnLaunch !== false;
+    if (openOnLaunch) {
+      viewerOpen = openLatchViewer({
+        executable,
+        providerSessionId: created.providerSession.providerSessionId,
+        viewerKind: snapshot?.viewer.kind ?? "iterm"
+      });
+    }
+    return {
+      plan: {
+        ...plan,
+        execution: {
+          command: executable,
+          args: ["create", "--manifest-file", "-", "--json"],
+          useShell: false,
+          terminal: snapshot?.viewer.launcher ?? null,
+          display: `latch create \u203A ${plan.latchCommandString}`
+        }
+      },
+      status: 0,
+      signal: null,
+      providerSession: created.providerSession,
+      viewerOpen,
+      providerFallbackWarning
+    };
+  }
   const { execution } = plan;
-  const result = execution.useShell ? spawnSync2(execution.command, {
+  const result = execution.useShell ? spawnSync4(execution.command, {
     cwd: options.workingDirectory,
     env,
     shell: true,
     stdio: "inherit"
-  }) : spawnSync2(execution.command, execution.args, {
+  }) : spawnSync4(execution.command, execution.args, {
     cwd: options.workingDirectory,
     env,
     stdio: "inherit"
   });
-  return { plan, status: result.status, signal: result.signal };
+  return {
+    plan,
+    status: result.status,
+    signal: result.signal,
+    providerSession: null,
+    viewerOpen: null,
+    providerFallbackWarning
+  };
 }
 var AGENT_HISTORY_EXCLUDED_EVENT_TYPES, EXECUTION_DIRECTIVE;
 var init_launch = __esm({
   "src/launch.ts"() {
     "use strict";
     init_dist2();
+    init_latch_launch();
     init_channel();
     init_agent_binaries();
+    init_latch_discovery2();
+    init_latch_launch2();
     init_pre_launch();
     init_project_tmp();
     init_terminal_launcher();
@@ -18740,8 +19578,8 @@ var init_launch = __esm({
 });
 
 // src/launch-bootstrap.ts
-import { existsSync as existsSync21, readdirSync as readdirSync4, readFileSync as readFileSync15, statSync as statSync5 } from "node:fs";
-import path23 from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
+import path25 from "node:path";
 function firstCapture(match) {
   if (!match) return null;
   const value = match[1] ?? match[2] ?? match[3] ?? null;
@@ -18762,15 +19600,15 @@ function recoverLaunchBootstrapFromProjectTmp({
   const trimmedMission = missionId.trim();
   if (!trimmedMission) return empty;
   const tmpDir = projectTmpDir(workingDirectory);
-  if (!existsSync21(tmpDir)) return empty;
+  if (!existsSync22(tmpDir)) return empty;
   const prefix = `launch-${safeMissionPart(trimmedMission)}-`;
   let newest = null;
   try {
     for (const name of readdirSync4(tmpDir)) {
       if (!name.startsWith(prefix) || !name.endsWith(".sh")) continue;
-      const filePath = path23.join(tmpDir, name);
+      const filePath = path25.join(tmpDir, name);
       try {
-        const mtimeMs = statSync5(filePath).mtimeMs;
+        const mtimeMs = statSync6(filePath).mtimeMs;
         if (!newest || mtimeMs > newest.mtimeMs) {
           newest = { path: filePath, mtimeMs };
         }
@@ -18783,7 +19621,7 @@ function recoverLaunchBootstrapFromProjectTmp({
   if (!newest) return empty;
   let contents = "";
   try {
-    contents = readFileSync15(newest.path, "utf8");
+    contents = readFileSync16(newest.path, "utf8");
   } catch {
     return empty;
   }
@@ -18804,8 +19642,8 @@ var init_launch_bootstrap = __esm({
 });
 
 // src/org-setup.ts
-import { readFileSync as readFileSync16 } from "node:fs";
-import path24 from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
+import path26 from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 function suggestSlug(name) {
   const cleaned = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -18820,8 +19658,8 @@ function promptText({
   return new Promise((resolve) => {
     rl.question(`${question}${suffix}: `, (answer) => {
       rl.close();
-      const trimmed = answer.trim();
-      resolve(trimmed || defaultValue || "");
+      const trimmed5 = answer.trim();
+      resolve(trimmed5 || defaultValue || "");
     });
   });
 }
@@ -18884,12 +19722,12 @@ async function runOrgSetupCommand({
   let logoWarning = null;
   if (logoPath) {
     try {
-      const resolvedPath = path24.resolve(logoPath);
-      const bytes = readFileSync16(resolvedPath);
+      const resolvedPath = path26.resolve(logoPath);
+      const bytes = readFileSync17(resolvedPath);
       const stored = await runtime.backend.postRaw({
         path: "/api/uploads/organization-images",
         body: bytes,
-        filename: path24.basename(resolvedPath)
+        filename: path26.basename(resolvedPath)
       });
       await runtime.backend.patch({
         path: `/api/organizations/${encodeURIComponent(organization.id)}`,
@@ -19384,17 +20222,17 @@ var init_protocol_help = __esm({
 
 // src/vcs-sessions.ts
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "node:fs";
-import path25 from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "node:fs";
+import path27 from "node:path";
 function manifestPath2(workingDirectory) {
-  const key = createHash8("sha256").update(path25.resolve(workingDirectory)).digest("hex");
-  return path25.join(resolveGlobalDataDir(), "vcs-sessions", `${key}.json`);
+  const key = createHash8("sha256").update(path27.resolve(workingDirectory)).digest("hex");
+  return path27.join(resolveGlobalDataDir(), "vcs-sessions", `${key}.json`);
 }
 function readEntries(workingDirectory) {
   try {
     const target = manifestPath2(workingDirectory);
-    if (!existsSync22(target)) return [];
-    const raw = JSON.parse(readFileSync17(target, "utf8"));
+    if (!existsSync23(target)) return [];
+    const raw = JSON.parse(readFileSync18(target, "utf8"));
     if (!Array.isArray(raw.entries)) return [];
     const now = Date.now();
     return raw.entries.flatMap((entry) => {
@@ -19413,8 +20251,8 @@ function readEntries(workingDirectory) {
 function writeEntries(workingDirectory, entries) {
   try {
     const target = manifestPath2(workingDirectory);
-    mkdirSync10(path25.dirname(target), { recursive: true });
-    writeFileSync9(target, JSON.stringify({ entries }));
+    mkdirSync11(path27.dirname(target), { recursive: true });
+    writeFileSync10(target, JSON.stringify({ entries }));
   } catch {
   }
 }
@@ -19464,23 +20302,23 @@ var init_vcs_sessions = __esm({
 });
 
 // src/vcs.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
 import {
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync12,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   realpathSync as realpathSync3,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import path26 from "node:path";
+import path28 from "node:path";
 function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/").trim();
 }
 function sameWorkingDirectory(left, right) {
-  return typeof left === "string" && path26.resolve(left) === path26.resolve(right);
+  return typeof left === "string" && path28.resolve(left) === path28.resolve(right);
 }
 function parsePorcelainLine(line) {
   const trimmedEnd = line.replace(/\s+$/, "");
@@ -19500,7 +20338,7 @@ function hashWorktreeFile({
   filePath
 }) {
   try {
-    return execFileSync6("git", ["hash-object", filePath], {
+    return execFileSync7("git", ["hash-object", filePath], {
       cwd: workingDirectory,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -19511,7 +20349,7 @@ function hashWorktreeFile({
 }
 function readChangedFiles(workingDirectory) {
   try {
-    const output = execFileSync6("git", ["status", "--porcelain"], {
+    const output = execFileSync7("git", ["status", "--porcelain"], {
       cwd: workingDirectory,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -19531,13 +20369,13 @@ function sessionKeyHash({
   workingDirectory,
   missionId
 }) {
-  return createHash9("sha256").update(`${path26.resolve(workingDirectory)}\0${missionId}`).digest("hex");
+  return createHash9("sha256").update(`${path28.resolve(workingDirectory)}\0${missionId}`).digest("hex");
 }
 function baselineFilePath({
   workingDirectory,
   missionId
 }) {
-  return path26.join(
+  return path28.join(
     resolveGlobalDataDir(),
     "vcs-baselines",
     `${sessionKeyHash({ workingDirectory, missionId })}.json`
@@ -19547,7 +20385,7 @@ function touchedFilesPath({
   workingDirectory,
   missionId
 }) {
-  return path26.join(
+  return path28.join(
     resolveGlobalDataDir(),
     "vcs-touched",
     `${sessionKeyHash({ workingDirectory, missionId })}.json`
@@ -19557,7 +20395,7 @@ function rationaleNotesPath({
   workingDirectory,
   missionId
 }) {
-  return path26.join(
+  return path28.join(
     resolveGlobalDataDir(),
     "vcs-rationale-notes",
     `${sessionKeyHash({ workingDirectory, missionId })}.json`
@@ -19567,7 +20405,7 @@ function bashSnapshotPath({
   workingDirectory,
   missionId
 }) {
-  return path26.join(
+  return path28.join(
     resolveGlobalDataDir(),
     "vcs-touched",
     `${sessionKeyHash({ workingDirectory, missionId })}.bash-snapshot.json`
@@ -19579,8 +20417,8 @@ function readBashSnapshot({
 }) {
   try {
     const target = bashSnapshotPath({ workingDirectory, missionId });
-    if (!existsSync23(target)) return /* @__PURE__ */ new Map();
-    const raw = JSON.parse(readFileSync18(target, "utf8"));
+    if (!existsSync24(target)) return /* @__PURE__ */ new Map();
+    const raw = JSON.parse(readFileSync19(target, "utf8"));
     const byPath = /* @__PURE__ */ new Map();
     if (Array.isArray(raw.files)) {
       for (const entry of raw.files) {
@@ -19605,8 +20443,8 @@ function writeBashSnapshot({
 }) {
   try {
     const target = bashSnapshotPath({ workingDirectory, missionId });
-    mkdirSync11(path26.dirname(target), { recursive: true });
-    writeFileSync10(target, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString(), files }));
+    mkdirSync12(path28.dirname(target), { recursive: true });
+    writeFileSync11(target, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString(), files }));
   } catch {
   }
 }
@@ -19639,12 +20477,12 @@ function recordBashObservedChanges({
   }
 }
 function normalizeAbsolute(filePath) {
-  const resolved = path26.resolve(filePath);
+  const resolved = path28.resolve(filePath);
   try {
     return realpathSync3(resolved).replace(/\\/g, "/");
   } catch {
     try {
-      return path26.join(realpathSync3(path26.dirname(resolved)), path26.basename(resolved)).replace(/\\/g, "/");
+      return path28.join(realpathSync3(path28.dirname(resolved)), path28.basename(resolved)).replace(/\\/g, "/");
     } catch {
       return resolved.replace(/\\/g, "/");
     }
@@ -19652,7 +20490,7 @@ function normalizeAbsolute(filePath) {
 }
 function gitRepoRoot(workingDirectory) {
   try {
-    const root = execFileSync6("git", ["rev-parse", "--show-toplevel"], {
+    const root = execFileSync7("git", ["rev-parse", "--show-toplevel"], {
       cwd: workingDirectory,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -19671,7 +20509,7 @@ function resetTouchedFiles({
       touchedFilesPath({ workingDirectory, missionId }),
       bashSnapshotPath({ workingDirectory, missionId })
     ]) {
-      if (existsSync23(target)) rmSync5(target);
+      if (existsSync24(target)) rmSync5(target);
     }
   } catch {
   }
@@ -19682,14 +20520,14 @@ function resetRationaleNotes({
 }) {
   try {
     const target = rationaleNotesPath({ workingDirectory, missionId });
-    if (existsSync23(target)) rmSync5(target);
+    if (existsSync24(target)) rmSync5(target);
   } catch {
   }
 }
 function truncateNoteText(value, max = 500) {
-  const trimmed = (value ?? "").replace(/\s+/g, " ").trim();
-  if (!trimmed) return null;
-  return trimmed.length > max ? `${trimmed.slice(0, max - 1)}...` : trimmed;
+  const trimmed5 = (value ?? "").replace(/\s+/g, " ").trim();
+  if (!trimmed5) return null;
+  return trimmed5.length > max ? `${trimmed5.slice(0, max - 1)}...` : trimmed5;
 }
 function readRationaleNotes({
   workingDirectory,
@@ -19697,8 +20535,8 @@ function readRationaleNotes({
 }) {
   try {
     const target = rationaleNotesPath({ workingDirectory, missionId });
-    if (!existsSync23(target)) return [];
-    const raw = JSON.parse(readFileSync18(target, "utf8"));
+    if (!existsSync24(target)) return [];
+    const raw = JSON.parse(readFileSync19(target, "utf8"));
     if (!Array.isArray(raw.notes)) return [];
     return raw.notes.flatMap((note) => {
       if (typeof note !== "object" || note === null || typeof note.filePath !== "string") {
@@ -19732,7 +20570,7 @@ function recordRationaleNotes({
       intent: truncateNoteText(note.intent),
       transcriptContext: truncateNoteText(note.transcriptContext)
     })).filter((note) => note.filePath).map((note) => {
-      const absolute = normalizeAbsolute(path26.resolve(workingDirectory, note.filePath));
+      const absolute = normalizeAbsolute(path28.resolve(workingDirectory, note.filePath));
       return {
         filePath: absolute,
         toolName: note.toolName,
@@ -19740,17 +20578,17 @@ function recordRationaleNotes({
         transcriptContext: note.transcriptContext,
         contentHash: hashWorktreeFile({
           workingDirectory,
-          filePath: path26.relative(workingDirectory, absolute)
+          filePath: path28.relative(workingDirectory, absolute)
         }),
         recordedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
     });
     if (additions.length === 0) return;
     const target = rationaleNotesPath({ workingDirectory, missionId });
-    mkdirSync11(path26.dirname(target), { recursive: true });
+    mkdirSync12(path28.dirname(target), { recursive: true });
     const prior = readRationaleNotes({ workingDirectory, missionId });
     const notesToKeep = [...prior, ...additions].slice(-200);
-    writeFileSync10(
+    writeFileSync11(
       target,
       JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString(), notes: notesToKeep })
     );
@@ -19763,16 +20601,16 @@ function recordTouchedFiles({
   files
 }) {
   try {
-    const additions = files.map((filePath) => (filePath ?? "").trim()).filter(Boolean).map((filePath) => normalizeAbsolute(path26.resolve(workingDirectory, filePath)));
+    const additions = files.map((filePath) => (filePath ?? "").trim()).filter(Boolean).map((filePath) => normalizeAbsolute(path28.resolve(workingDirectory, filePath)));
     if (additions.length === 0) return;
     const target = touchedFilesPath({ workingDirectory, missionId });
-    mkdirSync11(path26.dirname(target), { recursive: true });
+    mkdirSync12(path28.dirname(target), { recursive: true });
     const existing = readTouchedLog({ workingDirectory, missionId })?.paths ?? /* @__PURE__ */ new Set();
     for (const filePath of additions) existing.add(filePath);
-    writeFileSync10(
+    writeFileSync11(
       target,
       JSON.stringify({
-        workingDirectory: path26.resolve(workingDirectory),
+        workingDirectory: path28.resolve(workingDirectory),
         missionId,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         paths: Array.from(existing)
@@ -19785,7 +20623,7 @@ function hasTouchedFilesLog({
   workingDirectory,
   missionId
 }) {
-  return existsSync23(touchedFilesPath({ workingDirectory, missionId }));
+  return existsSync24(touchedFilesPath({ workingDirectory, missionId }));
 }
 function readTouchedLog({
   workingDirectory,
@@ -19793,8 +20631,8 @@ function readTouchedLog({
 }) {
   try {
     const target = touchedFilesPath({ workingDirectory, missionId });
-    if (!existsSync23(target)) return null;
-    const raw = JSON.parse(readFileSync18(target, "utf8"));
+    if (!existsSync24(target)) return null;
+    const raw = JSON.parse(readFileSync19(target, "utf8"));
     const result = /* @__PURE__ */ new Set();
     if (Array.isArray(raw.paths)) {
       for (const entry of raw.paths) {
@@ -19827,14 +20665,14 @@ function writeBaseline({
 }) {
   try {
     const target = baselineFilePath({ workingDirectory, missionId });
-    mkdirSync11(path26.dirname(target), { recursive: true });
+    mkdirSync12(path28.dirname(target), { recursive: true });
     const snapshot = {
-      workingDirectory: path26.resolve(workingDirectory),
+      workingDirectory: path28.resolve(workingDirectory),
       missionId,
       capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
       files: snapshotBaselineFiles({ workingDirectory, files })
     };
-    writeFileSync10(target, JSON.stringify(snapshot));
+    writeFileSync11(target, JSON.stringify(snapshot));
   } catch {
   }
 }
@@ -19846,13 +20684,13 @@ function readPeerTouchedClaims({
     readActiveSessions(workingDirectory).map((entry) => entry.missionId.trim()).filter(Boolean)
   );
   if (activeMissionIds.size === 0) return [];
-  const directory = path26.join(resolveGlobalDataDir(), "vcs-touched");
-  if (!existsSync23(directory)) return [];
+  const directory = path28.join(resolveGlobalDataDir(), "vcs-touched");
+  if (!existsSync24(directory)) return [];
   const claims = [];
   for (const name of readdirSync5(directory)) {
     if (!name.endsWith(".json") || name.endsWith(".bash-snapshot.json")) continue;
     try {
-      const raw = JSON.parse(readFileSync18(path26.join(directory, name), "utf8"));
+      const raw = JSON.parse(readFileSync19(path28.join(directory, name), "utf8"));
       const candidateMissionId = typeof raw.missionId === "string" && raw.missionId.trim() ? raw.missionId.trim() : null;
       if (!candidateMissionId || candidateMissionId === missionId) continue;
       if (!activeMissionIds.has(candidateMissionId)) continue;
@@ -19877,8 +20715,8 @@ function readBaselineSnapshot({
 }) {
   try {
     const target = baselineFilePath({ workingDirectory, missionId });
-    if (!existsSync23(target)) return /* @__PURE__ */ new Map();
-    const raw = JSON.parse(readFileSync18(target, "utf8"));
+    if (!existsSync24(target)) return /* @__PURE__ */ new Map();
+    const raw = JSON.parse(readFileSync19(target, "utf8"));
     if (Array.isArray(raw.files)) {
       const byPath = /* @__PURE__ */ new Map();
       for (const entry of raw.files) {
@@ -19972,10 +20810,10 @@ function compileIgnorePattern(rawPattern) {
 }
 function loadIgnoreRules(repoRoot) {
   try {
-    const target = path26.join(repoRoot, OVERLORD_IGNORE_FILENAME);
-    if (!existsSync23(target)) return [];
+    const target = path28.join(repoRoot, OVERLORD_IGNORE_FILENAME);
+    if (!existsSync24(target)) return [];
     const rules = [];
-    for (const rawLine of readFileSync18(target, "utf8").split("\n")) {
+    for (const rawLine of readFileSync19(target, "utf8").split("\n")) {
       const line = rawLine.replace(/\r$/, "").trim();
       if (!line || line.startsWith("#")) continue;
       const rule = compileIgnorePattern(line);
@@ -20009,7 +20847,7 @@ function filterRunAttributableChanges({
       return [];
     }
     if (!touched) return [{ filePath: entry.filePath, vcsStatus: entry.vcsStatus }];
-    const absolute = normalizeAbsolute(path26.resolve(repoRoot, entry.filePath));
+    const absolute = normalizeAbsolute(path28.resolve(repoRoot, entry.filePath));
     if (touched.paths.has(absolute)) {
       return [
         {
@@ -20040,7 +20878,7 @@ function filterRunAttributableChanges({
   });
 }
 function titleFromPath(filePath) {
-  const base = path26.basename(filePath).replace(/\.[^.]+$/, "");
+  const base = path28.basename(filePath).replace(/\.[^.]+$/, "");
   const words = base.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim();
   if (!words) return `Update ${filePath}`;
   return `Update ${words.replace(/\b\w/g, (char) => char.toUpperCase())}`;
@@ -20063,7 +20901,7 @@ function draftChangeRationalesFromNotes({
   if (notes.length === 0 || files.length === 0) return [];
   const repoRoot = gitRepoRoot(workingDirectory) ?? workingDirectory;
   return files.flatMap((file) => {
-    const absolute = normalizeAbsolute(path26.resolve(repoRoot, file.filePath));
+    const absolute = normalizeAbsolute(path28.resolve(repoRoot, file.filePath));
     const currentHash = hashWorktreeFile({ workingDirectory, filePath: file.filePath });
     const note = latestRelevantNote({ notes, filePath: absolute, currentHash });
     if (!note) return [];
@@ -20103,17 +20941,17 @@ var init_vcs = __esm({
 });
 
 // src/record-touched.ts
-import { readFileSync as readFileSync19 } from "node:fs";
-import path27 from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import path29 from "node:path";
 function collectCandidates(toolInput) {
   const counts = /* @__PURE__ */ new Map();
   const order = [];
   const bump = (raw, amount) => {
     if (typeof raw !== "string") return;
-    const trimmed = raw.trim();
-    if (!trimmed) return;
-    if (!counts.has(trimmed)) order.push(trimmed);
-    counts.set(trimmed, (counts.get(trimmed) ?? 0) + amount);
+    const trimmed5 = raw.trim();
+    if (!trimmed5) return;
+    if (!counts.has(trimmed5)) order.push(trimmed5);
+    counts.set(trimmed5, (counts.get(trimmed5) ?? 0) + amount);
   };
   bump(toolInput.file_path, 1);
   bump(toolInput.notebook_path, 1);
@@ -20153,7 +20991,7 @@ function editIntent({
 function recentAssistantContext(transcriptPath) {
   if (typeof transcriptPath !== "string" || !transcriptPath.trim()) return null;
   try {
-    const lines2 = readFileSync19(transcriptPath, "utf8").split("\n").slice(-200);
+    const lines2 = readFileSync20(transcriptPath, "utf8").split("\n").slice(-200);
     for (let index = lines2.length - 1; index >= 0; index -= 1) {
       const line = lines2[index]?.trim();
       if (!line) continue;
@@ -20203,7 +21041,7 @@ function recordTouchedFromPayload({
   const toolInput = toolInputRaw && typeof toolInputRaw === "object" ? toolInputRaw : {};
   const toolName = typeof payload.tool_name === "string" && payload.tool_name.trim() ? payload.tool_name.trim() : "file edit";
   const cwd = typeof payload.cwd === "string" && payload.cwd.trim() ? payload.cwd.trim() : fallbackCwd;
-  const workingDirectory = path27.resolve(cwd);
+  const workingDirectory = path29.resolve(cwd);
   const trimmedOverride = missionOverride?.trim();
   let missionId;
   let ambiguous = false;
@@ -20307,23 +21145,23 @@ var init_resource_observations = __esm({
 
 // src/runner-identity.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "node:fs";
 import { hostname as hostname4 } from "node:os";
-import path28 from "node:path";
+import path30 from "node:path";
 function envValue(name) {
   const value = process.env[name]?.trim();
   return value && value.length > 0 ? value : null;
 }
 function runnerInstanceStatePath(dataDir = resolveGlobalDataDir()) {
-  return path28.join(dataDir, RUNNER_INSTANCE_STATE_FILENAME);
+  return path30.join(dataDir, RUNNER_INSTANCE_STATE_FILENAME);
 }
 function resolveRunnerInstanceId(dataDir = resolveGlobalDataDir()) {
   const pinned = envValue("OVERLORD_RUNNER_INSTANCE_ID");
   if (pinned) return pinned;
   const statePath = runnerInstanceStatePath(dataDir);
-  if (existsSync24(statePath)) {
+  if (existsSync25(statePath)) {
     try {
-      const parsed = JSON.parse(readFileSync20(statePath, "utf8"));
+      const parsed = JSON.parse(readFileSync21(statePath, "utf8"));
       if (typeof parsed.runnerInstanceId === "string" && parsed.runnerInstanceId.trim()) {
         return parsed.runnerInstanceId.trim();
       }
@@ -20332,8 +21170,8 @@ function resolveRunnerInstanceId(dataDir = resolveGlobalDataDir()) {
   }
   const runnerInstanceId = randomUUID();
   try {
-    mkdirSync12(path28.dirname(statePath), { recursive: true });
-    writeFileSync11(statePath, `${JSON.stringify({ runnerInstanceId }, null, 2)}
+    mkdirSync13(path30.dirname(statePath), { recursive: true });
+    writeFileSync12(statePath, `${JSON.stringify({ runnerInstanceId }, null, 2)}
 `, { mode: 384 });
   } catch {
   }
@@ -20375,12 +21213,12 @@ var init_runner_identity = __esm({
 
 // src/runner-service.ts
 import { execFile } from "node:child_process";
-import { chmodSync as chmodSync5, existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync21, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "node:fs";
-import os4 from "node:os";
-import path29 from "node:path";
+import { chmodSync as chmodSync5, existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync22, rmSync as rmSync6, writeFileSync as writeFileSync13 } from "node:fs";
+import os5 from "node:os";
+import path31 from "node:path";
 import { promisify } from "node:util";
 function writeServiceFile(filePath, contents) {
-  writeFileSync12(filePath, contents, { mode: 384 });
+  writeFileSync13(filePath, contents, { mode: 384 });
   chmodSync5(filePath, 384);
 }
 function emptyRunnerServiceState() {
@@ -20399,21 +21237,21 @@ function emptyRunnerServiceState() {
   };
 }
 function runnerServiceStatePath(dataDir = resolveGlobalDataDir()) {
-  return path29.join(dataDir, RUNNER_SERVICE_STATE_FILENAME);
+  return path31.join(dataDir, RUNNER_SERVICE_STATE_FILENAME);
 }
 function readRunnerServiceState(dataDir = resolveGlobalDataDir()) {
   const filePath = runnerServiceStatePath(dataDir);
-  if (!existsSync25(filePath)) return emptyRunnerServiceState();
+  if (!existsSync26(filePath)) return emptyRunnerServiceState();
   try {
-    const parsed = JSON.parse(readFileSync21(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(filePath, "utf8"));
     return { ...emptyRunnerServiceState(), ...parsed };
   } catch {
     return emptyRunnerServiceState();
   }
 }
 function writeRunnerServiceState(state, dataDir = resolveGlobalDataDir()) {
-  mkdirSync13(dataDir, { recursive: true });
-  writeFileSync12(runnerServiceStatePath(dataDir), `${JSON.stringify(state, null, 2)}
+  mkdirSync14(dataDir, { recursive: true });
+  writeFileSync13(runnerServiceStatePath(dataDir), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function patchRunnerServiceState(patch, dataDir = resolveGlobalDataDir()) {
@@ -20422,13 +21260,13 @@ function patchRunnerServiceState(patch, dataDir = resolveGlobalDataDir()) {
   return next;
 }
 function runnerFocusStatePath(dataDir = resolveGlobalDataDir()) {
-  return path29.join(dataDir, RUNNER_FOCUS_STATE_FILENAME);
+  return path31.join(dataDir, RUNNER_FOCUS_STATE_FILENAME);
 }
 function readDesktopFocusState(dataDir = resolveGlobalDataDir()) {
   const filePath = runnerFocusStatePath(dataDir);
-  if (!existsSync25(filePath)) return { lastFocusedAt: null };
+  if (!existsSync26(filePath)) return { lastFocusedAt: null };
   try {
-    const parsed = JSON.parse(readFileSync21(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(filePath, "utf8"));
     return { lastFocusedAt: parsed.lastFocusedAt ?? null };
   } catch {
     return { lastFocusedAt: null };
@@ -20458,17 +21296,17 @@ function nextRunnerLastError(pollError) {
 }
 function resolveOverlordAppInvocation({
   platform: platform2 = process.platform,
-  homedir: homedir2 = os4.homedir(),
-  exists = existsSync25
+  homedir: homedir2 = os5.homedir(),
+  exists = existsSync26
 } = {}) {
   if (platform2 !== "darwin") return null;
   const appDirs = [
     "/Applications/Overlord.app",
-    path29.join(homedir2, "Applications", "Overlord.app")
+    path31.join(homedir2, "Applications", "Overlord.app")
   ];
   for (const appDir of appDirs) {
-    const program = path29.join(appDir, "Contents", "MacOS", "Overlord");
-    const script = path29.join(appDir, "Contents", "Resources", "cli", "bin", "ovld.mjs");
+    const program = path31.join(appDir, "Contents", "MacOS", "Overlord");
+    const script = path31.join(appDir, "Contents", "Resources", "cli", "bin", "ovld.mjs");
     if (exists(program) && exists(script)) {
       return { program, args: [script, "runner", "supervise"], runAsElectronNode: true };
     }
@@ -20480,7 +21318,7 @@ function resolveOvldInvocation(argv = process.argv, execPath = process.execPath)
   if (override) {
     return { program: override, args: ["runner", "supervise"] };
   }
-  const scriptPath = argv[1] ? path29.resolve(argv[1]) : "";
+  const scriptPath = argv[1] ? path31.resolve(argv[1]) : "";
   if (process.env.ELECTRON_RUN_AS_NODE) {
     return scriptPath ? { program: execPath, args: [scriptPath, "runner", "supervise"], runAsElectronNode: true } : { program: execPath, args: ["runner", "supervise"], runAsElectronNode: true };
   }
@@ -20513,7 +21351,7 @@ function buildRunnerServiceEnv({
     PATH: process.env.PATH?.trim() || "/usr/local/bin:/usr/bin:/bin"
   };
   const home = overlordHome?.trim() || process.env.OVLD_HOME?.trim();
-  if (home) env.OVLD_HOME = path29.resolve(home);
+  if (home) env.OVLD_HOME = path31.resolve(home);
   const token = process.env.OVERLORD_USER_TOKEN?.trim() || process.env.OVLD_USER_TOKEN?.trim();
   if (token) env.OVERLORD_USER_TOKEN = token;
   if (runAsElectronNode || process.env.ELECTRON_RUN_AS_NODE) env.ELECTRON_RUN_AS_NODE = "1";
@@ -20552,9 +21390,9 @@ ${envEntries}
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${xmlEscape(path29.join(logDir, "runner-service.out.log"))}</string>
+  <string>${xmlEscape(path31.join(logDir, "runner-service.out.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xmlEscape(path29.join(logDir, "runner-service.err.log"))}</string>
+  <string>${xmlEscape(path31.join(logDir, "runner-service.err.log"))}</string>
   <key>ProcessType</key>
   <string>Background</string>
 </dict>
@@ -20585,12 +21423,12 @@ WantedBy=default.target
 `;
 }
 function launchAgentsDir() {
-  return path29.join(os4.homedir(), "Library", "LaunchAgents");
+  return path31.join(os5.homedir(), "Library", "LaunchAgents");
 }
 function systemdUserDir() {
   const xdg = process.env.XDG_CONFIG_HOME?.trim();
-  const base = xdg ? path29.resolve(xdg) : path29.join(os4.homedir(), ".config");
-  return path29.join(base, "systemd", "user");
+  const base = xdg ? path31.resolve(xdg) : path31.join(os5.homedir(), ".config");
+  return path31.join(base, "systemd", "user");
 }
 async function runCommand(program, args) {
   const { stdout } = await execFileAsync(program, args);
@@ -20619,19 +21457,19 @@ var init_runner_service = __esm({
       kind = "launchd";
       identifier = LAUNCHD_LABEL;
       unitPath() {
-        return path29.join(launchAgentsDir(), `${LAUNCHD_LABEL}.plist`);
+        return path31.join(launchAgentsDir(), `${LAUNCHD_LABEL}.plist`);
       }
       render(opts) {
         return renderLaunchdPlist({
           label: LAUNCHD_LABEL,
           invocation: opts.invocation,
           env: opts.env,
-          logDir: path29.join(resolveGlobalDataDir(), "logs")
+          logDir: path31.join(resolveGlobalDataDir(), "logs")
         });
       }
       async install(opts) {
-        mkdirSync13(launchAgentsDir(), { recursive: true });
-        mkdirSync13(path29.join(resolveGlobalDataDir(), "logs"), { recursive: true });
+        mkdirSync14(launchAgentsDir(), { recursive: true });
+        mkdirSync14(path31.join(resolveGlobalDataDir(), "logs"), { recursive: true });
         writeServiceFile(this.unitPath(), this.render(opts));
         if (opts.autoStart) await this.start();
       }
@@ -20661,10 +21499,10 @@ var init_runner_service = __esm({
           await this.stop();
         } catch {
         }
-        if (existsSync25(this.unitPath())) rmSync6(this.unitPath());
+        if (existsSync26(this.unitPath())) rmSync6(this.unitPath());
       }
       async status() {
-        const installed = existsSync25(this.unitPath());
+        const installed = existsSync26(this.unitPath());
         try {
           const { stdout } = await runCommand("launchctl", ["list"]);
           const line = stdout.split("\n").find((row) => row.includes(LAUNCHD_LABEL));
@@ -20680,13 +21518,13 @@ var init_runner_service = __esm({
       kind = "systemd";
       identifier = `${SYSTEMD_UNIT_NAME}.service`;
       unitPath() {
-        return path29.join(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
+        return path31.join(systemdUserDir(), `${SYSTEMD_UNIT_NAME}.service`);
       }
       render(opts) {
         return renderSystemdUnit(opts);
       }
       async install(opts) {
-        mkdirSync13(systemdUserDir(), { recursive: true });
+        mkdirSync14(systemdUserDir(), { recursive: true });
         writeServiceFile(this.unitPath(), this.render(opts));
         await runCommand("systemctl", ["--user", "daemon-reload"]);
         await runCommand("systemctl", ["--user", "enable", this.identifier]);
@@ -20707,14 +21545,14 @@ var init_runner_service = __esm({
           await runCommand("systemctl", ["--user", "disable", this.identifier]);
         } catch {
         }
-        if (existsSync25(this.unitPath())) rmSync6(this.unitPath());
+        if (existsSync26(this.unitPath())) rmSync6(this.unitPath());
         try {
           await runCommand("systemctl", ["--user", "daemon-reload"]);
         } catch {
         }
       }
       async status() {
-        const installed = existsSync25(this.unitPath());
+        const installed = existsSync26(this.unitPath());
         try {
           const { stdout } = await runCommand("systemctl", ["--user", "is-active", this.identifier]);
           return { installed, running: stdout.trim() === "active" ? "running" : "stopped" };
@@ -20729,9 +21567,9 @@ var init_runner_service = __esm({
 // src/select-prompt.ts
 import { createInterface as createInterface4 } from "node:readline";
 function parseNumberedSelection(answer, count) {
-  const trimmed = answer.trim();
-  if (!/^\d+$/.test(trimmed)) return null;
-  const value = Number.parseInt(trimmed, 10);
+  const trimmed5 = answer.trim();
+  if (!/^\d+$/.test(trimmed5)) return null;
+  const value = Number.parseInt(trimmed5, 10);
   if (!Number.isInteger(value) || value < 1 || value > count) return null;
   return value - 1;
 }
@@ -20781,14 +21619,14 @@ var init_select_prompt = __esm({
 
 // src/session-key.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync22, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "node:fs";
-import path30 from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import path32 from "node:path";
 function sessionKeyCachePath({
   missionId,
   workingDirectory
 }) {
-  const key = createHash10("sha256").update(`${path30.resolve(workingDirectory)}\0${missionId}`).digest("hex");
-  return path30.join(resolveGlobalDataDir(), "protocol-session-keys", key);
+  const key = createHash10("sha256").update(`${path32.resolve(workingDirectory)}\0${missionId}`).digest("hex");
+  return path32.join(resolveGlobalDataDir(), "protocol-session-keys", key);
 }
 function readCachedSessionKey({
   missionId,
@@ -20796,8 +21634,8 @@ function readCachedSessionKey({
 }) {
   try {
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    if (!existsSync26(filePath)) return void 0;
-    const raw = JSON.parse(readFileSync22(filePath, "utf8"));
+    if (!existsSync27(filePath)) return void 0;
+    const raw = JSON.parse(readFileSync23(filePath, "utf8"));
     return typeof raw.sessionKey === "string" && raw.sessionKey.trim() ? raw.sessionKey.trim() : void 0;
   } catch {
     return void 0;
@@ -20809,13 +21647,13 @@ function writeCachedSessionKey({
   sessionKey
 }) {
   try {
-    const trimmed = sessionKey.trim();
-    if (!trimmed) return;
+    const trimmed5 = sessionKey.trim();
+    if (!trimmed5) return;
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    mkdirSync14(path30.dirname(filePath), { recursive: true });
-    writeFileSync13(
+    mkdirSync15(path32.dirname(filePath), { recursive: true });
+    writeFileSync14(
       filePath,
-      JSON.stringify({ sessionKey: trimmed, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+      JSON.stringify({ sessionKey: trimmed5, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }),
       { mode: 384 }
     );
   } catch {
@@ -20827,7 +21665,7 @@ function clearCachedSessionKey({
 }) {
   try {
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    if (existsSync26(filePath)) rmSync7(filePath);
+    if (existsSync27(filePath)) rmSync7(filePath);
   } catch {
   }
 }
@@ -20845,9 +21683,9 @@ __export(commands_exports, {
   runManagementCommand: () => runManagementCommand,
   runProtocolCommand: () => runProtocolCommand
 });
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "node:fs";
-import os5 from "node:os";
-import path31 from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "node:fs";
+import os6 from "node:os";
+import path33 from "node:path";
 function resourceAccessModeBody(value) {
   if (typeof value !== "string") return {};
   const normalized = value.trim().toLowerCase();
@@ -20893,7 +21731,7 @@ function readChangedFilesFromFlags(flags, stdin) {
   if (typeof fileFlag === "string") {
     const raw = fileFlag === "-" ? stdin ?? "" : (() => {
       try {
-        return readFileSync23(fileFlag, "utf8");
+        return readFileSync24(fileFlag, "utf8");
       } catch {
         return "";
       }
@@ -20945,7 +21783,7 @@ function readJsonFlagContent({
   if (typeof filePath === "string") {
     if (fileInputs[fileFlag] !== void 0) return fileInputs[fileFlag];
     try {
-      return readFileSync23(filePath, "utf8");
+      return readFileSync24(filePath, "utf8");
     } catch {
       return void 0;
     }
@@ -21249,7 +22087,7 @@ async function resolveProtocolFileInputs({
     } else if (process.stdin.isTTY) {
       stdinContent = "";
     } else {
-      stdinContent = readFileSync23(0, "utf8");
+      stdinContent = readFileSync24(0, "utf8");
     }
     return stdinContent;
   };
@@ -21263,7 +22101,7 @@ async function resolveProtocolFileInputs({
       fileInputs[flagName] = content;
       stdinPayload = content;
     } else {
-      fileInputs[flagName] = readFileSync23(filePath, "utf8");
+      fileInputs[flagName] = readFileSync24(filePath, "utf8");
     }
   }
   if (stdinPayload === void 0 && stdin !== void 0 && Object.keys(fileInputs).length === 0) {
@@ -21328,7 +22166,7 @@ async function runProtocolCommand({
   });
   if (subcommand === "record-touched") {
     const missionOverride = flagValue(parsed.flags, "--mission-id") ?? process.env.MISSION_ID ?? process.env.OVERLORD_MISSION_ID;
-    const rawPayload = stdin ?? (process.stdin.isTTY ? "" : readFileSync23(0, "utf8"));
+    const rawPayload = stdin ?? (process.stdin.isTTY ? "" : readFileSync24(0, "utf8"));
     const result2 = recordTouchedFromPayload({
       rawPayload,
       missionOverride,
@@ -21459,9 +22297,9 @@ async function runProtocolCommand({
     clearCachedSessionKey({ missionId, workingDirectory });
     removeActiveSession({ workingDirectory, missionId });
     clearActiveMissionPointer(workingDirectory);
-    const connectorInstallsEditHook = existsSync27(path31.join(os5.homedir(), ".claude")) || existsSync27(
-      path31.join(
-        os5.homedir(),
+    const connectorInstallsEditHook = existsSync28(path33.join(os6.homedir(), ".claude")) || existsSync28(
+      path33.join(
+        os6.homedir(),
         ".cursor",
         "plugins",
         "local",
@@ -21560,7 +22398,7 @@ async function runManagementCommand({
     case "add-cwd": {
       const directory = flagValue(parsed.flags, "--directory") ?? process.cwd();
       const existingProjectJson = readProjectJsonLink(
-        path31.join(directory, ".overlord", "project.json")
+        path33.join(directory, ".overlord", "project.json")
       );
       const resourceKey = flagValue(parsed.flags, "--key") ?? existingProjectJson?.resourceKey;
       let projectId = flagValue(parsed.flags, "--project-id");
@@ -21951,13 +22789,13 @@ async function runManagementCommand({
         rationales: `/api/missions/${encodeURIComponent(missionId)}/file-changes`,
         deliveries: `/api/missions/${encodeURIComponent(missionId)}/deliveries`
       };
-      const path32 = sub ? pathBySub[sub] : void 0;
-      if (!path32) {
+      const path34 = sub ? pathBySub[sub] : void 0;
+      if (!path34) {
         throw new CliError({
           message: "Usage: ovld mission context|events|deliveries|artifacts|rationales <missionId> [--json]"
         });
       }
-      const result = await runtime.backend.get(path32);
+      const result = await runtime.backend.get(path34);
       if (json || sub === "context") printJson(result);
       else if (Array.isArray(result)) for (const row of result) console.log(JSON.stringify(row));
       else printJson(result);
@@ -22127,16 +22965,33 @@ The runner will not register a target for you \u2014 declare this machine first,
           sessionChannelId: typeof sessionChannel.channelId === "string" ? sessionChannel.channelId : void 0,
           sessionChannelToken: typeof sessionChannel.token === "string" ? sessionChannel.token : void 0,
           sessionChannelLaunchKind: typeof sessionChannel.launchKind === "string" ? sessionChannel.launchKind : void 0,
+          launchSession: launchSessionSnapshotFromMetadata(asRecord5(requestRecord.metadata)),
           ...terminal,
           dryRun
         }
       });
+      if (result.providerFallbackWarning) {
+        console.error(`[overlord] ${result.providerFallbackWarning}`);
+      }
+      if (result.viewerOpen && result.viewerOpen.ok === false) {
+        console.error(`[overlord] ${result.viewerOpen.warning}`);
+      }
       if (result.status && result.status !== 0) {
         throw new CliError({ message: `Launch command exited with status ${result.status}` });
       }
-      await runtime.backend.post({ path: `/api/runner/requests/${requestId}/launched` });
+      await runtime.backend.post({
+        path: `/api/runner/requests/${requestId}/launched`,
+        body: result.providerSession ? { providerSession: result.providerSession } : {}
+      });
       if (json || dryRun) {
-        printJson({ request, plan: result.plan, status: result.status });
+        printJson({
+          request,
+          plan: result.plan,
+          status: result.status,
+          providerSession: result.providerSession ?? null,
+          viewerOpen: result.viewerOpen ?? null,
+          providerFallbackWarning: result.providerFallbackWarning ?? null
+        });
       } else {
         console.log(`Launched ${requestedAgent} for ${requestRecord.missionId}`);
       }
@@ -22318,6 +23173,7 @@ var init_commands = __esm({
     init_dist2();
     init_project_metadata();
     init_local_target_mutation_runner();
+    init_terminal_profile_types2();
     init_active_mission();
     init_args();
     init_branch_preparation();