tryharness 0.7.23 → 0.7.26

package/lib/places.mjs

@@ -19,14 +19,33 @@ import { mainCheckout } from "./worktrees.mjs";
 // `reopen` is optional: a page it serves on this computer opens directly; a command is only ever copied for the person
 // to paste, never run. Only PLACE_ENV is kept of `env`.
 
-const PS = ["/bin/ps", "/usr/bin/ps"].find((file) => fs.existsSync(file)) || "ps";
+const PS =
+  ["/bin/ps", "/usr/bin/ps"].find((file) => fs.existsSync(file)) || "ps";
 
 /** The names a place is read from: nothing else of a session's environment is kept. */
-export const PLACE_ENV = ["__CFBundleIdentifier", "TERM_PROGRAM", "TMUX", "TMUX_PANE", "WEZTERM_PANE", "KITTY_WINDOW_ID", "KITTY_LISTEN_ON", "WT_SESSION", "VSCODE_GIT_ASKPASS_NODE", "CLAUDE_CODE_ENTRYPOINT", "T3CODE_CLI_PATH"];
+export const PLACE_ENV = [
+  "__CFBundleIdentifier",
+  "TERM_PROGRAM",
+  "TMUX",
+  "TMUX_PANE",
+  "WEZTERM_PANE",
+  "KITTY_WINDOW_ID",
+  "KITTY_LISTEN_ON",
+  "WT_SESSION",
+  "VSCODE_GIT_ASKPASS_NODE",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "T3CODE_CLI_PATH",
+];
 
 export function placeEnv(env) {
   const picked = {};
-  for (const name of PLACE_ENV) if (typeof env?.[name] === "string" && env[name] && env[name].length <= 1024) picked[name] = env[name];
+  for (const name of PLACE_ENV)
+    if (
+      typeof env?.[name] === "string" &&
+      env[name] &&
+      env[name].length <= 1024
+    )
+      picked[name] = env[name];
   return picked;
 }
 
@@ -35,31 +54,88 @@ export function processEnv(pid) {
   if (!Number.isInteger(pid) || pid <= 1) return {};
   if (process.platform === "linux") {
     try {
-      return placeEnv(Object.fromEntries(fs.readFileSync(`/proc/${pid}/environ`, "utf8").split("\0").filter((entry) => entry.includes("="))
-        .map((entry) => [entry.slice(0, entry.indexOf("=")), entry.slice(entry.indexOf("=") + 1)])));
-    } catch { return {}; }
+      return placeEnv(
+        Object.fromEntries(
+          fs
+            .readFileSync(`/proc/${pid}/environ`, "utf8")
+            .split("\0")
+            .filter((entry) => entry.includes("="))
+            .map((entry) => [
+              entry.slice(0, entry.indexOf("=")),
+              entry.slice(entry.indexOf("=") + 1),
+            ])
+        )
+      );
+    } catch {
+      return {};
+    }
   }
   if (process.platform !== "darwin") return {};
   // `ps eww` prints the command, then each variable as NAME=value, space separated (values may hold spaces).
-  const line = spawnSync(PS, ["eww", "-o", "command=", "-p", String(pid)], { encoding: "utf8", timeout: 3_000 }).stdout || "";
+  const line =
+    spawnSync(PS, ["eww", "-o", "command=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 3_000,
+    }).stdout || "";
   const env = {};
   for (const name of PLACE_ENV) {
-    const found = line.match(new RegExp(`(?:^|\\s)${name}=(.*?)(?=\\s[A-Za-z_][A-Za-z0-9_]*=|\\s*$)`));
+    const found = line.match(
+      new RegExp(`(?:^|\\s)${name}=(.*?)(?=\\s[A-Za-z_][A-Za-z0-9_]*=|\\s*$)`)
+    );
     if (found?.[1]) env[name] = found[1];
   }
   return placeEnv(env);
 }
 
-export const appDirs = () => (process.env.HARNESS_APP_DIRS ? process.env.HARNESS_APP_DIRS.split(path.delimiter) : ["/Applications", path.join(os.homedir(), "Applications")]);
+export const appDirs = () =>
+  process.env.HARNESS_APP_DIRS
+    ? process.env.HARNESS_APP_DIRS.split(path.delimiter)
+    : ["/Applications", path.join(os.homedir(), "Applications")];
 
 // ── Editors built on VS Code ──────────────────────────────────────────────────
 
 /** Each one's app, link scheme, command-line tool, settings folder and extensions folder. */
 const EDITORS = [
-  { id: "cursor", name: "Cursor", bundle: "com.todesktop.230313mzl4w4u92", match: /cursor/i, scheme: "cursor", cli: "cursor", data: "Cursor", extensions: ".cursor" },
-  { id: "windsurf", name: "Windsurf", bundle: "com.exafunction.windsurf", match: /windsurf/i, scheme: "windsurf", cli: "windsurf", data: "Windsurf", extensions: ".windsurf" },
-  { id: "vscode-insiders", name: "Visual Studio Code - Insiders", bundle: "com.microsoft.VSCodeInsiders", match: /insiders/i, scheme: "vscode-insiders", cli: "code-insiders", data: "Code - Insiders", extensions: ".vscode-insiders" },
-  { id: "vscode", name: "Visual Studio Code", bundle: "com.microsoft.VSCode", match: /visual studio code|microsoft vs code|[\\/]code[\\/]/i, scheme: "vscode", cli: "code", data: "Code", extensions: ".vscode" },
+  {
+    id: "cursor",
+    name: "Cursor",
+    bundle: "com.todesktop.230313mzl4w4u92",
+    match: /cursor/i,
+    scheme: "cursor",
+    cli: "cursor",
+    data: "Cursor",
+    extensions: ".cursor",
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    bundle: "com.exafunction.windsurf",
+    match: /windsurf/i,
+    scheme: "windsurf",
+    cli: "windsurf",
+    data: "Windsurf",
+    extensions: ".windsurf",
+  },
+  {
+    id: "vscode-insiders",
+    name: "Visual Studio Code - Insiders",
+    bundle: "com.microsoft.VSCodeInsiders",
+    match: /insiders/i,
+    scheme: "vscode-insiders",
+    cli: "code-insiders",
+    data: "Code - Insiders",
+    extensions: ".vscode-insiders",
+  },
+  {
+    id: "vscode",
+    name: "Visual Studio Code",
+    bundle: "com.microsoft.VSCode",
+    match: /visual studio code|microsoft vs code|[\\/]code[\\/]/i,
+    scheme: "vscode",
+    cli: "code",
+    data: "Code",
+    extensions: ".vscode",
+  },
 ];
 export const EDITOR_IDS = EDITORS.map((editor) => editor.id);
 const editorById = (id) => EDITORS.find((editor) => editor.id === id) ?? null;
@@ -71,31 +147,75 @@ export function editorInstall(editorId, hint = "") {
   if (!editor) return null;
   const tries = [];
   const app = String(hint).match(/^(.*?\.app)(?:\/|$)/)?.[1];
-  if (app) tries.push({ app, cli: path.join(app, "Contents", "Resources", "app", "bin", editor.cli) });
+  if (app)
+    tries.push({
+      app,
+      cli: path.join(app, "Contents", "Resources", "app", "bin", editor.cli),
+    });
   // Linux and Windows: the editor's executable sits beside its bin folder.
-  else if (hint && path.isAbsolute(hint)) tries.push({ app: path.dirname(hint), cli: path.join(path.dirname(hint), "bin", editor.cli + (process.platform === "win32" ? ".cmd" : "")) });
+  else if (hint && path.isAbsolute(hint))
+    tries.push({
+      app: path.dirname(hint),
+      cli: path.join(
+        path.dirname(hint),
+        "bin",
+        editor.cli + (process.platform === "win32" ? ".cmd" : "")
+      ),
+    });
   for (const dir of appDirs()) {
     const at = path.join(dir, `${editor.name}.app`);
-    tries.push({ app: at, cli: path.join(at, "Contents", "Resources", "app", "bin", editor.cli) });
+    tries.push({
+      app: at,
+      cli: path.join(at, "Contents", "Resources", "app", "bin", editor.cli),
+    });
   }
   return tries.find((entry) => fs.existsSync(entry.cli)) ?? null;
 }
 
 function editorData(editor) {
-  if (process.env.HARNESS_EDITOR_ROOT) return path.join(process.env.HARNESS_EDITOR_ROOT, editor.data);
-  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", editor.data);
-  if (process.platform === "win32") return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), editor.data);
-  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), editor.data);
+  if (process.env.HARNESS_EDITOR_ROOT)
+    return path.join(process.env.HARNESS_EDITOR_ROOT, editor.data);
+  if (process.platform === "darwin")
+    return path.join(
+      os.homedir(),
+      "Library",
+      "Application Support",
+      editor.data
+    );
+  if (process.platform === "win32")
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"),
+      editor.data
+    );
+  return path.join(
+    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+    editor.data
+  );
 }
 
 /** Whether an editor has an extension installed (and not marked for removal). */
 export function editorHas(editorId, extension) {
   const editor = editorById(editorId);
   if (!editor) return false;
-  const dir = path.join(process.env.HARNESS_EDITOR_ROOT || os.homedir(), editor.extensions, "extensions");
+  const dir = path.join(
+    process.env.HARNESS_EDITOR_ROOT || os.homedir(),
+    editor.extensions,
+    "extensions"
+  );
   let removed = {};
-  try { removed = JSON.parse(fs.readFileSync(path.join(dir, ".obsolete"), "utf8")); } catch {}
-  try { return fs.readdirSync(dir).some((name) => name.toLowerCase().startsWith(`${extension}-`) && !removed[name]); } catch { return false; }
+  try {
+    removed = JSON.parse(fs.readFileSync(path.join(dir, ".obsolete"), "utf8"));
+  } catch {}
+  try {
+    return fs
+      .readdirSync(dir)
+      .some(
+        (name) =>
+          name.toLowerCase().startsWith(`${extension}-`) && !removed[name]
+      );
+  } catch {
+    return false;
+  }
 }
 
 /**
@@ -108,11 +228,25 @@ export function editorFolder(editorId, folder) {
   const root = path.join(editorData(editor), "User", "workspaceStorage");
   let best = null;
   let dirs = [];
-  try { dirs = fs.readdirSync(root); } catch {}
+  try {
+    dirs = fs.readdirSync(root);
+  } catch {}
   for (const dir of dirs) {
     let opened;
-    try { opened = fileURLToPath(JSON.parse(fs.readFileSync(path.join(root, dir, "workspace.json"), "utf8")).folder); } catch { continue; }
-    if ((folder === opened || folder.startsWith(opened + path.sep)) && (!best || opened.length > best.length)) best = opened;
+    try {
+      opened = fileURLToPath(
+        JSON.parse(
+          fs.readFileSync(path.join(root, dir, "workspace.json"), "utf8")
+        ).folder
+      );
+    } catch {
+      continue;
+    }
+    if (
+      (folder === opened || folder.startsWith(opened + path.sep)) &&
+      (!best || opened.length > best.length)
+    )
+      best = opened;
   }
   return best ?? folder;
 }
@@ -122,13 +256,24 @@ export function editorFolder(editorId, folder) {
  * else a new one on it. No link, so the editor asks nothing; its tool brings itself forward.
  */
 export function openEditorFolder(place, folder) {
-  if (!place?.cli || !folder || !path.isAbsolute(folder) || !fs.existsSync(place.cli)) return false;
+  if (
+    !place?.cli ||
+    !folder ||
+    !path.isAbsolute(folder) ||
+    !fs.existsSync(place.cli)
+  )
+    return false;
   const env = { ...process.env };
   // Not inside one of its terminals: a tool started there would replace that window's folder.
   delete env.VSCODE_IPC_HOOK_CLI;
   delete env.ELECTRON_RUN_AS_NODE;
   const windows = process.platform === "win32";
-  const child = spawn(place.cli, [windows ? `"${folder}"` : folder], { env, detached: !windows, stdio: "ignore", shell: windows });
+  const child = spawn(place.cli, [windows ? `"${folder}"` : folder], {
+    env,
+    detached: !windows,
+    stdio: "ignore",
+    shell: windows,
+  });
   child.on("error", () => {});
   child.unref();
   return true;
@@ -137,22 +282,60 @@ export function openEditorFolder(place, folder) {
 /** How many times the person started a command in an editor's terminal, by the editor's own record of its last commands. */
 export function editorTerminalStarts(editorId, command) {
   const editor = editorById(editorId);
-  const db = editor ? path.join(editorData(editor), "User", "globalStorage", "state.vscdb") : null;
+  const db = editor
+    ? path.join(editorData(editor), "User", "globalStorage", "state.vscdb")
+    : null;
   if (!db || !fs.existsSync(db) || !fs.existsSync(SQLITE)) return 0;
-  const found = spawnSync(SQLITE, ["-readonly", "-cmd", ".timeout 500", db, "select value from ItemTable where key = 'terminal.history.entries.commands';"], { encoding: "utf8", timeout: 3_000 });
+  const found = spawnSync(
+    SQLITE,
+    [
+      "-readonly",
+      "-cmd",
+      ".timeout 500",
+      db,
+      "select value from ItemTable where key = 'terminal.history.entries.commands';",
+    ],
+    { encoding: "utf8", timeout: 3_000 }
+  );
   let entries = [];
-  try { entries = JSON.parse(found.stdout || "{}").entries || []; } catch { return 0; }
-  return entries.filter((entry) => path.basename(String(entry?.key || "").trim().split(/\s+/)[0] || "") === command).length;
+  try {
+    entries = JSON.parse(found.stdout || "{}").entries || [];
+  } catch {
+    return 0;
+  }
+  return entries.filter(
+    (entry) =>
+      path.basename(
+        String(entry?.key || "")
+          .trim()
+          .split(/\s+/)[0] || ""
+      ) === command
+  ).length;
 }
 
 // ── The agents ────────────────────────────────────────────────────────────────
 
 /** How each agent picks a session up again; its own panel in an editor, when it has one; its name in T3 Code. */
 const AGENTS = {
-  "claude-code": { command: "claude", resume: "claude --resume", t3: "claudeAgent",
-    panel: { extension: "anthropic.claude-code", link: (scheme, id) => `${scheme}://anthropic.claude-code/open?session=${id}` } },
-  codex: { command: "codex", resume: "codex resume", t3: "codex",
-    panel: { extension: "openai.chatgpt", link: (scheme, id) => `${scheme}://openai.chatgpt/local/${id}` } },
+  "claude-code": {
+    command: "claude",
+    resume: "claude --resume",
+    t3: "claudeAgent",
+    panel: {
+      extension: "anthropic.claude-code",
+      link: (scheme, id) =>
+        `${scheme}://anthropic.claude-code/open?session=${id}`,
+    },
+  },
+  codex: {
+    command: "codex",
+    resume: "codex resume",
+    t3: "codex",
+    panel: {
+      extension: "openai.chatgpt",
+      link: (scheme, id) => `${scheme}://openai.chatgpt/local/${id}`,
+    },
+  },
   pi: { command: "pi", resume: "pi --session" },
   opencode: { command: "opencode", resume: "opencode --session" },
 };
@@ -175,7 +358,14 @@ export function editorRunsOpenTasks(editorId) {
   const editor = editorById(editorId);
   if (!editor) return false;
   let settings = "";
-  try { settings = fs.readFileSync(path.join(editorData(editor), "User", "settings.json"), "utf8"); } catch { return true; }
+  try {
+    settings = fs.readFileSync(
+      path.join(editorData(editor), "User", "settings.json"),
+      "utf8"
+    );
+  } catch {
+    return true;
+  }
   return !/"task\.allowAutomaticTasks"\s*:\s*"off"/.test(settings);
 }
 
@@ -185,25 +375,71 @@ export function editorRunsOpenTasks(editorId) {
  * and to allow such tasks). Through the person's login shell, so the agent runs with their own setup. The file lives in
  * Harness's folder, never in the person's; its path, or null when the agent has no resume command.
  */
-export function editorSessionWorkspace(agent, sessionId, folder, window = folder) {
+export function editorSessionWorkspace(
+  agent,
+  sessionId,
+  folder,
+  window = folder
+) {
   const resume = AGENTS[agent]?.resume;
-  if (!resume || !PLAIN_ID.test(String(sessionId || "")) || !folder || !path.isAbsolute(folder)) return null;
+  if (
+    !resume ||
+    !PLAIN_ID.test(String(sessionId || "")) ||
+    !folder ||
+    !path.isAbsolute(folder)
+  )
+    return null;
   // Through the person's login shell (VS Code's default terminal on Windows), with a Node the agent accepts first.
-  const shell = process.platform === "win32" ? null : process.env.SHELL || os.userInfo().shell || "/bin/sh";
+  const shell =
+    process.platform === "win32"
+      ? null
+      : process.env.SHELL || os.userInfo().shell || "/bin/sh";
   const { bin } = agentEnvironment(AGENTS[agent].command);
-  const name = `${path.basename(window || folder)} - ${agent} ${String(sessionId).replace(/^ses_/, "").slice(0, 8)}`.replace(/[^A-Za-z0-9 ._-]/g, "-");
+  const name =
+    `${path.basename(window || folder)} - ${agent} ${String(sessionId).replace(/^ses_/, "").slice(0, 8)}`.replace(
+      /[^A-Za-z0-9 ._-]/g,
+      "-"
+    );
   const file = path.join(paths.home, "editor", `${name}.code-workspace`);
   fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(file, JSON.stringify({
-    folders: [{ path: window || folder }],
-    tasks: { version: "2.0.0", tasks: [{
-      label: `${agent} session ${sessionId}`, type: "shell", command: `${resume} ${sessionId}`,
-      options: { cwd: folder, ...(shell ? { shell: { executable: shell, args: ["-l", "-i", "-c"] } } : {}), ...(bin ? { env: { PATH: `${bin}${path.delimiter}\${env:PATH}` } } : {}) },
-      runOptions: { runOn: "folderOpen" },
-      presentation: { reveal: "always", focus: true, panel: "dedicated", clear: true },
-      problemMatcher: [],
-    }] },
-  }, null, 2), { mode: 0o600 });
+  fs.writeFileSync(
+    file,
+    JSON.stringify(
+      {
+        folders: [{ path: window || folder }],
+        tasks: {
+          version: "2.0.0",
+          tasks: [
+            {
+              label: `${agent} session ${sessionId}`,
+              type: "shell",
+              command: `${resume} ${sessionId}`,
+              options: {
+                cwd: folder,
+                ...(shell
+                  ? { shell: { executable: shell, args: ["-l", "-i", "-c"] } }
+                  : {}),
+                ...(bin
+                  ? { env: { PATH: `${bin}${path.delimiter}\${env:PATH}` } }
+                  : {}),
+              },
+              runOptions: { runOn: "folderOpen" },
+              presentation: {
+                reveal: "always",
+                focus: true,
+                panel: "dedicated",
+                clear: true,
+              },
+              problemMatcher: [],
+            },
+          ],
+        },
+      },
+      null,
+      2
+    ),
+    { mode: 0o600 }
+  );
   return file;
 }
 
@@ -211,7 +447,13 @@ export function editorSessionWorkspace(agent, sessionId, folder, window = folder
 export function panelLink(agent, editorId, sessionId) {
   const panel = AGENTS[agent]?.panel;
   const editor = editorById(editorId);
-  if (!panel || !editor || !UUID.test(String(sessionId || "")) || !editorHas(editorId, panel.extension)) return null;
+  if (
+    !panel ||
+    !editor ||
+    !UUID.test(String(sessionId || "")) ||
+    !editorHas(editorId, panel.extension)
+  )
+    return null;
   return panel.link(editor.scheme, sessionId);
 }
 
@@ -219,22 +461,41 @@ export function panelLink(agent, editorId, sessionId) {
 
 const SQLITE = "/usr/bin/sqlite3";
 const T3_BUNDLE = "com.t3tools.t3code";
-export const t3Home = () => process.env.T3_HOME || path.join(os.homedir(), ".t3", "userdata");
+export const t3Home = () =>
+  process.env.T3_HOME || path.join(os.homedir(), ".t3", "userdata");
 
 /** T3 Code's state database: 0.0.46 nightlies (Orchestrator V2) keep a copy of their own, statev2.sqlite; the newer file is the one in use. */
 function t3Database(home) {
-  const [found] = ["statev2.sqlite", "state.sqlite"].map((name) => path.join(home, name))
-    .map((file) => { try { return { file, at: fs.statSync(file).mtimeMs }; } catch { return null; } })
-    .filter(Boolean).sort((a, b) => b.at - a.at);
+  const [found] = ["statev2.sqlite", "state.sqlite"]
+    .map((name) => path.join(home, name))
+    .map((file) => {
+      try {
+        return { file, at: fs.statSync(file).mtimeMs };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.at - a.at);
   return found?.file ?? null;
 }
 function t3Query(home, sql) {
   const db = t3Database(home);
   if (!db || !fs.existsSync(SQLITE)) return null;
-  const found = spawnSync(SQLITE, ["-readonly", "-cmd", ".timeout 500", db, sql], { encoding: "utf8", timeout: 3_000 });
+  const found = spawnSync(
+    SQLITE,
+    ["-readonly", "-cmd", ".timeout 500", db, sql],
+    { encoding: "utf8", timeout: 3_000 }
+  );
   return found.status === 0 ? (found.stdout || "").trim() : null;
 }
-const t3Tables = (home) => new Set((t3Query(home, "select name from sqlite_master where type = 'table';") || "").split("\n"));
+const t3Tables = (home) =>
+  new Set(
+    (
+      t3Query(home, "select name from sqlite_master where type = 'table';") ||
+      ""
+    ).split("\n")
+  );
 
 /**
  * The T3 Code thread that has a provider session: the thread T3 ran it in (nightlies record the session on the thread's
@@ -246,31 +507,77 @@ export function t3Thread(sessionId, home = t3Home()) {
   const tables = t3Tables(home);
   // The id is checked above: letters, digits and . _ : - only.
   const parts = [];
-  if (tables.has("orchestration_v2_projection_provider_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_provider_threads where thread_id is not null and json_extract(payload_json, '$.nativeThreadRef.nativeId') = '${sessionId}'`);
-  if (tables.has("orchestration_v2_projection_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_threads where deleted_at is null and thread_id in ('${sessionId}', 'import:claudeAgent:${sessionId}', 'import:codex:${sessionId}')`);
-  else if (tables.has("provider_session_runtime")) parts.push(`select thread_id, last_seen_at as at from provider_session_runtime where thread_id like '%:${sessionId}' or json_extract(resume_cursor_json, '$.resume') = '${sessionId}'`);
+  if (tables.has("orchestration_v2_projection_provider_threads"))
+    parts.push(
+      `select thread_id, updated_at as at from orchestration_v2_projection_provider_threads where thread_id is not null and json_extract(payload_json, '$.nativeThreadRef.nativeId') = '${sessionId}'`
+    );
+  if (tables.has("orchestration_v2_projection_threads"))
+    parts.push(
+      `select thread_id, updated_at as at from orchestration_v2_projection_threads where deleted_at is null and thread_id in ('${sessionId}', 'import:claudeAgent:${sessionId}', 'import:codex:${sessionId}')`
+    );
+  else if (tables.has("provider_session_runtime"))
+    parts.push(
+      `select thread_id, last_seen_at as at from provider_session_runtime where thread_id like '%:${sessionId}' or json_extract(resume_cursor_json, '$.resume') = '${sessionId}'`
+    );
   if (!parts.length) return null;
-  return t3Query(home, `select thread_id from (${parts.join(" union all ")}) order by at desc limit 1;`) || null;
+  return (
+    t3Query(
+      home,
+      `select thread_id from (${parts.join(" union all ")}) order by at desc limit 1;`
+    ) || null
+  );
 }
 
 /** T3 Code's own link to one of its threads (t3code://threads/<environment>/<thread>). */
 export function t3Link(threadId, home = t3Home()) {
   let environment = "";
-  try { environment = fs.readFileSync(path.join(home, "environment-id"), "utf8").trim(); } catch { return null; }
-  return threadId && PLAIN_ID.test(environment) ? `t3code://threads/${environment}/${encodeURIComponent(threadId)}` : null;
+  try {
+    environment = fs
+      .readFileSync(path.join(home, "environment-id"), "utf8")
+      .trim();
+  } catch {
+    return null;
+  }
+  return threadId && PLAIN_ID.test(environment)
+    ? `t3code://threads/${environment}/${encodeURIComponent(threadId)}`
+    : null;
 }
 
-const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return null; } };
+const realDir = (dir) => {
+  try {
+    return fs.realpathSync(dir);
+  } catch {
+    return null;
+  }
+};
 
 /** The T3 Code project for a folder: the one T3 opened on the folder itself or on the repository it is in. */
 export function t3Project(folder, home = t3Home()) {
   if (!folder || !t3Tables(home).has("projection_projects")) return null;
-  const top = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: folder, encoding: "utf8" });
+  const top = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: folder,
+    encoding: "utf8",
+  });
   const root = top.status === 0 ? top.stdout.trim() : null;
   // A worktree of a project's checkout (a thread's copy here, T3's own) is that project's, as T3 counts it.
-  const wanted = new Set([realDir(folder), root && realDir(root), root && realDir(mainCheckout(root))].filter(Boolean));
-  const rows = (t3Query(home, "select project_id || char(9) || workspace_root from projection_projects where deleted_at is null;") || "").split("\n").map((line) => line.split("\t"));
-  const found = rows.find(([id, root]) => id && root && wanted.has(realDir(root)));
+  const wanted = new Set(
+    [
+      realDir(folder),
+      root && realDir(root),
+      root && realDir(mainCheckout(root)),
+    ].filter(Boolean)
+  );
+  const rows = (
+    t3Query(
+      home,
+      "select project_id || char(9) || workspace_root from projection_projects where deleted_at is null;"
+    ) || ""
+  )
+    .split("\n")
+    .map((line) => line.split("\t"));
+  const found = rows.find(
+    ([id, root]) => id && root && wanted.has(realDir(root))
+  );
   return found ? { id: found[0], root: realDir(found[1]) } : null;
 }
 
@@ -280,28 +587,55 @@ export function t3Project(folder, home = t3Home()) {
  */
 export function t3ThreadIn(folder, home = t3Home()) {
   const dir = folder ? realDir(folder) : null;
-  if (!dir || !t3Tables(home).has("orchestration_v2_projection_threads")) return null;
+  if (!dir || !t3Tables(home).has("orchestration_v2_projection_threads"))
+    return null;
   const project = t3Project(folder, home);
-  const rows = (t3Query(home, "select thread_id || char(9) || coalesce(project_id, '') || char(9) || coalesce(json_extract(payload_json, '$.worktreePath'), '') from orchestration_v2_projection_threads where deleted_at is null and archived_at is null order by updated_at desc;") || "")
-    .split("\n").map((line) => line.split("\t")).filter(([id]) => id);
+  const rows = (
+    t3Query(
+      home,
+      "select thread_id || char(9) || coalesce(project_id, '') || char(9) || coalesce(json_extract(payload_json, '$.worktreePath'), '') from orchestration_v2_projection_threads where deleted_at is null and archived_at is null order by updated_at desc;"
+    ) || ""
+  )
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter(([id]) => id);
   const inProject = project ? rows.filter(([, id]) => id === project.id) : [];
-  const found = rows.find(([, , tree]) => tree && realDir(tree) === dir)
-    ?? (dir === project?.root ? inProject.find(([, , tree]) => !tree) : null) ?? inProject[0];
+  const found =
+    rows.find(([, , tree]) => tree && realDir(tree) === dir) ??
+    (dir === project?.root ? inProject.find(([, , tree]) => !tree) : null) ??
+    inProject[0];
   return found?.[0] ?? null;
 }
 
 /** Every folder T3 Code has a project for. */
 export function t3Projects(home = t3Home()) {
   if (!t3Tables(home).has("projection_projects")) return [];
-  return (t3Query(home, "select workspace_root from projection_projects where deleted_at is null;") || "").split("\n").map(realDir).filter(Boolean);
+  return (
+    t3Query(
+      home,
+      "select workspace_root from projection_projects where deleted_at is null;"
+    ) || ""
+  )
+    .split("\n")
+    .map(realDir)
+    .filter(Boolean);
 }
 
 /** The model (and its options) the person last ran an agent with in T3 Code, as T3 records each thread's choice. */
 export function t3Model(agent, home = t3Home()) {
   const provider = t3Provider(agent);
-  if (!provider || !t3Tables(home).has("orchestration_v2_projection_threads")) return null;
-  const raw = t3Query(home, `select json_extract(payload_json, '$.modelSelection') from orchestration_v2_projection_threads where deleted_at is null and json_extract(payload_json, '$.modelSelection.instanceId') = '${provider}' order by updated_at desc limit 1;`);
-  try { const model = JSON.parse(raw || "null"); return typeof model?.model === "string" ? model : null; } catch { return null; }
+  if (!provider || !t3Tables(home).has("orchestration_v2_projection_threads"))
+    return null;
+  const raw = t3Query(
+    home,
+    `select json_extract(payload_json, '$.modelSelection') from orchestration_v2_projection_threads where deleted_at is null and json_extract(payload_json, '$.modelSelection.instanceId') = '${provider}' order by updated_at desc limit 1;`
+  );
+  try {
+    const model = JSON.parse(raw || "null");
+    return typeof model?.model === "string" ? model : null;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -312,18 +646,36 @@ export function t3Model(agent, home = t3Home()) {
 export function t3Working(agent, home = t3Home()) {
   const provider = t3Provider(agent);
   const tables = t3Tables(home);
-  if (!provider || !tables.has("orchestration_v2_projection_provider_threads") || !tables.has("orchestration_v2_projection_threads")) return [];
+  if (
+    !provider ||
+    !tables.has("orchestration_v2_projection_provider_threads") ||
+    !tables.has("orchestration_v2_projection_threads")
+  )
+    return [];
   const projects = tables.has("projection_projects");
-  const rows = t3Query(home, `select p.thread_id || char(9) || json_extract(p.payload_json, '$.nativeThreadRef.nativeId') || char(9) || coalesce(json_extract(t.payload_json, '$.worktreePath'), ${projects ? "r.workspace_root, " : ""}'') || char(9) || p.updated_at
+  const rows = t3Query(
+    home,
+    `select p.thread_id || char(9) || json_extract(p.payload_json, '$.nativeThreadRef.nativeId') || char(9) || coalesce(json_extract(t.payload_json, '$.worktreePath'), ${projects ? "r.workspace_root, " : ""}'') || char(9) || p.updated_at
     from orchestration_v2_projection_provider_threads p join orchestration_v2_projection_threads t on t.thread_id = p.thread_id${projects ? " left join projection_projects r on r.project_id = t.project_id" : ""}
-    where p.provider = '${provider}' and p.status = 'active' and t.deleted_at is null;`);
-  return (rows || "").split("\n").map((line) => line.split("\t")).filter(([thread, session]) => thread && PLAIN_ID.test(session || ""))
-    .map(([thread, session, folder, at]) => ({ thread, sessionId: session, folder: folder || null, at: Date.parse(at) || 0 }));
+    where p.provider = '${provider}' and p.status = 'active' and t.deleted_at is null;`
+  );
+  return (rows || "")
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter(([thread, session]) => thread && PLAIN_ID.test(session || ""))
+    .map(([thread, session, folder, at]) => ({
+      thread,
+      sessionId: session,
+      folder: folder || null,
+      at: Date.parse(at) || 0,
+    }));
 }
 
 /** True while T3 Code is open on this computer. */
 export function t3Open() {
-  const running = spawnSync(PS, ["-axo", "comm="], { encoding: "utf8", maxBuffer: 16 << 20 }).stdout || "";
+  const running =
+    spawnSync(PS, ["-axo", "comm="], { encoding: "utf8", maxBuffer: 16 << 20 })
+      .stdout || "";
   return /\/T3 Code\b[^/\n]*\.app\/Contents\/MacOS\//.test(running);
 }
 
@@ -333,9 +685,19 @@ export function t3Runs(agent, sinceIso, home = t3Home()) {
   if (!provider || !/^[0-9TZ:.-]+$/.test(sinceIso)) return 0;
   const tables = t3Tables(home);
   const parts = [];
-  if (tables.has("orchestration_v2_projection_provider_threads")) parts.push(`select thread_id from orchestration_v2_projection_provider_threads where provider = '${provider}' and updated_at > '${sinceIso}'`);
-  if (tables.has("provider_session_runtime")) parts.push(`select thread_id from provider_session_runtime where provider_name = '${provider}' and last_seen_at > '${sinceIso}' and (thread_id not like 'import:%' or resume_cursor_json like '%turnCount%')`);
-  return parts.length ? Number(t3Query(home, `select count(*) from (${parts.join(" union ")});`) || 0) || 0 : 0;
+  if (tables.has("orchestration_v2_projection_provider_threads"))
+    parts.push(
+      `select thread_id from orchestration_v2_projection_provider_threads where provider = '${provider}' and updated_at > '${sinceIso}'`
+    );
+  if (tables.has("provider_session_runtime"))
+    parts.push(
+      `select thread_id from provider_session_runtime where provider_name = '${provider}' and last_seen_at > '${sinceIso}' and (thread_id not like 'import:%' or resume_cursor_json like '%turnCount%')`
+    );
+  return parts.length
+    ? Number(
+        t3Query(home, `select count(*) from (${parts.join(" union ")});`) || 0
+      ) || 0
+    : 0;
 }
 
 // T3 Code opens thread and prompt links from other apps only in its newer builds (0.0.46 nightlies on); 0.0.45 hands
@@ -345,27 +707,62 @@ const t3LinkSupport = new Map();
 export function t3OpensLinks(app) {
   const archive = path.join(app, "Contents", "Resources", "app.asar");
   let stamp = "";
-  try { stamp = String(fs.statSync(archive).mtimeMs); } catch { return false; }
+  try {
+    stamp = String(fs.statSync(archive).mtimeMs);
+  } catch {
+    return false;
+  }
   const known = t3LinkSupport.get(archive);
   if (known?.stamp === stamp) return known.ok;
   let ok = false;
-  try { ok = fs.readFileSync(archive).includes("so T3 Code did not open it"); } catch {}
+  try {
+    ok = fs.readFileSync(archive).includes("so T3 Code did not open it");
+  } catch {}
   t3LinkSupport.set(archive, { stamp, ok });
   return ok;
 }
 
 /** T3 Code's app: the one running when several builds are installed (stable and nightly side by side), else one that opens links, else any. */
 export function t3App() {
-  const apps = appDirs().flatMap((dir) => { try { return fs.readdirSync(dir).filter((entry) => /^T3 Code\b.*\.app$/.test(entry)).map((entry) => path.join(dir, entry)); } catch { return []; } });
+  const apps = appDirs().flatMap((dir) => {
+    try {
+      return fs
+        .readdirSync(dir)
+        .filter((entry) => /^T3 Code\b.*\.app$/.test(entry))
+        .map((entry) => path.join(dir, entry));
+    } catch {
+      return [];
+    }
+  });
   if (!apps.length) return null;
-  const running = apps.length > 1 ? spawnSync(PS, ["-axo", "comm="], { encoding: "utf8", maxBuffer: 16 << 20 }).stdout || "" : "";
-  const app = apps.find((candidate) => running.includes(`${candidate}/Contents/MacOS/`)) ?? apps.find((candidate) => t3OpensLinks(candidate)) ?? apps[0];
+  const running =
+    apps.length > 1
+      ? spawnSync(PS, ["-axo", "comm="], {
+          encoding: "utf8",
+          maxBuffer: 16 << 20,
+        }).stdout || ""
+      : "";
+  const app =
+    apps.find((candidate) =>
+      running.includes(`${candidate}/Contents/MacOS/`)
+    ) ??
+    apps.find((candidate) => t3OpensLinks(candidate)) ??
+    apps[0];
   return { name: path.basename(app, ".app"), app };
 }
 
 // ── A place ───────────────────────────────────────────────────────────────────
 
-const TERMINAL_NAMES = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTerm: "WezTerm", ghostty: "Ghostty", WarpTerminal: "Warp", Hyper: "Hyper", kitty: "kitty", alacritty: "Alacritty" };
+const TERMINAL_NAMES = {
+  Apple_Terminal: "Terminal",
+  "iTerm.app": "iTerm",
+  WezTerm: "WezTerm",
+  ghostty: "Ghostty",
+  WarpTerminal: "Warp",
+  Hyper: "Hyper",
+  kitty: "kitty",
+  alacritty: "Alacritty",
+};
 
 /**
  * Where a session runs, from its environment and the app found up its process tree (`host`, live.mjs hostApp):
@@ -376,32 +773,83 @@ const TERMINAL_NAMES = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTe
  *   app       any other app.
  * The environment comes first: the app a process sits under can be a different one (a terminal started from an editor).
  */
-export function placeFrom({ env = {}, host = null, tty = null, folder = null }) {
+export function placeFrom({
+  env = {},
+  host = null,
+  tty = null,
+  folder = null,
+}) {
   const bundle = env.__CFBundleIdentifier || null;
   const hostName = host?.name ?? "";
-  const editorOf = () => EDITORS.find((editor) => editor.bundle === bundle) ?? EDITORS.find((editor) => editor.match.test(env.VSCODE_GIT_ASKPASS_NODE || ""))
-    ?? (env.TERM_PROGRAM === "vscode" || env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode" ? editorById("vscode") : null);
+  const editorOf = () =>
+    EDITORS.find((editor) => editor.bundle === bundle) ??
+    EDITORS.find((editor) =>
+      editor.match.test(env.VSCODE_GIT_ASKPASS_NODE || "")
+    ) ??
+    (env.TERM_PROGRAM === "vscode" ||
+    env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode"
+      ? editorById("vscode")
+      : null);
   const editorPlace = (editor) => {
-    const install = editorInstall(editor.id, env.VSCODE_GIT_ASKPASS_NODE || host?.app || "");
-    const panel = env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode" || env.TERM_PROGRAM !== "vscode";
-    return { kind: "editor", editor: editor.id, name: editor.name, app: install?.app ?? host?.app ?? null, cli: install?.cli ?? null, surface: panel ? "panel" : "terminal", folder };
+    const install = editorInstall(
+      editor.id,
+      env.VSCODE_GIT_ASKPASS_NODE || host?.app || ""
+    );
+    const panel =
+      env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode" ||
+      env.TERM_PROGRAM !== "vscode";
+    return {
+      kind: "editor",
+      editor: editor.id,
+      name: editor.name,
+      app: install?.app ?? host?.app ?? null,
+      cli: install?.cli ?? null,
+      surface: panel ? "panel" : "terminal",
+      folder,
+    };
   };
-  if (env.T3CODE_CLI_PATH || bundle === T3_BUNDLE) return { kind: "t3", name: "T3 Code", folder };
+  if (env.T3CODE_CLI_PATH || bundle === T3_BUNDLE)
+    return { kind: "t3", name: "T3 Code", folder };
   const editor = editorOf();
   if (editor) return editorPlace(editor);
-  const ids = { tty,
+  const ids = {
+    tty,
     tmux: env.TMUX && /^%\d+$/.test(env.TMUX_PANE || "") ? env.TMUX_PANE : null,
     wezterm: /^\d+$/.test(env.WEZTERM_PANE || "") ? env.WEZTERM_PANE : null,
-    kitty: /^\d+$/.test(env.KITTY_WINDOW_ID || "") ? { id: env.KITTY_WINDOW_ID, socket: env.KITTY_LISTEN_ON || null } : null };
-  if (env.TERM_PROGRAM && env.TERM_PROGRAM !== "vscode") return { kind: "terminal", name: hostName || TERMINAL_NAMES[env.TERM_PROGRAM] || env.TERM_PROGRAM, app: host?.app ?? null, ...ids, folder };
+    kitty: /^\d+$/.test(env.KITTY_WINDOW_ID || "")
+      ? { id: env.KITTY_WINDOW_ID, socket: env.KITTY_LISTEN_ON || null }
+      : null,
+  };
+  if (env.TERM_PROGRAM && env.TERM_PROGRAM !== "vscode")
+    return {
+      kind: "terminal",
+      name: hostName || TERMINAL_NAMES[env.TERM_PROGRAM] || env.TERM_PROGRAM,
+      app: host?.app ?? null,
+      ...ids,
+      folder,
+    };
   // Nothing in its environment says: the app it runs under.
-  if (/^T3 Code\b/.test(hostName)) return { kind: "t3", name: "T3 Code", folder };
+  if (/^T3 Code\b/.test(hostName))
+    return { kind: "t3", name: "T3 Code", folder };
   const hosted = EDITORS.find((entry) => entry.name === hostName);
   if (hosted) return editorPlace(hosted);
-  if (hostName === "Codex") return { kind: "codex-app", name: "Codex", app: host.app, folder };
-  if (tty || ids.tmux || ids.wezterm || ids.kitty) return { kind: "terminal", name: hostName || "Terminal", app: host?.app ?? null, ...ids, folder };
+  if (hostName === "Codex")
+    return { kind: "codex-app", name: "Codex", app: host.app, folder };
+  if (tty || ids.tmux || ids.wezterm || ids.kitty)
+    return {
+      kind: "terminal",
+      name: hostName || "Terminal",
+      app: host?.app ?? null,
+      ...ids,
+      folder,
+    };
   return host ? { kind: "app", name: hostName, app: host.app, folder } : null;
 }
 
 /** One key per place the person uses an agent in: both T3 builds are T3; an editor's terminal and its panel differ. */
-export const placeKey = (place) => (place.kind === "editor" ? `editor:${place.editor}:${place.surface}` : place.kind === "t3" ? "t3" : `${place.kind}:${place.name}`);
+export const placeKey = (place) =>
+  place.kind === "editor"
+    ? `editor:${place.editor}:${place.surface}`
+    : place.kind === "t3"
+      ? "t3"
+      : `${place.kind}:${place.name}`;