@phenx-inc/ctlsurf 0.16.1 → 0.17.1

package/out/headless/index.mjs

@@ -6386,15 +6386,15 @@ function redactSensitive(body) {
   }
   return null;
 }
-async function checkCredentialsFileSafety(path12, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
+async function checkCredentialsFileSafety(path13, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
   if (typeof process === "undefined" || process.platform === "win32")
     return;
-  const fs8 = await import("node:fs");
-  let resolved = path12;
+  const fs9 = await import("node:fs");
+  let resolved = path13;
   let st;
   try {
-    resolved = await fs8.promises.realpath(path12);
-    st = await fs8.promises.stat(resolved);
+    resolved = await fs9.promises.realpath(path13);
+    st = await fs9.promises.stat(resolved);
   } catch {
     return;
   }
@@ -6410,27 +6410,27 @@ async function checkCredentialsFileSafety(path12, onWarn = (m) => console.warn(`
   }
 }
 async function writeCredentialsFileAtomic(targetPath, data) {
-  const fs8 = await import("node:fs");
-  const path12 = await import("node:path");
-  const dir = path12.dirname(targetPath);
-  await fs8.promises.mkdir(dir, { recursive: true, mode: 448 });
+  const fs9 = await import("node:fs");
+  const path13 = await import("node:path");
+  const dir = path13.dirname(targetPath);
+  await fs9.promises.mkdir(dir, { recursive: true, mode: 448 });
   const tmpPath = `${targetPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    const fh = await fs8.promises.open(tmpPath, "w", 384);
+    const fh = await fs9.promises.open(tmpPath, "w", 384);
     try {
       await fh.writeFile(JSON.stringify(data, null, 2));
       await fh.sync();
     } finally {
       await fh.close();
     }
-    await fs8.promises.rename(tmpPath, targetPath);
+    await fs9.promises.rename(tmpPath, targetPath);
   } catch (err) {
-    await fs8.promises.unlink(tmpPath).catch(() => {
+    await fs9.promises.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
   try {
-    const dirFh = await fs8.promises.open(dir, "r");
+    const dirFh = await fs9.promises.open(dir, "r");
     try {
       await dirFh.sync();
     } finally {
@@ -6794,12 +6794,12 @@ var init_credentials = __esm({
         return null;
       }
       validateProfileName(profileName);
-      const fs8 = await import("node:fs");
-      const path12 = await import("node:path");
-      const configPath = path12.join(rootConfigPath, "configs", `${profileName}.json`);
+      const fs9 = await import("node:fs");
+      const path13 = await import("node:path");
+      const configPath = path13.join(rootConfigPath, "configs", `${profileName}.json`);
       let configRaw;
       try {
-        configRaw = await fs8.promises.readFile(configPath, "utf-8");
+        configRaw = await fs9.promises.readFile(configPath, "utf-8");
       } catch (err) {
         if (err?.code !== "ENOENT") {
           throw new Error(`failed to read config file ${configPath}: ${err}`);
@@ -6880,37 +6880,37 @@ var init_credentials = __esm({
         return null;
       }
       validateProfileName(profileName);
-      const path12 = await import("node:path");
-      return path12.join(rootConfigPath, "credentials", `${profileName}.json`);
+      const path13 = await import("node:path");
+      return path13.join(rootConfigPath, "credentials", `${profileName}.json`);
     };
     getRootConfigPath = async () => {
       if (!supportsLocalConfigFiles()) {
         return null;
       }
-      const path12 = await import("node:path");
+      const path13 = await import("node:path");
       const configDir = readEnv("ANTHROPIC_CONFIG_DIR");
       if (configDir) {
         return configDir;
       }
-      const os6 = getPlatformHeaders()["X-Stainless-OS"];
-      if (os6 === "Windows") {
+      const os7 = getPlatformHeaders()["X-Stainless-OS"];
+      if (os7 === "Windows") {
         const appData = readEnv("APPDATA");
         if (appData) {
-          return path12.join(appData, "Anthropic");
+          return path13.join(appData, "Anthropic");
         }
         const userProfile = readEnv("USERPROFILE");
         if (userProfile) {
-          return path12.join(userProfile, "AppData", "Roaming", "Anthropic");
+          return path13.join(userProfile, "AppData", "Roaming", "Anthropic");
         }
         return null;
       }
       const xdgConfigHome = readEnv("XDG_CONFIG_HOME");
       if (xdgConfigHome) {
-        return path12.join(xdgConfigHome, "anthropic");
+        return path13.join(xdgConfigHome, "anthropic");
       }
       const home = readEnv("HOME");
       if (home) {
-        return path12.join(home, ".config", "anthropic");
+        return path13.join(home, ".config", "anthropic");
       }
       return null;
     };
@@ -6927,11 +6927,11 @@ var init_credentials = __esm({
       if (profileName) {
         return profileName;
       }
-      const fs8 = await import("node:fs");
-      const path12 = await import("node:path");
-      const filePath = path12.join(rootConfigPath, "active_config");
+      const fs9 = await import("node:fs");
+      const path13 = await import("node:path");
+      const filePath = path13.join(rootConfigPath, "active_config");
       try {
-        return (await fs8.promises.readFile(filePath, "utf-8")).trim() || "default";
+        return (await fs9.promises.readFile(filePath, "utf-8")).trim() || "default";
       } catch (err) {
         if (err?.code !== "ENOENT") {
           throw new Error(`failed to read ${filePath}: ${err}`);
@@ -6943,21 +6943,21 @@ var init_credentials = __esm({
 });
 
 // node_modules/@anthropic-ai/sdk/lib/credentials/identity-token.mjs
-function identityTokenFromFile(path12) {
-  if (!path12) {
+function identityTokenFromFile(path13) {
+  if (!path13) {
     throw new AnthropicError("Identity token file path is empty");
   }
   return async () => {
-    const fs8 = await import("node:fs");
+    const fs9 = await import("node:fs");
     let content;
     try {
-      content = await fs8.promises.readFile(path12, "utf-8");
+      content = await fs9.promises.readFile(path13, "utf-8");
     } catch (err) {
-      throw new AnthropicError(`Failed to read identity token file at ${path12}: ${err}`);
+      throw new AnthropicError(`Failed to read identity token file at ${path13}: ${err}`);
     }
     const token = content.trim();
     if (!token) {
-      throw new AnthropicError(`Identity token file at ${path12} is empty`);
+      throw new AnthropicError(`Identity token file at ${path13} is empty`);
     }
     return token;
   };
@@ -7042,11 +7042,11 @@ var init_oidc_federation = __esm({
 // node_modules/@anthropic-ai/sdk/lib/credentials/user-oauth.mjs
 function userOAuthProvider(config) {
   return async (opts) => {
-    const fs8 = await import("node:fs");
+    const fs9 = await import("node:fs");
     await checkCredentialsFileSafety(config.credentialsPath, config.onSafetyWarning);
     let raw;
     try {
-      raw = await fs8.promises.readFile(config.credentialsPath, "utf-8");
+      raw = await fs9.promises.readFile(config.credentialsPath, "utf-8");
     } catch (err) {
       throw new WorkloadIdentityError(`Credentials file not found at ${config.credentialsPath}: ${err}`);
     }
@@ -7218,11 +7218,11 @@ function resolveIdentityTokenProvider(auth) {
 }
 function cachedExchangeProvider(exchange, credentialsPath, onCacheWriteError, onSafetyWarning) {
   return async (opts) => {
-    const fs8 = await import("node:fs");
+    const fs9 = await import("node:fs");
     await checkCredentialsFileSafety(credentialsPath, onSafetyWarning);
     let existing;
     try {
-      const raw = await fs8.promises.readFile(credentialsPath, "utf-8");
+      const raw = await fs9.promises.readFile(credentialsPath, "utf-8");
       existing = JSON.parse(raw);
       const token = existing?.["access_token"];
       if (token && !opts?.forceRefresh) {
@@ -8282,12 +8282,12 @@ var init_path = __esm({
   "node_modules/@anthropic-ai/sdk/internal/utils/path.mjs"() {
     init_error();
     EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-    createPathTagFunction = (pathEncoder = encodeURIPath) => function path12(statics, ...params) {
+    createPathTagFunction = (pathEncoder = encodeURIPath) => function path13(statics, ...params) {
       if (statics.length === 1)
         return statics[0];
       let postPath = false;
       const invalidSegments = [];
-      const path13 = statics.reduce((previousValue, currentValue, index) => {
+      const path14 = statics.reduce((previousValue, currentValue, index) => {
         if (/[?#]/.test(currentValue)) {
           postPath = true;
         }
@@ -8304,7 +8304,7 @@ var init_path = __esm({
         }
         return previousValue + currentValue + (index === params.length ? "" : encoded);
       }, "");
-      const pathOnly = path13.split(/[?#]/, 1)[0];
+      const pathOnly = path14.split(/[?#]/, 1)[0];
       const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
       let match;
       while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -8325,10 +8325,10 @@ var init_path = __esm({
         }, "");
         throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path13}
+${path14}
 ${underline}`);
       }
-      return path13;
+      return path14;
     };
     path5 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
   }
@@ -9706,15 +9706,15 @@ var require_dist = __commonJS({
         return `v1,${expectedSignature}`;
       }
       verifyTimestamp(timestampHeader) {
-        const now = Math.floor(Date.now() / 1e3);
+        const now2 = Math.floor(Date.now() / 1e3);
         const timestamp = parseInt(timestampHeader, 10);
         if (isNaN(timestamp)) {
           throw new WebhookVerificationError("Invalid Signature Headers");
         }
-        if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
+        if (now2 - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
           throw new WebhookVerificationError("Message timestamp too old");
         }
-        if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
+        if (timestamp > now2 + WEBHOOK_TOLERANCE_IN_SECONDS) {
           throw new WebhookVerificationError("Message timestamp too new");
         }
         return new Date(timestamp * 1e3);
@@ -16818,9 +16818,9 @@ var init_client = __esm({
       makeStatusError(status, error, message, headers) {
         return APIError.generate(status, error, message, headers);
       }
-      buildURL(path12, query, defaultBaseURL) {
+      buildURL(path13, query, defaultBaseURL) {
         const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-        const url = isAbsoluteURL(path12) ? new URL(path12) : new URL(baseURL + (baseURL.endsWith("/") && path12.startsWith("/") ? path12.slice(1) : path12));
+        const url = isAbsoluteURL(path13) ? new URL(path13) : new URL(baseURL + (baseURL.endsWith("/") && path13.startsWith("/") ? path13.slice(1) : path13));
         const defaultQuery = this.defaultQuery();
         const pathQuery = Object.fromEntries(url.searchParams);
         if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
@@ -16892,24 +16892,24 @@ var init_client = __esm({
       backendMiddleware() {
         return [];
       }
-      get(path12, opts) {
-        return this.methodRequest("get", path12, opts);
+      get(path13, opts) {
+        return this.methodRequest("get", path13, opts);
       }
-      post(path12, opts) {
-        return this.methodRequest("post", path12, opts);
+      post(path13, opts) {
+        return this.methodRequest("post", path13, opts);
       }
-      patch(path12, opts) {
-        return this.methodRequest("patch", path12, opts);
+      patch(path13, opts) {
+        return this.methodRequest("patch", path13, opts);
       }
-      put(path12, opts) {
-        return this.methodRequest("put", path12, opts);
+      put(path13, opts) {
+        return this.methodRequest("put", path13, opts);
       }
-      delete(path12, opts) {
-        return this.methodRequest("delete", path12, opts);
+      delete(path13, opts) {
+        return this.methodRequest("delete", path13, opts);
       }
-      methodRequest(method, path12, opts) {
+      methodRequest(method, path13, opts) {
         return this.request(Promise.resolve(opts).then((opts2) => {
-          return { method, path: path12, ...opts2 };
+          return { method, path: path13, ...opts2 };
         }));
       }
       request(options, remainingRetries = null) {
@@ -17023,8 +17023,8 @@ var init_client = __esm({
         }));
         return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
       }
-      getAPIList(path12, Page2, opts) {
-        return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path12, ...opts2 })) : { method: "get", path: path12, ...opts });
+      getAPIList(path13, Page2, opts) {
+        return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path13, ...opts2 })) : { method: "get", path: path13, ...opts });
       }
       requestAPIList(Page2, options) {
         const request = this.makeRequest(options, null, void 0);
@@ -17140,14 +17140,14 @@ var init_client = __esm({
       }
       async buildRequest(inputOptions, { retryCount = 0 } = {}) {
         const options = { ...inputOptions };
-        const { method, path: path12, query, defaultBaseURL } = options;
+        const { method, path: path13, query, defaultBaseURL } = options;
         if (this._authState.resolution) {
           await this._authState.resolution;
         }
         if (!this._baseURLIsExplicit && this._authState.baseURL && this.baseURL !== this._authState.baseURL) {
           this.baseURL = this._authState.baseURL;
         }
-        const url = this.buildURL(path12, query, defaultBaseURL);
+        const url = this.buildURL(path13, query, defaultBaseURL);
         if ("timeout" in options)
           validatePositiveInteger("timeout", options.timeout);
         options.timeout = options.timeout ?? this.timeout;
@@ -17288,19 +17288,19 @@ var init_sdk = __esm({
 // node_modules/electron/index.js
 var require_electron = __commonJS({
   "node_modules/electron/index.js"(exports, module) {
-    var fs8 = __require("fs");
-    var path12 = __require("path");
-    var pathFile = path12.join(__dirname, "path.txt");
+    var fs9 = __require("fs");
+    var path13 = __require("path");
+    var pathFile = path13.join(__dirname, "path.txt");
     function getElectronPath() {
       let executablePath;
-      if (fs8.existsSync(pathFile)) {
-        executablePath = fs8.readFileSync(pathFile, "utf-8");
+      if (fs9.existsSync(pathFile)) {
+        executablePath = fs9.readFileSync(pathFile, "utf-8");
       }
       if (process.env.ELECTRON_OVERRIDE_DIST_PATH) {
-        return path12.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
+        return path13.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
       }
       if (executablePath) {
-        return path12.join(__dirname, "dist", executablePath);
+        return path13.join(__dirname, "dist", executablePath);
       } else {
         throw new Error("Electron failed to install correctly, please delete node_modules/electron and try installing again");
       }
@@ -17314,7 +17314,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.16.1",
+      version: "0.17.1",
       description: "Agent-agnostic terminal and desktop app for ctlsurf \u2014 run Claude Code, Codex, or any coding agent with live session logging and remote control",
       main: "out/main/index.js",
       bin: {
@@ -17452,6 +17452,10 @@ var PtyManager = class {
       this.process = null;
     });
   }
+  /** OS pid of the spawned agent (or ssh), null once it has exited. */
+  get pid() {
+    return this.process?.pid ?? null;
+  }
   write(data) {
     this.process?.write(data);
   }
@@ -17564,8 +17568,8 @@ var CtlsurfApi = class {
     }
     return h;
   }
-  async request(method, path12, body) {
-    const url = `${this.baseUrl}${path12}`;
+  async request(method, path13, body) {
+    const url = `${this.baseUrl}${path13}`;
     const opts = {
       method,
       headers: this.headers()
@@ -17576,7 +17580,7 @@ var CtlsurfApi = class {
     const res = await fetch(url, opts);
     if (!res.ok) {
       const text = await res.text();
-      throw new Error(`ctlsurf API ${method} ${path12}: ${res.status} ${text}`);
+      throw new Error(`ctlsurf API ${method} ${path13}: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -17747,16 +17751,16 @@ var ConversationBridge = class {
     this.outputFlushTimer = null;
     if (this.outputBuffer.length === 0) return;
     const candidate = this.terminalCapture.currentCandidate();
-    const now = Date.now();
+    const now2 = Date.now();
     if (candidate.length === 0) {
       this.outputBuffer = "";
       return;
     }
     if (candidate !== this.pendingCandidate) {
       this.pendingCandidate = candidate;
-      this.pendingCandidateChangedAt = now;
+      this.pendingCandidateChangedAt = now2;
     }
-    if (now - this.pendingCandidateChangedAt >= OUTPUT_STABLE_MS) {
+    if (now2 - this.pendingCandidateChangedAt >= OUTPUT_STABLE_MS) {
       this.flush();
       return;
     }
@@ -18271,8 +18275,8 @@ function mostRecentClaudeFile(cwd, root) {
 }
 function recentCodexRollouts(root) {
   const dirs = /* @__PURE__ */ new Set();
-  const now = Date.now();
-  for (const ms of [now, now - 24 * 60 * 60 * 1e3]) {
+  const now2 = Date.now();
+  for (const ms of [now2, now2 - 24 * 60 * 60 * 1e3]) {
     const d = new Date(ms);
     const yyyy = String(d.getFullYear());
     const mm = String(d.getMonth() + 1).padStart(2, "0");
@@ -18386,9 +18390,9 @@ var AgentStateMonitor = class {
   tabs = /* @__PURE__ */ new Map();
   timer = null;
   lastAnyAwaiting = false;
-  constructor(sink, now = Date.now) {
+  constructor(sink, now2 = Date.now) {
     this.sink = sink;
-    this.now = now;
+    this.now = now2;
   }
   start() {
     if (this.timer) return;
@@ -18404,14 +18408,14 @@ var AgentStateMonitor = class {
   }
   /** Register a tab so its raw PTY output can be classified. */
   trackTab(tabId, agentId, cwd) {
-    const now = this.now();
+    const now2 = this.now();
     this.tabs.set(tabId, {
       agentId,
       cwd,
       state: "idle",
       everBusy: false,
       lastBusyAt: 0,
-      lastOutputAt: now,
+      lastOutputAt: now2,
       lastDecisionAt: 0,
       hookState: null,
       hookAt: 0,
@@ -18425,16 +18429,16 @@ var AgentStateMonitor = class {
   feed(tabId, data) {
     const rec = this.tabs.get(tabId);
     if (!rec) return;
-    const now = this.now();
-    rec.lastOutputAt = now;
+    const now2 = this.now();
+    rec.lastOutputAt = now2;
     const text = rec.tail + stripAnsi2(data);
     rec.tail = text.length > TAIL_KEEP_CHARS ? text.slice(-TAIL_KEEP_CHARS) : text;
     if (hasBusyMarker(text)) {
-      rec.lastBusyAt = now;
+      rec.lastBusyAt = now2;
       rec.everBusy = true;
     }
     if (hasApprovalMarker(text)) {
-      rec.lastDecisionAt = now;
+      rec.lastDecisionAt = now2;
     }
   }
   /**
@@ -18451,9 +18455,9 @@ var AgentStateMonitor = class {
     if (!/[\r\n]/.test(data)) return;
     const rec = this.tabs.get(tabId);
     if (!rec) return;
-    const now = this.now();
+    const now2 = this.now();
     rec.everBusy = false;
-    rec.lastBusyAt = now;
+    rec.lastBusyAt = now2;
     rec.lastDecisionAt = 0;
     rec.hookState = null;
     this.setState(rec, tabId, "busy");
@@ -18467,28 +18471,28 @@ var AgentStateMonitor = class {
    */
   applyHookEvent(cwd, kind) {
     const target = stripTrailingSep2(cwd);
-    const now = this.now();
+    const now2 = this.now();
     for (const [tabId, rec] of this.tabs) {
       if (stripTrailingSep2(rec.cwd) !== target) continue;
       rec.hookState = kind;
-      rec.hookAt = now;
+      rec.hookAt = now2;
       if (kind === "busy") {
         rec.everBusy = false;
-        rec.lastBusyAt = now;
+        rec.lastBusyAt = now2;
       }
       this.setState(rec, tabId, kind);
     }
   }
   tick() {
-    const now = this.now();
+    const now2 = this.now();
     for (const [tabId, rec] of this.tabs) {
-      if (rec.hookState && now - rec.hookAt < HOOK_AUTHORITY_MS) {
+      if (rec.hookState && now2 - rec.hookAt < HOOK_AUTHORITY_MS) {
         this.setState(rec, tabId, rec.hookState);
         continue;
       }
-      const busyRecently = rec.lastBusyAt > 0 && now - rec.lastBusyAt < BUSY_GRACE_MS;
-      const settled = now - rec.lastOutputAt >= SETTLE_MS;
-      const decisionRecent = rec.lastDecisionAt > 0 && now - rec.lastDecisionAt < DECISION_TTL_MS;
+      const busyRecently = rec.lastBusyAt > 0 && now2 - rec.lastBusyAt < BUSY_GRACE_MS;
+      const settled = now2 - rec.lastOutputAt >= SETTLE_MS;
+      const decisionRecent = rec.lastDecisionAt > 0 && now2 - rec.lastDecisionAt < DECISION_TTL_MS;
       let next = null;
       if (busyRecently) {
         next = "busy";
@@ -18909,16 +18913,16 @@ var TimeTracker = class {
   recordActivity(tabId) {
     const s = this.sessions.get(tabId);
     if (!s || s.ended) return;
-    const now = Date.now();
-    if (!isSameLocalDay(s.startedAt, now)) {
+    const now2 = Date.now();
+    if (!isSameLocalDay(s.startedAt, now2)) {
       void this.rollover(tabId);
       return;
     }
-    const delta = now - s.lastActivity;
+    const delta = now2 - s.lastActivity;
     if (delta < s.idleTimeoutMs) {
       s.activeMs += delta;
     }
-    s.lastActivity = now;
+    s.lastActivity = now2;
   }
   async rollover(tabId) {
     if (this.rollingOver.has(tabId)) return;
@@ -19562,10 +19566,10 @@ var SpanTracker = class {
   lastAccountAt = 0;
   activityMs = { agent: 0, human: 0, idle: 0 };
   started = false;
-  constructor(session, sink, now = Date.now) {
+  constructor(session, sink, now2 = Date.now) {
     this.session = session;
     this.sink = sink;
-    this.now = now;
+    this.now = now2;
   }
   /** Begin attribution at session start. */
   begin() {
@@ -20020,10 +20024,10 @@ var ObserverBudget = class {
   capUsd;
   date;
   spentUsd = 0;
-  constructor(dir, capUsd, now = () => /* @__PURE__ */ new Date()) {
+  constructor(dir, capUsd, now2 = () => /* @__PURE__ */ new Date()) {
     this.filePath = path4.join(dir, "budget.json");
     this.capUsd = capUsd;
-    this.date = localDay(now());
+    this.date = localDay(now2());
     try {
       const raw = JSON.parse(fs3.readFileSync(this.filePath, "utf-8"));
       if (raw?.date === this.date && typeof raw.spentUsd === "number") {
@@ -20032,8 +20036,8 @@ var ObserverBudget = class {
     } catch {
     }
   }
-  addUsage(model, usage, now = () => /* @__PURE__ */ new Date()) {
-    const today = localDay(now());
+  addUsage(model, usage, now2 = () => /* @__PURE__ */ new Date()) {
+    const today = localDay(now2());
     if (today !== this.date) {
       this.date = today;
       this.spentUsd = 0;
@@ -20045,8 +20049,8 @@ var ObserverBudget = class {
     } catch {
     }
   }
-  overCap(now = () => /* @__PURE__ */ new Date()) {
-    if (localDay(now()) !== this.date) return false;
+  overCap(now2 = () => /* @__PURE__ */ new Date()) {
+    if (localDay(now2()) !== this.date) return false;
     return this.spentUsd >= this.capUsd;
   }
   get spent() {
@@ -21234,6 +21238,15 @@ var Orchestrator = class {
   getTabIds() {
     return [...this.tabs.keys()];
   }
+  // Every open tab's agent and PTY pid, for the resource monitor (monitor.ts).
+  getTabProcesses() {
+    return [...this.tabs].map(([tabId, tab]) => ({
+      tabId,
+      agent: tab.agent,
+      pid: tab.ptyManager.pid,
+      active: tabId === this.activeTabId
+    }));
+  }
   // ─── Tracking control (active tab) ──────────────
   isActiveTabTracking() {
     if (!this.activeTabId) return false;
@@ -21439,6 +21452,7 @@ var FG_TITLE = `${CSI}38;2;192;202;245m`;
 var BG_MODAL = `${CSI}48;2;31;35;53m`;
 var BG_SELECTED = `${CSI}48;2;42;43;61m`;
 var RESET = `${CSI}0m`;
+var TITLE_QUIET_MS = 50;
 var Tui = class {
   rows = 0;
   cols = 0;
@@ -21447,8 +21461,13 @@ var Tui = class {
     cwd: "",
     wsStatus: "disconnected",
     workerId: null,
-    mode: "terminal"
+    mode: "terminal",
+    resources: ""
   };
+  lastPtyWrite = 0;
+  pendingTitle = null;
+  lastTitle = "";
+  titleTimer = null;
   constructor() {
     this.rows = process.stdout.rows || 24;
     this.cols = process.stdout.columns || 80;
@@ -21464,6 +21483,8 @@ var Tui = class {
    * Restore terminal to normal state
    */
   destroy() {
+    if (this.titleTimer) clearTimeout(this.titleTimer);
+    this.titleTimer = null;
     this.write(`${CSI}?25h`);
   }
   /**
@@ -21493,19 +21514,35 @@ var Tui = class {
    * Write PTY output — full passthrough.
    */
   writePtyData(data) {
+    this.lastPtyWrite = Date.now();
     this.write(data);
   }
   /**
    * Update the terminal window/tab title via OSC escape sequence.
    */
   setTerminalTitle(title) {
-    this.write(`${ESC}]0;${title}\x07`);
+    this.pendingTitle = title;
+    this.flushTitle();
+  }
+  flushTitle() {
+    if (this.pendingTitle === null || this.titleTimer) return;
+    const wait = TITLE_QUIET_MS - (Date.now() - this.lastPtyWrite);
+    if (wait > 0) {
+      this.titleTimer = setTimeout(() => {
+        this.titleTimer = null;
+        this.flushTitle();
+      }, wait);
+      return;
+    }
+    if (this.pendingTitle !== this.lastTitle) this.write(`${ESC}]0;${this.pendingTitle}\x07`);
+    this.lastTitle = this.pendingTitle;
+    this.pendingTitle = null;
   }
   /**
    * Build a title string from current state for the terminal tab.
    */
   updateTerminalTitle() {
-    const { agentName, wsStatus, cwd } = this.state;
+    const { agentName, wsStatus, cwd, resources } = this.state;
     const displayCwd = this.shortenPath(cwd);
     const statusIcon = {
       connected: "\u25CF",
@@ -21521,7 +21558,9 @@ var Tui = class {
       pending_approval: "Pending",
       no_project: "No Project"
     }[wsStatus] || wsStatus;
-    this.setTerminalTitle(`ctlsurf \xB7 ${agentName} \xB7 ${statusIcon} ${statusLabel} \xB7 ${displayCwd}`);
+    this.setTerminalTitle(
+      `ctlsurf \xB7 ${agentName} \xB7 ${statusIcon} ${statusLabel} \xB7 ${displayCwd}` + (resources ? ` \xB7 ${resources}` : "")
+    );
   }
   /**
    * Show an interactive agent picker modal.
@@ -21696,6 +21735,392 @@ var Tui = class {
   }
 };
 
+// src/main/monitor.ts
+import { execFile as execFile2 } from "child_process";
+import fs8 from "fs";
+import os6 from "os";
+import path12 from "path";
+var FAST_MS = 3e3;
+var SLOW_MS = 1e4;
+var IDLE_STOP_MS = 12e4;
+var HISTORY_MS = 6e5;
+var FAST_HOLD_MS = 15e3;
+var USAGE_SLOW_MS = 3e5;
+var USAGE_FAST_MS = 6e4;
+var CODEX_TAIL_BYTES = 512 * 1024;
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function round(x, digits = 1) {
+  const f = 10 ** digits;
+  return Math.round(x * f) / f;
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve4, reject) => {
+    execFile2(cmd, args, { timeout: opts.timeout ?? 5e3, cwd: opts.cwd, maxBuffer: 16 * 1024 * 1024 }, (err, stdout) => {
+      if (err && !stdout) reject(err);
+      else resolve4(stdout);
+    });
+  });
+}
+function serviceFor(agent) {
+  const cmd = isRemoteAgent(agent) ? agent.args.slice(2).join(" ") : path12.basename(agent.command);
+  if (/\bcodex\b/.test(cmd)) return "codex";
+  if (/\bclaude\b/.test(cmd)) return "claude";
+  return null;
+}
+function cpuTimes() {
+  let idle = 0;
+  let total = 0;
+  for (const c of os6.cpus()) {
+    const t = c.times;
+    idle += t.idle;
+    total += t.user + t.nice + t.sys + t.idle + t.irq;
+  }
+  return { idle, total };
+}
+async function memory() {
+  const total = os6.totalmem();
+  let avail = os6.freemem();
+  try {
+    if (process.platform === "darwin") {
+      const out = await run("vm_stat", []);
+      const page = Number(/page size of (\d+) bytes/.exec(out)?.[1]) || 4096;
+      const pages = (name) => Number(new RegExp(`Pages ${name}:\\s+(\\d+)`).exec(out)?.[1] ?? 0);
+      avail = (pages("free") + pages("inactive") + pages("speculative")) * page;
+    } else if (process.platform === "linux") {
+      const m = /MemAvailable:\s+(\d+) kB/.exec(await fs8.promises.readFile("/proc/meminfo", "utf-8"));
+      if (m) avail = Number(m[1]) * 1024;
+    }
+  } catch {
+  }
+  avail = Math.min(avail, total);
+  return { total, used: total - avail, pct: round(100 * (total - avail) / total) };
+}
+async function diskUsage() {
+  if (typeof fs8.promises.statfs !== "function") return null;
+  try {
+    const s = await fs8.promises.statfs(os6.homedir());
+    return { total: s.blocks * s.bsize, free: s.bavail * s.bsize };
+  } catch {
+    return null;
+  }
+}
+async function appleGpu() {
+  if (process.platform !== "darwin") return null;
+  try {
+    const out = await run("ioreg", ["-r", "-d", "1", "-w", "0", "-c", "IOAccelerator"], { timeout: 3e3 });
+    const m = /"Device Utilization %"=(\d+)/.exec(out);
+    return m ? Number(m[1]) : null;
+  } catch {
+    return null;
+  }
+}
+async function processTable() {
+  const table = /* @__PURE__ */ new Map();
+  if (process.platform === "win32") return table;
+  try {
+    const out = await run("ps", ["-A", "-o", "pid=,ppid=,pcpu=,rss="]);
+    for (const line of out.split("\n")) {
+      const [pid, ppid, cpu, rss] = line.trim().split(/\s+/).map(Number);
+      if (pid) table.set(pid, { ppid, cpu: cpu || 0, rss: (rss || 0) * 1024 });
+    }
+  } catch {
+  }
+  return table;
+}
+function agentProcess(tab, table) {
+  const base = {
+    tabId: tab.tabId,
+    name: tab.agent.name,
+    active: tab.active,
+    remote: isRemoteAgent(tab.agent),
+    service: serviceFor(tab.agent),
+    pid: tab.pid
+  };
+  if (tab.pid == null || !table.has(tab.pid)) return { ...base, cpu: null, mem: null, procs: 0 };
+  const children = /* @__PURE__ */ new Map();
+  for (const [pid, row] of table) {
+    const list = children.get(row.ppid);
+    if (list) list.push(pid);
+    else children.set(row.ppid, [pid]);
+  }
+  let cpu = 0;
+  let mem = 0;
+  let procs = 0;
+  const queue = [tab.pid];
+  while (queue.length) {
+    const pid = queue.pop();
+    const row = table.get(pid);
+    if (!row) continue;
+    cpu += row.cpu;
+    mem += row.rss;
+    procs++;
+    queue.push(...children.get(pid) ?? []);
+  }
+  return { ...base, cpu: round(cpu), mem, procs };
+}
+function parseClaudeUsage(text) {
+  const windows = [];
+  for (const line of text.split("\n")) {
+    let m = /^\s*Current session:\s*([\d.]+)% used(?:\s*·\s*resets (.+))?/.exec(line);
+    if (m) {
+      windows.push({ label: "session (5h)", short: "5h", pct: Number(m[1]), resets: m[2]?.trim() || null });
+      continue;
+    }
+    m = /^\s*Current week \((.+?)\):\s*([\d.]+)% used(?:\s*·\s*resets (.+))?/.exec(line);
+    if (m) {
+      const all = m[1].trim().toLowerCase() === "all models";
+      windows.push({
+        label: all ? "week, all models" : `week, ${m[1].trim()}`,
+        short: all ? "wk" : null,
+        pct: Number(m[2]),
+        resets: m[3]?.trim() || null
+      });
+    }
+  }
+  return windows;
+}
+async function claudeUsage() {
+  const source = "claude /usage";
+  let text = "";
+  try {
+    const out = await run(
+      "claude",
+      ["-p", "/usage", "--output-format", "json", "--no-session-persistence"],
+      { cwd: os6.tmpdir(), timeout: 4e4 }
+    );
+    text = String(JSON.parse(out || "{}").result ?? "");
+  } catch (err) {
+    const msg = err.code === "ENOENT" ? "claude not found on PATH" : String(err);
+    return { ok: false, windows: [], source, ts: now(), error: msg.slice(0, 200) };
+  }
+  const windows = parseClaudeUsage(text);
+  return windows.length ? { ok: true, windows, source, ts: now() } : { ok: false, windows: [], source, ts: now(), error: text.trim().slice(0, 200) || "no usage reported" };
+}
+function findKey(obj, key) {
+  if (Array.isArray(obj)) {
+    for (const v of obj) {
+      const found = findKey(v, key);
+      if (found) return found;
+    }
+  } else if (obj && typeof obj === "object") {
+    const rec = obj;
+    if (rec[key] && typeof rec[key] === "object") return rec[key];
+    for (const v of Object.values(rec)) {
+      const found = findKey(v, key);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function codexWindow(minutes) {
+  const m = Number(minutes);
+  if (!Number.isFinite(m)) return { label: "window", short: "win" };
+  if (m === 300) return { label: "5h", short: "5h" };
+  if (m === 1440) return { label: "day", short: "day" };
+  if (m === 10080) return { label: "week", short: "wk" };
+  const s = m < 1440 ? `${Math.floor(m / 60)}h` : `${Math.floor(m / 1440)}d`;
+  return { label: s, short: s };
+}
+async function readTail(file, bytes) {
+  const fh = await fs8.promises.open(file, "r");
+  try {
+    const { size } = await fh.stat();
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    await fh.read(buf, 0, buf.length, start);
+    return buf.toString("utf-8");
+  } finally {
+    await fh.close();
+  }
+}
+async function codexSessionFiles(root, limit2) {
+  const sortedDirs = async (dir) => (await fs8.promises.readdir(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => path12.join(dir, d.name)).sort().reverse();
+  const days = [];
+  for (const y of await sortedDirs(root)) {
+    for (const m of await sortedDirs(y)) {
+      days.push(...await sortedDirs(m));
+      if (days.length >= 14) break;
+    }
+    if (days.length >= 14) break;
+  }
+  const files = [];
+  for (const day of days.slice(0, 14)) {
+    for (const name of await fs8.promises.readdir(day).catch(() => [])) {
+      if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
+      const file = path12.join(day, name);
+      try {
+        files.push({ file, mtime: (await fs8.promises.stat(file)).mtimeMs });
+      } catch {
+      }
+    }
+  }
+  return files.sort((a, b) => b.mtime - a.mtime).slice(0, limit2).map((f) => f.file);
+}
+async function codexUsage(home = os6.homedir()) {
+  const source = "your most recent Codex session";
+  for (const file of await codexSessionFiles(path12.join(home, ".codex", "sessions"), 5)) {
+    let lines;
+    try {
+      lines = (await readTail(file, CODEX_TAIL_BYTES)).split("\n");
+    } catch {
+      continue;
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"rate_limits"')) continue;
+      let rl;
+      try {
+        rl = findKey(JSON.parse(lines[i]), "rate_limits");
+      } catch {
+        continue;
+      }
+      if (!rl) continue;
+      const windows = [];
+      for (const key of ["primary", "secondary"]) {
+        const w = rl[key];
+        if (!w || typeof w !== "object" || w.used_percent == null) continue;
+        const { label, short } = codexWindow(w.window_minutes);
+        const resets = typeof w.resets_at === "number" ? new Date(w.resets_at * 1e3).toLocaleString(void 0, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }) : null;
+        windows.push({ label, short, pct: Number(w.used_percent), resets });
+      }
+      if (windows.length) {
+        const ts = new Date((await fs8.promises.stat(file)).mtimeMs).toISOString();
+        return { ok: true, windows, plan: rl.plan_type ?? null, source, ts };
+      }
+    }
+  }
+  return { ok: false, windows: [], source, ts: now(), error: "no Codex session with usage yet" };
+}
+var FETCH_USAGE = {
+  claude: claudeUsage,
+  codex: () => codexUsage()
+};
+var SERVICE_NAME = { claude: "Claude", codex: "Codex" };
+var ResourceMonitor = class {
+  constructor(tabs) {
+    this.tabs = tabs;
+  }
+  machine = { ok: false, ts: now(), error: "sampling\u2026" };
+  history = [];
+  agents = [];
+  usage = {};
+  usageAt = {};
+  usageBusy = /* @__PURE__ */ new Set();
+  prevCpu = cpuTimes();
+  lastAsk = 0;
+  fastUntil = 0;
+  timer = null;
+  inflight = null;
+  /** Latest sample plus 10 minutes of history. `fast` = the panel is open:
+   *  sample every ~3 s and refresh quota every minute. */
+  async snapshot(fast = false) {
+    const t = Date.now();
+    this.lastAsk = t;
+    const speedUp = fast && t >= this.fastUntil;
+    if (fast) this.fastUntil = t + FAST_HOLD_MS;
+    if (!this.timer && !this.inflight || speedUp) await this.tick();
+    else this.refreshUsage(this.tabs());
+    return this.build(fast);
+  }
+  stop() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.lastAsk = 0;
+  }
+  tick() {
+    if (!this.inflight) {
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = null;
+      this.inflight = this.sample().catch((err) => log(`[monitor] sample failed: ${err}`)).finally(() => {
+        this.inflight = null;
+        if (Date.now() - this.lastAsk >= IDLE_STOP_MS) return;
+        this.timer = setTimeout(() => {
+          void this.tick();
+        }, Date.now() < this.fastUntil ? FAST_MS : SLOW_MS);
+        this.timer.unref?.();
+      });
+    }
+    return this.inflight;
+  }
+  async sample() {
+    const tabs = this.tabs();
+    this.refreshUsage(tabs);
+    try {
+      const [mem, disk, gpu, table] = await Promise.all([memory(), diskUsage(), appleGpu(), processTable()]);
+      const cur = cpuTimes();
+      const dTotal = cur.total - this.prevCpu.total;
+      const cpuPct = dTotal > 0 ? round(100 * (1 - (cur.idle - this.prevCpu.idle) / dTotal)) : null;
+      this.prevCpu = cur;
+      this.machine = {
+        ok: true,
+        ts: now(),
+        cpu: { pct: cpuPct, cores: os6.cpus().length, load: os6.loadavg().map((x) => round(x, 2)) },
+        mem,
+        disk,
+        gpu
+      };
+      this.agents = tabs.map((tab) => agentProcess(tab, table));
+      const t = Date.now();
+      this.history.push({ t, cpu: cpuPct, mem: mem.pct, gpu });
+      while (this.history.length && this.history[0].t < t - HISTORY_MS) this.history.shift();
+    } catch (err) {
+      this.machine = { ok: false, ts: now(), error: String(err).slice(0, 200) };
+    }
+  }
+  refreshUsage(tabs) {
+    const every = Date.now() < this.fastUntil ? USAGE_FAST_MS : USAGE_SLOW_MS;
+    for (const s of this.servicesInUse(tabs)) {
+      if (this.usageBusy.has(s) || Date.now() - (this.usageAt[s] ?? 0) < every) continue;
+      this.usageBusy.add(s);
+      FETCH_USAGE[s]().catch((err) => ({ ok: false, windows: [], source: s, ts: now(), error: String(err).slice(0, 200) })).then((u) => {
+        this.usage[s] = u;
+        this.usageAt[s] = Date.now();
+        if (!u.ok) log(`[monitor] ${s} usage unavailable: ${u.error}`);
+      }).finally(() => this.usageBusy.delete(s));
+    }
+  }
+  servicesInUse(tabs) {
+    return [...new Set(tabs.map((t) => serviceFor(t.agent)).filter((s) => s !== null))];
+  }
+  build(fast) {
+    const tabs = this.tabs();
+    const active = tabs.find((t) => t.active);
+    const usage = {};
+    for (const s of this.servicesInUse(tabs)) {
+      if (this.usage[s]) usage[s] = this.usage[s];
+    }
+    return {
+      machine: {
+        ...this.machine,
+        label: process.platform === "darwin" ? "This Mac" : os6.hostname(),
+        history: [...this.history]
+      },
+      agents: this.agents,
+      activeService: active ? serviceFor(active.agent) : null,
+      usage,
+      interval: fast ? FAST_MS : SLOW_MS
+    };
+  }
+};
+function summarizeSnapshot(s) {
+  const parts = [];
+  const m = s.machine;
+  if (m.ok) {
+    const res = [
+      m.cpu?.pct != null ? `CPU ${Math.round(m.cpu.pct)}%` : "",
+      m.mem ? `RAM ${Math.round(m.mem.pct)}%` : ""
+    ].filter(Boolean).join(" ");
+    if (res) parts.push(res);
+  }
+  const u = s.activeService ? s.usage[s.activeService] : void 0;
+  if (s.activeService && u?.ok) {
+    const wins = u.windows.filter((w) => w.short).map((w) => `${w.short} ${Math.round(w.pct)}%`);
+    if (wins.length) parts.push(`${SERVICE_NAME[s.activeService]} ${wins.join(" ")}`);
+  }
+  return parts.join(" \xB7 ");
+}
+
 // src/main/updateCheck.ts
 import https from "https";
 var NPM_PACKAGE = "@phenx-inc/ctlsurf";
@@ -21880,6 +22305,13 @@ async function main() {
   const ptySize = tui.getPtySize();
   await orchestrator.spawnAgent(HEADLESS_TAB, agent, args.cwd, { trackTime: trackTimeOverride });
   orchestrator.resizePty(HEADLESS_TAB, ptySize.cols, ptySize.rows);
+  const monitor = new ResourceMonitor(() => orchestrator.getTabProcesses());
+  const refreshResources = () => {
+    monitor.snapshot().then((snap) => tui.update({ resources: summarizeSnapshot(snap) })).catch(() => {
+    });
+  };
+  refreshResources();
+  setInterval(refreshResources, 1e4).unref();
   if (isCodingAgent(agent)) {
     setTimeout(() => {
       orchestrator.writePty(HEADLESS_TAB, "hello\r");
@@ -21908,6 +22340,7 @@ async function main() {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
+    monitor.stop();
     tui.destroy();
     await orchestrator.shutdown();
     process.exit(0);