@liberseek/boft-cli-win32-arm64 0.6.2 → 0.6.4

package/app/plugins/claude-code/plugin.mjs

@@ -776,10 +776,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path11) {
-  if (!path11)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path11.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1188,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path11, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path11);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -1339,16 +1339,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path11 = []) => {
+  const processError = (error53, path12 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path11, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1375,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path11 = []) => {
+  const processError = (error53, path12 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path11, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1417,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path11) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14110,13 +14110,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path11 = ref.slice(1).split("/").filter(Boolean);
-  if (path11.length === 0) {
+  const path12 = ref.slice(1).split("/").filter(Boolean);
+  if (path12.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path11[0] === defsKey) {
-    const key = path11[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14550,6 +14550,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15505,7 +15507,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -15539,6 +15543,12 @@ function parseHostUsage(value) {
   if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
   for (const field of percentFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
@@ -15567,10 +15577,13 @@ var HARNESS_BROKER_PROTOCOL_VERSION = 1;
 var HARNESS_BROKER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var HARNESS_BROKER_MAX_PENDING_REQUESTS = 32;
 var HARNESS_BROKER_REQUEST_TIMEOUT_MS = 15e3;
+var HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE = 100;
 var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspect",
   "adapter.inspectAccount",
   "adapter.open",
+  "adapter.sessionImport.list",
+  "adapter.sessionImport.resolve",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
   "session.refreshUsage",
@@ -15719,6 +15732,27 @@ var brokerOpenInputSchema = external_exports.discriminatedUnion("kind", [
   rollbackSchema
 ]);
 var brokerInspectInputSchema = external_exports.object({ cwd: cwdSchema.optional(), refresh: external_exports.boolean().optional() }).strict();
+var brokerSessionImportListParamsSchema = external_exports.object({
+  offset: external_exports.number().int().nonnegative().safe(),
+  limit: external_exports.number().int().min(1).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE)
+}).strict();
+var brokerSessionImportResolveParamsSchema = external_exports.object({ nativeSessionId: harnessSessionImportIdSchema }).strict();
+var brokerSessionImportCandidatesSchema = external_exports.array(harnessSessionImportCandidateSchema);
+var brokerSessionImportPageSchema = external_exports.object({
+  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE),
+  total: external_exports.number().int().nonnegative().safe()
+}).strict();
+var brokerSessionImportSourceSchema = external_exports.object({
+  candidate: harnessSessionImportCandidateSchema,
+  nativeRef: nativeSessionRefSchema
+}).strict().superRefine((source, context) => {
+  if (source.nativeRef.harnessId !== "claude-code" || source.nativeRef.nativeSessionId !== source.candidate.nativeSessionId) {
+    context.addIssue({
+      code: "custom",
+      message: "Claude Session import source identity does not match"
+    });
+  }
+});
 var textInputSchema = external_exports.object({ type: external_exports.literal("text"), text: external_exports.string().max(4e6) }).strict();
 var turnStartSchema = external_exports.object({
   type: external_exports.literal("turn.start"),
@@ -16246,6 +16280,7 @@ var BrokeredHarnessAdapter = class {
   #descriptorPath;
   #connection = null;
   #closed = false;
+  #sessionImportListing = null;
   subagents = {
     readSnapshot: async (input) => {
       try {
@@ -16258,6 +16293,84 @@ var BrokeredHarnessAdapter = class {
       }
     }
   };
+  sessionImport = Object.freeze({
+    listCandidates: () => {
+      this.#sessionImportListing ??= this.#listSessionImportCandidates().finally(() => {
+        this.#sessionImportListing = null;
+      });
+      return this.#sessionImportListing;
+    },
+    resolveCandidate: async (nativeSessionId) => {
+      if (this.#closed) {
+        return {
+          ok: false,
+          error: unavailable("Claude Aqua broker adapter is closed", false)
+        };
+      }
+      try {
+        const result = parseHarnessResult(await (await this.#connect()).request("adapter.sessionImport.resolve", {
+          nativeSessionId
+        }));
+        if (!result.ok)
+          return result;
+        const parsed = brokerSessionImportSourceSchema.safeParse(result.value);
+        if (!parsed.success || parsed.data.candidate.nativeSessionId !== nativeSessionId) {
+          return {
+            ok: false,
+            error: {
+              ...unavailable("Harness broker returned an invalid Session source", false),
+              code: "protocolError"
+            }
+          };
+        }
+        return { ok: true, value: parsed.data };
+      } catch (error52) {
+        this.#connection = null;
+        return {
+          ok: false,
+          error: unavailable(error52 instanceof Error ? error52.message : String(error52))
+        };
+      }
+    }
+  });
+  async #listSessionImportCandidates() {
+    if (this.#closed) {
+      return {
+        ok: false,
+        error: unavailable("Claude Aqua broker adapter is closed", false)
+      };
+    }
+    try {
+      const candidates = [];
+      for (; ; ) {
+        const result = parseHarnessResult(await (await this.#connect()).request("adapter.sessionImport.list", {
+          offset: candidates.length,
+          limit: HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE
+        }));
+        if (!result.ok)
+          return result;
+        const parsed = brokerSessionImportPageSchema.safeParse(result.value);
+        if (!parsed.success || parsed.data.total < candidates.length + parsed.data.candidates.length || parsed.data.candidates.length === 0 && candidates.length < parsed.data.total) {
+          return {
+            ok: false,
+            error: {
+              ...unavailable("Harness broker returned invalid Session candidates", false),
+              code: "protocolError"
+            }
+          };
+        }
+        candidates.push(...parsed.data.candidates);
+        if (candidates.length === parsed.data.total)
+          return { ok: true, value: candidates };
+      }
+    } catch (error52) {
+      this.#connection = null;
+      return {
+        ok: false,
+        error: unavailable(error52 instanceof Error ? error52.message : String(error52))
+      };
+    }
+  }
   constructor(input = {}) {
     if (input.commandCatalog)
       this.commandCatalog = input.commandCatalog;
@@ -16319,7 +16432,7 @@ var BrokeredHarnessAdapter = class {
 
 // dist/claude-code-adapter.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as DW } from "node:module";
@@ -16389,6 +16502,8 @@ import { promisify as tEe } from "util";
 import { execFileSync as GSe } from "child_process";
 import { lstatSync as WSe } from "fs";
 import { join as VSe } from "path";
+import { readdir as FT, stat as CEe } from "fs/promises";
+import { basename as REe, join as zT } from "path";
 import { open as UEe, readdir as sF, rm as iF, stat as $Ee } from "fs/promises";
 import { join as mc } from "path";
 import { randomUUID as n_ } from "crypto";
@@ -25149,6 +25264,19 @@ function Xc(e, t) {
   }
   return;
 }
+function HO(e, t) {
+  let r = e.data;
+  if (r.isSidechain === true) return null;
+  let n = go(r.firstPromptLocked === true ? r.firstPrompt : r.commandFallback) || void 0, o = go(r.customTitle) || go(r.aiTitle) || void 0, i = o || go(r.lastPrompt) || go(r.summaryHint) || n;
+  if (!i) return null;
+  return { sessionId: e.sessionId, summary: i, lastModified: e.mtime, fileSize: void 0, customTitle: o, firstPrompt: n, gitBranch: go(r.gitBranch) || void 0, cwd: go(r.cwd) || t || void 0, tag: go(r.tag) || void 0, createdAt: JW(r.createdAt) };
+}
+function go(e) {
+  return typeof e === "string" ? e : void 0;
+}
+function JW(e) {
+  return typeof e === "number" ? e : void 0;
+}
 var It = class extends Error {
 };
 function Cs() {
@@ -39482,6 +39610,14 @@ async function ao(e) {
   }
 }
 var dn = 65536;
+var sEe = /* @__PURE__ */ new Set(["sdk-cli", "sdk-ts", "sdk-py"]);
+function B1(e, t) {
+  let r = pc(e, "entrypoint") ?? er(t, "entrypoint");
+  if (r && sEe.has(r)) return true;
+  let n = e.split(`
+`).find((i) => i.includes('"parentUuid":')) ?? e, o = pc(n, "sessionKind");
+  return o === "daemon" || o === "daemon-worker";
+}
 var aEe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function ze(e) {
   if (typeof e !== "string") return null;
@@ -39724,6 +39860,126 @@ function fc(e, t, r) {
 `).findLast((T) => T.includes('"type":"tag"') && T.includes('"tag":"')), b = y ? er(y, "tag") || void 0 : void 0;
   return { sessionId: e, summary: g, lastModified: i, fileSize: s, customTitle: u, firstPrompt: d, gitBranch: h, cwd: _, tag: b, createdAt: m };
 }
+async function Gp(e, t, r) {
+  let n;
+  try {
+    n = await FT(e);
+  } catch {
+    return [];
+  }
+  return (await Promise.all(n.map(async (i) => {
+    if (!i.endsWith(".jsonl")) return null;
+    let s = ze(i.slice(0, -6));
+    if (!s) return null;
+    let a = zT(e, i);
+    if (!t) return { sessionId: s, filePath: a, mtime: 0, projectPath: r };
+    try {
+      let c = await CEe(a);
+      return { sessionId: s, filePath: a, mtime: c.mtime.getTime(), projectPath: r };
+    } catch {
+      return null;
+    }
+  }))).filter((i) => i !== null);
+}
+async function tF(e, t) {
+  let r = await r_(e.filePath);
+  if (!r) return null;
+  if (!t && B1(r.head, r.tail)) return null;
+  let n = fc(e.sessionId, r, e.projectPath);
+  if (!n) return null;
+  if (e.mtime) n.lastModified = e.mtime;
+  return n;
+}
+var IEe = 32;
+function PEe(e, t) {
+  if (t.mtime !== e.mtime) return t.mtime - e.mtime;
+  return t.sessionId < e.sessionId ? -1 : t.sessionId > e.sessionId ? 1 : 0;
+}
+async function DEe(e, t, r, n) {
+  e.sort(PEe);
+  let o = [], i = t && t > 0 ? t : 1 / 0, s = 0, a = /* @__PURE__ */ new Set();
+  for (let c = 0; c < e.length && o.length < i; ) {
+    let u = Math.min(c + IEe, e.length), d = e.slice(c, u), f = await Promise.all(d.map((m) => tF(m, n)));
+    for (let m = 0; m < f.length && o.length < i; m++) {
+      c++;
+      let g = f[m];
+      if (!g) continue;
+      if (a.has(g.sessionId)) continue;
+      if (a.add(g.sessionId), s < r) {
+        s++;
+        continue;
+      }
+      o.push(g);
+    }
+  }
+  return o;
+}
+async function LEe(e, t) {
+  let r = await Promise.all(e.map((i) => tF(i, t))), n = /* @__PURE__ */ new Map();
+  for (let i of r) {
+    if (!i) continue;
+    let s = n.get(i.sessionId);
+    if (!s || i.lastModified > s.lastModified) n.set(i.sessionId, i);
+  }
+  let o = [...n.values()];
+  return o.sort((i, s) => s.lastModified !== i.lastModified ? s.lastModified - i.lastModified : s.sessionId < i.sessionId ? -1 : s.sessionId > i.sessionId ? 1 : 0), o;
+}
+async function NEe(e, t, r) {
+  let n = await Jo(e), o;
+  if (t) try {
+    o = await ao(n);
+  } catch {
+    o = [];
+  }
+  else o = [];
+  if (o.length <= 1) {
+    let f = [];
+    for (let m of await fr(n)) f.push(...await Gp(m, r, n));
+    return f;
+  }
+  let i = fn(), s = process.platform === "win32", a = o.map((f) => {
+    let m = us(f);
+    return { path: f, prefix: s ? m.toLowerCase() : m };
+  });
+  a.sort((f, m) => m.prefix.length - f.prefix.length);
+  let c;
+  try {
+    c = await FT(i, { withFileTypes: true });
+  } catch {
+    let f = [];
+    for (let m of await fr(n)) f.push(...await Gp(m, r, n));
+    return f;
+  }
+  let u = [], d = /* @__PURE__ */ new Set();
+  for (let f of await fr(n)) {
+    let m = REe(f);
+    d.add(s ? m.toLowerCase() : m), u.push(...await Gp(f, r, n));
+  }
+  for (let f of c) {
+    if (!f.isDirectory()) continue;
+    let m = s ? f.name.toLowerCase() : f.name;
+    if (d.has(m)) continue;
+    for (let { path: g, prefix: h } of a) if (m === h || h.length >= dc && m.startsWith(h + "-")) {
+      d.add(m), u.push(...await Gp(zT(i, f.name), r, g));
+      break;
+    }
+  }
+  return u;
+}
+async function MEe(e) {
+  let t = fn(), r;
+  try {
+    r = await FT(t, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return (await Promise.all(r.filter((o) => o.isDirectory()).map((o) => Gp(zT(t, o.name), e)))).flat();
+}
+async function rF(e) {
+  let { dir: t, limit: r, offset: n, includeWorktrees: o, includeProgrammatic: i } = e ?? {}, s = n ?? 0, a = i ?? true, c = r !== void 0 && r > 0 || s > 0, u = t ? await NEe(t, o ?? true, c) : await MEe(c);
+  if (!c) return LEe(u, a);
+  return DEe(u, r, s, a);
+}
 async function nF(e, t = {}) {
   let r = ze(e);
   if (!r) return;
@@ -41782,6 +42038,10 @@ function bUe(e, t) {
     n.spawnAbort(m), r.setError(m);
   }), dO(r, n, e, o), r;
 }
+async function Ikt(e) {
+  if (e?.sessionStore) return vUe(e.sessionStore, e);
+  return rF(e);
+}
 async function Pkt(e, t) {
   if (t?.sessionStore) return TUe(t.sessionStore, e, t);
   return nF(e, t);
@@ -41821,9 +42081,53 @@ function lW(e) {
 `) + `
 `;
 }
+function uW(e, t, r) {
+  if (t !== void 0 && t > 0) return e.slice(r, r + t);
+  if (r > 0) return e.slice(r);
+  return e;
+}
 function cO(e) {
   return typeof e === "object" && e !== null && "type" in e && e.type === "agent_metadata";
 }
+async function vUe(e, t) {
+  let r = cW(t.dir), n = us(r), o = t.offset ?? 0, i = t.limit;
+  if (e.listSessionSummaries) return SUe(e, n, r, t.dir, i, o);
+  if (!e.listSessions) throw Error("sessionStore.listSessions is not implemented -- cannot list sessions. Provide a store with a listSessions() method.");
+  let a = (await e.listSessions(n)).slice().sort((u, d) => d.mtime - u.mtime), c = uW(a, i, o);
+  return pW(e, c, t.dir, r);
+}
+async function SUe(e, t, r, n, o, i) {
+  let s = await e.listSessionSummaries(t), a = e.listSessions ? new Map((await e.listSessions(t)).map((f) => [f.sessionId, f])) : void 0, c = [];
+  for (let f of s) {
+    let m = a?.get(f.sessionId);
+    if (a && !m) continue;
+    let g = m !== void 0 && f.mtime < m.mtime;
+    c.push({ sessionId: f.sessionId, mtime: g ? m.mtime : f.mtime, info: g ? void 0 : HO(f, r) });
+  }
+  if (a) {
+    let f = new Set(s.map((m) => m.sessionId));
+    for (let [m, g] of a) if (!f.has(m)) c.push({ sessionId: m, mtime: g.mtime });
+  } else ce("listSessionSummaries without listSessions: gap-fill skipped; sessions lacking a sidecar will be omitted");
+  c.sort((f, m) => m.mtime - f.mtime);
+  let u = uW(c, o, i), d = u.filter((f) => f.info === void 0);
+  if (d.length > 0) {
+    let f = await pW(e, d, n, r), m = new Map(f.map((g) => [g.sessionId, g]));
+    for (let g of u) if (g.info === void 0) g.info = m.get(g.sessionId) ?? null;
+  }
+  return u.flatMap((f) => f.info ? [f.info] : []);
+}
+async function pW(e, t, r, n) {
+  return (await Promise.allSettled(t.map(async (i) => {
+    let s = await fW(e, i.sessionId, r);
+    if (!s) return null;
+    let a = fc(i.sessionId, dW(s, i.mtime), n);
+    return a ? { ...a, lastModified: i.mtime } : null;
+  }))).flatMap((i, s) => {
+    let a = t[s];
+    if (i.status === "fulfilled") return i.value ? [i.value] : [];
+    return [{ sessionId: a.sessionId, summary: "", lastModified: a.mtime }];
+  });
+}
 function dW(e, t) {
   let r = Buffer.from(e, "utf-8"), n = r.length, o = r.subarray(0, dn).toString("utf-8"), i = n > dn ? r.subarray(n - dn).toString("utf-8") : o;
   return { mtime: t, size: n, head: o, tail: i };
@@ -42929,26 +43233,150 @@ async function forkClaudeSession(input) {
   return { ok: true, value: { sessionId: derivedSessionId } };
 }
 
+// dist/claude-session-import.js
+import { realpath, stat } from "node:fs/promises";
+import path6 from "node:path";
+function titleFromMetadata(metadata) {
+  for (const value of [metadata.customTitle, metadata.summary, metadata.firstPrompt]) {
+    if (typeof value !== "string")
+      continue;
+    const title = value.replaceAll("\0", "").trim().slice(0, HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH);
+    if (title)
+      return title;
+  }
+  return null;
+}
+async function sourceFromMetadata(metadata, isRunning, signal, canonicalCwds, preferredCwds = []) {
+  signal.throwIfAborted();
+  if (typeof metadata.sessionId !== "string" || metadata.sessionId.trim().length === 0 || typeof metadata.lastModified !== "number" || !Number.isFinite(metadata.lastModified)) {
+    return null;
+  }
+  const candidates = [
+    ...preferredCwds,
+    ...typeof metadata.cwd === "string" ? [metadata.cwd] : []
+  ];
+  let cwd = null;
+  for (const candidate2 of new Set(candidates)) {
+    if (!path6.isAbsolute(candidate2))
+      continue;
+    let canonical = canonicalCwds.get(candidate2);
+    if (!canonical) {
+      canonical = (async () => {
+        try {
+          const resolved = await realpath(candidate2);
+          return (await stat(resolved)).isDirectory() ? resolved : null;
+        } catch {
+          return null;
+        }
+      })();
+      canonicalCwds.set(candidate2, canonical);
+    }
+    cwd = await canonical;
+    signal.throwIfAborted();
+    if (cwd)
+      break;
+  }
+  if (!cwd)
+    return null;
+  const nativeSessionId = metadata.sessionId.trim();
+  const candidate = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId,
+    cwd,
+    title: titleFromMetadata(metadata),
+    updatedAt: Math.floor(metadata.lastModified),
+    // We know about sessions opened through this Adapter. Other Claude clients do not
+    // expose a reliable cross-process ownership signal, so their activity stays unknown.
+    running: isRunning(nativeSessionId) ? true : null
+  });
+  const nativeRef = nativeSessionRefSchema.safeParse({
+    harnessId: "claude-code",
+    nativeSessionId,
+    formatVersion: 1
+  });
+  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
+}
+var ClaudeSessionImportIndex = class {
+  #dependencies;
+  #listing;
+  constructor(dependencies) {
+    this.#dependencies = dependencies;
+  }
+  list(signal) {
+    this.#listing ??= this.#scan(signal).finally(() => {
+      this.#listing = void 0;
+    });
+    return this.#listing;
+  }
+  async #scan(signal) {
+    signal.throwIfAborted();
+    const metadata = await this.#dependencies.listSessions();
+    signal.throwIfAborted();
+    const sources = [];
+    const identities = /* @__PURE__ */ new Set();
+    const canonicalCwds = /* @__PURE__ */ new Map();
+    for (const session of metadata) {
+      const source = await sourceFromMetadata(session, this.#dependencies.isRunning, signal, canonicalCwds);
+      if (!source)
+        continue;
+      const identity = source.candidate.nativeSessionId;
+      if (identities.has(identity)) {
+        throw new Error(`Claude Session identity is ambiguous: ${identity}`);
+      }
+      identities.add(identity);
+      sources.push(source);
+    }
+    return sources;
+  }
+  async resolve(nativeSessionId, signal) {
+    signal.throwIfAborted();
+    const metadata = await this.#dependencies.getSessionInfo({ sessionId: nativeSessionId });
+    signal.throwIfAborted();
+    if (!metadata || metadata.sessionId !== nativeSessionId)
+      return null;
+    const preferredCwds = [];
+    if (typeof metadata.cwd === "string" && path6.isAbsolute(metadata.cwd)) {
+      try {
+        const messages = await this.#dependencies.readSessionMessages({
+          cwd: metadata.cwd,
+          sessionId: nativeSessionId
+        });
+        signal.throwIfAborted();
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+          const message = messages[index];
+          if (typeof message !== "object" || message === null || Array.isArray(message) || typeof message.cwd !== "string") {
+            continue;
+          }
+          const cwd = message.cwd;
+          if (path6.isAbsolute(cwd) && !preferredCwds.includes(cwd))
+            preferredCwds.push(cwd);
+        }
+      } catch {
+      }
+    }
+    return sourceFromMetadata(metadata, this.#dependencies.isRunning, signal, /* @__PURE__ */ new Map(), preferredCwds);
+  }
+};
+
 // dist/claude-transcript.js
 import os3 from "node:os";
-import path6 from "node:path";
-import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import path7 from "node:path";
+import { readFile as readFile2, readdir, stat as stat2 } from "node:fs/promises";
 function projectDirectoryName(cwd) {
   return cwd.replace(/[^A-Za-z0-9]/gu, "-");
 }
 function configDirectory(environment) {
-  return environment.CLAUDE_CONFIG_DIR ? path6.resolve(environment.CLAUDE_CONFIG_DIR) : path6.join(os3.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path7.resolve(environment.CLAUDE_CONFIG_DIR) : path7.join(os3.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
-    return (await stat(file2)).isFile();
+    return (await stat2(file2)).isFile();
   } catch {
     return false;
   }
 }
 async function findTranscriptFile(environment, cwd, relativeName) {
-  const projectsDirectory = path6.join(configDirectory(environment), "projects");
-  const expected = path6.join(projectsDirectory, projectDirectoryName(cwd), relativeName);
+  const projectsDirectory = path7.join(configDirectory(environment), "projects");
+  const expected = path7.join(projectsDirectory, projectDirectoryName(cwd), relativeName);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -42958,7 +43386,7 @@ async function findTranscriptFile(environment, cwd, relativeName) {
     return null;
   }
   for (const project of projects) {
-    const candidate = path6.join(projectsDirectory, project, relativeName);
+    const candidate = path7.join(projectsDirectory, project, relativeName);
     if (await existingFile(candidate))
       return candidate;
   }
@@ -42992,7 +43420,7 @@ async function readClaudeTranscript(input) {
   return parseTranscriptRecords(await readFile2(transcript, "utf8"), input.sessionId);
 }
 async function readClaudeSubagentTranscript(input) {
-  const relativeName = path6.join(input.sessionId, "subagents", `agent-${input.nativeSubagentId}.jsonl`);
+  const relativeName = path7.join(input.sessionId, "subagents", `agent-${input.nativeSubagentId}.jsonl`);
   const transcript = await findTranscriptFile(input.environment, input.cwd, relativeName);
   if (!transcript)
     return null;
@@ -43259,7 +43687,7 @@ function projectClaudeAccountUsage(usage, account) {
 
 // dist/gateway-models.js
 import { readFile as readFile3 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 var GATEWAY_MODELS_TIMEOUT_MS = 3e3;
 var GATEWAY_MODELS_MAX_BYTES = 2 * 1024 * 1024;
 var OFFICIAL_ANTHROPIC_HOST = "api.anthropic.com";
@@ -43301,14 +43729,14 @@ function claudeConfigDirectory(environment) {
   if (configured)
     return configured;
   const home = trimmedEnv(environment, "HOME") ?? trimmedEnv(environment, "USERPROFILE");
-  return home ? path7.join(home, ".claude") : void 0;
+  return home ? path8.join(home, ".claude") : void 0;
 }
 async function readClaudeUserSettingsEnv(environment) {
   const configDir = claudeConfigDirectory(environment);
   if (!configDir)
     return {};
   try {
-    const raw = await readFile3(path7.join(configDir, "settings.json"), "utf8");
+    const raw = await readFile3(path8.join(configDir, "settings.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
@@ -43440,7 +43868,7 @@ async function applyGatewayModelCatalog(snapshot, environment, dependencies = {}
 }
 
 // dist/file-change.js
-import path8 from "node:path";
+import path9 from "node:path";
 var hunkSchema = external_exports.object({
   oldStart: external_exports.number().int().nonnegative(),
   oldLines: external_exports.number().int().nonnegative(),
@@ -43488,10 +43916,10 @@ function parseClaudeNativeFileChange(toolName, value) {
   };
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path8.resolve(cwd);
-  const resolvedPath = path8.isAbsolute(nativePath) ? path8.resolve(nativePath) : path8.resolve(cwd, nativePath);
-  const relative = path8.relative(resolvedCwd, resolvedPath);
-  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`) ? relative : resolvedPath;
+  const resolvedCwd = path9.resolve(cwd);
+  const resolvedPath = path9.isAbsolute(nativePath) ? path9.resolve(nativePath) : path9.resolve(cwd, nativePath);
+  const relative = path9.relative(resolvedCwd, resolvedPath);
+  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`) ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   return validNativePath(normalized) && normalized !== "." ? normalized : null;
 }
@@ -43503,7 +43931,7 @@ function projectClaudeFileChange(value, cwd) {
     `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
     ...hunk.lines
   ]);
-  const absoluteDisplayPath = path8.posix.isAbsolute(normalizedPath);
+  const absoluteDisplayPath = path9.posix.isAbsolute(normalizedPath);
   const oldHeader = value.kind === "add" ? "/dev/null" : absoluteDisplayPath ? normalizedPath : `a/${normalizedPath}`;
   const newHeader = absoluteDisplayPath ? normalizedPath : `b/${normalizedPath}`;
   const unifiedDiff = [`--- ${oldHeader}`, `+++ ${newHeader}`, ...body, ""].join("\n");
@@ -45631,6 +46059,9 @@ var ClaudeHarnessSession = class {
   initialState;
   initialUsage = null;
   outputs;
+  get nativeSessionId() {
+    return this.#sessionId;
+  }
   #channel = new HarnessOutputChannel();
   #cancelTimeoutMs;
   #closeTimeoutMs;
@@ -47333,9 +47764,31 @@ var ClaudeCodeAdapter = class {
       }
     }
   };
+  sessionImport = Object.freeze({
+    listCandidates: async () => {
+      const result = await this.#readImport((signal) => this.#importIndex.list(signal));
+      return result.ok ? { ok: true, value: result.value.map(({ candidate }) => candidate) } : result;
+    },
+    resolveCandidate: async (nativeSessionId) => {
+      const result = await this.#readImport((signal) => this.#importIndex.resolve(nativeSessionId, signal));
+      if (!result.ok)
+        return result;
+      return result.value ? { ok: true, value: result.value } : {
+        ok: false,
+        error: {
+          code: "sessionNotFound",
+          message: "Claude Code Session is no longer importable",
+          retryable: false
+        }
+      };
+    }
+  });
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #dependencies;
+  #importAbort = new AbortController();
+  #importIndex;
+  #importRequests = /* @__PURE__ */ new Set();
   #toolOutputLimit;
   #continuationQuiescenceMs;
   #inspectionCache = /* @__PURE__ */ new Map();
@@ -47384,10 +47837,10 @@ var ClaudeCodeAdapter = class {
       forkSession: ({ checkpointId, cwd, sourceSessionId }) => Mkt(sourceSessionId, { dir: cwd, upToMessageId: checkpointId }),
       getSessionInfo: async ({ sessionId }) => {
         const info = await Pkt(sessionId);
-        if (!info)
-          return void 0;
-        return info.cwd ? { cwd: info.cwd } : {};
+        return info;
       },
+      // Include SDK-origin Sessions so an orphaned codexhost mapping can also be recovered.
+      listSessions: () => Ikt(),
       readSessionMessages: async ({ cwd, sessionId }) => {
         const transcript = await readClaudeTranscript({
           cwd,
@@ -47408,6 +47861,30 @@ var ClaudeCodeAdapter = class {
         return jkt(sessionId, nativeSubagentId2, { dir: cwd });
       }
     };
+    this.#importIndex = new ClaudeSessionImportIndex({
+      getSessionInfo: (input) => this.#dependencies.getSessionInfo(input),
+      isRunning: (nativeSessionId) => [...this.#sessions].some((session) => session.nativeSessionId === nativeSessionId),
+      listSessions: () => this.#dependencies.listSessions(),
+      readSessionMessages: (input) => this.#dependencies.readSessionMessages(input)
+    });
+  }
+  #readImport(operation) {
+    if (this.#importAbort.signal.aborted) {
+      return Promise.resolve({
+        ok: false,
+        error: invalidState("Claude Code Adapter is closed")
+      });
+    }
+    const request = operation(this.#importAbort.signal).then((value) => ({ ok: true, value })).catch(() => ({
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: "Claude Code Session discovery failed; check native storage access and duplicate Session identities, then retry after closing native clients",
+        retryable: true
+      }
+    })).finally(() => this.#importRequests.delete(request));
+    this.#importRequests.add(request);
+    return request;
   }
   async inspect(input = {}) {
     if (this.#closePromise) {
@@ -47416,7 +47893,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path9.resolve(input.cwd ?? process.cwd());
+    const cwd = path10.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -47562,7 +48039,7 @@ var ClaudeCodeAdapter = class {
       let sourceSnapshot;
       try {
         const messages = await this.#dependencies.readSessionMessages({
-          cwd: path9.resolve(input.cwd),
+          cwd: path10.resolve(input.cwd),
           sessionId: sourceRef.data.nativeSessionId
         });
         sourceSnapshot = mapClaudeSnapshot(messages, sourceRef.data.nativeSessionId);
@@ -47604,7 +48081,7 @@ var ClaudeCodeAdapter = class {
       } else {
         const forked2 = await forkClaudeSession({
           checkpoint: retained.checkpoint,
-          cwd: path9.resolve(input.cwd),
+          cwd: path10.resolve(input.cwd),
           dependencies: this.#dependencies,
           harnessId: this.harnessId,
           sourceRef: sourceRef.data
@@ -47659,7 +48136,7 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const cwd = path9.resolve(input.cwd);
+    const cwd = path10.resolve(input.cwd);
     const nativeRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (nativeRef && (!nativeRef.success || nativeRef.data.harnessId !== this.harnessId)) {
       return {
@@ -47715,8 +48192,10 @@ var ClaudeCodeAdapter = class {
   }
   close() {
     if (!this.#closePromise) {
+      this.#importAbort.abort();
       this.#inspectionCache.clear();
       this.#closePromise = Promise.all([
+        ...this.#importRequests,
         ...[...this.#inspectors].map((inspector) => inspector.close()),
         ...[...this.#sessions].map((session) => session.close()),
         ...this.#inspectionInFlight.values()
@@ -47727,7 +48206,7 @@ var ClaudeCodeAdapter = class {
 };
 
 // dist/user-shell-environment.js
-import path10 from "node:path";
+import path11 from "node:path";
 import { spawnSync } from "node:child_process";
 var ENVIRONMENT_MARKER = Buffer.from("\0CODEXHOST_USER_SHELL_ENV_V1\0");
 var ENVIRONMENT_COMMAND = "printf '\\0CODEXHOST_USER_SHELL_ENV_V1\\0'; /usr/bin/env -0";
@@ -47770,7 +48249,7 @@ function withUserShellEnvironment(environment, dependencies) {
   if (platform === "win32" || !environment.HOME)
     return environment;
   const shell = environment.SHELL?.trim() || defaultShell(platform);
-  if (!shell || !SUPPORTED_SHELLS.has(path10.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path11.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);