heyterm 0.1.0 → 0.1.2

package/dist/server/cli.js

@@ -1,8 +1,8 @@
 // src/server/cli.ts
 import { execFile as execFile5, spawn as spawn2 } from "node:child_process";
-import { readFile as readFile7 } from "node:fs/promises";
-import os7 from "node:os";
-import path17 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import os8 from "node:os";
+import path19 from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/server/agents/agent-adapters.ts
@@ -38,7 +38,27 @@ var gemini = {
   newSession: () => ({ program: "gemini", args: [] }),
   resume: (point) => ({ program: "gemini", args: point.agentSessionId && point.conversationSaved ? ["--resume", point.agentSessionId] : [] })
 };
-var adapters = [claude, codex, gemini];
+var grok = {
+  kind: "grok",
+  label: "Grok Build",
+  program: "grok",
+  installHint: "Install it with curl -fsSL https://x.ai/cli/install.sh | bash, then sign in with grok login.",
+  choosesSessionIdAtLaunch: true,
+  newSession: (context) => ({ program: "grok", args: context.agentSessionId ? ["-s", context.agentSessionId] : [] }),
+  resume: (point, context) => {
+    if (point.agentSessionId && point.conversationSaved) return { program: "grok", args: ["-r", point.agentSessionId] };
+    return grok.newSession(context);
+  }
+};
+var cursor = {
+  kind: "cursor",
+  label: "Cursor",
+  program: "cursor-agent",
+  installHint: "Install it with curl https://cursor.com/install -fsS | bash, then sign in with cursor-agent login.",
+  newSession: () => ({ program: "cursor-agent", args: [] }),
+  resume: (point) => ({ program: "cursor-agent", args: point.agentSessionId && point.conversationSaved ? ["--resume", point.agentSessionId] : [] })
+};
+var adapters = [claude, codex, gemini, grok, cursor];
 var AgentAdapters = class {
   static get(kind) {
     return adapters.find((adapter) => adapter.kind === kind) ?? claude;
@@ -83,6 +103,11 @@ var HookCommands = class {
   static forSession(scriptPath, eventName) {
     return `node ${quoted(scriptPath)} heyterm ${eventName}`;
   }
+  // For agents that read hooks only from global files (Grok Build, Cursor). The forwarder checks the
+  // agent is really the one named, since Grok also runs the hooks in Cursor's file.
+  static forAgent(scriptPath, eventName, agent) {
+    return `node ${quoted(scriptPath)} agent ${eventName} ${agent}`;
+  }
   // For the user's own settings. If HeyTerm has been removed and the script is gone, this does
   // nothing and fails nothing, so the user never sees a hook error.
   static forExistingSessions(scriptPath, eventName) {
@@ -110,12 +135,24 @@ function forwardScript(port, token) {
 const http = require("http");
 const origin = process.argv[2];
 const eventName = process.argv[3] || "";
+const agentKind = process.argv[4] || "";
 const sessionName = process.env.HEYTERM_SESSION;
+// Grok and Cursor set these on every hook they run. Grok also runs the hooks in Cursor's and
+// Claude's files, so a hook knows which agent really ran it only by these.
+const ranByGrok = Boolean(process.env.GROK_HOOK_EVENT);
+const ranByCursor = Boolean(process.env.CURSOR_VERSION) && !ranByGrok;
 const isHeyTermSession = origin === "heyterm" && Boolean(sessionName);
-const isOutsideSession = origin === "external" && !sessionName && !process.env.HEYTERM_ROUTER;
-if ((!isHeyTermSession && !isOutsideSession) || !/^[A-Za-z]+$/.test(eventName)) process.exit(0);
+const isOutsideSession = origin === "external" && !sessionName && !process.env.HEYTERM_ROUTER && !ranByGrok && !process.env.CURSOR_VERSION;
+const isAgentEvent = origin === "agent" && ((agentKind === "grok" && ranByGrok) || (agentKind === "cursor" && ranByCursor));
+// Cursor reads a prompt hook's reply as a verdict, so its prompt always gets a "go ahead".
+const defaultReply = ranByCursor && agentKind === "cursor" && eventName === "beforeSubmitPrompt" ? '{"continue":true}' : "";
+const finish = (answer) => {
+  process.stdout.write(answer || defaultReply);
+  process.exit(0);
+};
+if ((!isHeyTermSession && !isOutsideSession && !isAgentEvent) || !/^[A-Za-z]+$/.test(eventName)) finish("");
 
-const query = isHeyTermSession ? "session=" + encodeURIComponent(sessionName) : "external=1";
+const query = isHeyTermSession ? "session=" + encodeURIComponent(sessionName) : isAgentEvent ? "agent=" + agentKind : "external=1";
 const waitSeconds = eventName === "PermissionRequest" ? ${permissionWaitSeconds} : 3;
 const chunks = [];
 process.stdin.on("data", (chunk) => chunks.push(chunk));
@@ -133,14 +170,11 @@ process.stdin.on("end", () => {
     (response) => {
       const answer = [];
       response.on("data", (chunk) => answer.push(chunk));
-      response.on("end", () => {
-        if (response.statusCode === 200) process.stdout.write(Buffer.concat(answer));
-        process.exit(0);
-      });
+      response.on("end", () => finish(response.statusCode === 200 ? Buffer.concat(answer).toString() : ""));
     },
   );
   request.on("timeout", () => request.destroy());
-  request.on("error", () => process.exit(0));
+  request.on("error", () => finish(""));
   request.end(body);
 });
 `;
@@ -250,12 +284,12 @@ var ExistingSessionConnector = class {
   }
   // A file that is not valid JSON is refused rather than overwritten: it belongs to the user.
   async readSettings() {
-    const text = await readFile2(this.settingsPath, "utf8").catch((error) => {
+    const text2 = await readFile2(this.settingsPath, "utf8").catch((error) => {
       if (error.code === "ENOENT") return "{}";
       throw error;
     });
     try {
-      return JSON.parse(text || "{}");
+      return JSON.parse(text2 || "{}");
     } catch {
       throw new Error(`${this.settingsPath} is not valid JSON, so HeyTerm left it alone. Fix it and try again.`);
     }
@@ -274,8 +308,8 @@ var ExistingSessionConnector = class {
 
 // src/server/main.ts
 import { execFile as execFile3 } from "node:child_process";
-import os5 from "node:os";
-import path15 from "node:path";
+import os6 from "node:os";
+import path17 from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/server/actions/action-executor.ts
@@ -340,8 +374,8 @@ var PermissionRisk = class _PermissionRisk {
     };
   }
 };
-function stringField(record, key) {
-  const value = record[key];
+function stringField(record2, key) {
+  const value = record2[key];
   return typeof value === "string" ? value : "";
 }
 
@@ -374,8 +408,11 @@ var SessionLifecycle = class _SessionLifecycle {
       }
       case "SessionEnd":
         return _SessionLifecycle.moveTo({ ...session, pending: void 0 }, "stopped", event.receivedAt);
-      case "Notification":
-        return session;
+      case "Notification": {
+        if (payload.waits_in_terminal === true) return _SessionLifecycle.moveTo({ ...session, blockedByTerminalDialog: true }, "asked", event.receivedAt);
+        const reply2 = stringField2(payload, "assistant_message");
+        return reply2 ? { ...session, lastMessage: reply2 } : session;
+      }
     }
   }
   static applyTrustDialog(session, now, trustSubject = "folder") {
@@ -384,8 +421,8 @@ var SessionLifecycle = class _SessionLifecycle {
   static markSeen(session, now) {
     return { ...session, lastSeenAt: now, activitySinceSeen: [] };
   }
-  static recordDecision(session, text, now) {
-    return _SessionLifecycle.addActivity(session, "decision", text, now);
+  static recordDecision(session, text2, now) {
+    return _SessionLifecycle.addActivity(session, "decision", text2, now);
   }
   static applyToolStart(session, event) {
     const toolName = stringField2(event.payload, "tool_name");
@@ -415,7 +452,8 @@ var SessionLifecycle = class _SessionLifecycle {
     return _SessionLifecycle.moveTo({ ...session, pending }, "needs_permission", event.receivedAt);
   }
   static applyTurnEnd(session, event) {
-    const lastMessage = stringField2(event.payload, "last_assistant_message");
+    if (event.payload.turn_cancelled === true) return _SessionLifecycle.moveTo({ ...session, pending: void 0 }, "idle", event.receivedAt);
+    const lastMessage = event.payload.keep_last_message === true ? session.lastMessage ?? "" : stringField2(event.payload, "last_assistant_message");
     const withMessage = _SessionLifecycle.addActivity({ ...session, lastMessage, pending: void 0 }, "message", lastMessage, event.receivedAt);
     return _SessionLifecycle.moveTo(withMessage, endsWithQuestion(lastMessage) ? "asked" : "done", event.receivedAt);
   }
@@ -424,9 +462,9 @@ var SessionLifecycle = class _SessionLifecycle {
     const waitedMillisecondsToday = leavingWait ? session.waitedMillisecondsToday + Math.max(0, now - session.stateSince) : session.waitedMillisecondsToday;
     return { ...session, state, stateSince: now, waitedMillisecondsToday };
   }
-  static addActivity(session, kind, text, at) {
-    if (!text) return session;
-    const entries = [...session.activitySinceSeen, { kind, text, at }];
+  static addActivity(session, kind, text2, at) {
+    if (!text2) return session;
+    const entries = [...session.activitySinceSeen, { kind, text: text2, at }];
     return { ...session, activitySinceSeen: entries.slice(-_SessionLifecycle.maximumActivityEntries) };
   }
 };
@@ -444,12 +482,12 @@ function endsWithQuestion(message) {
   const paragraphs = message.split(/\n\s*\n/).map((paragraph) => paragraph.trim()).filter(Boolean);
   return paragraphs.at(-1)?.includes("?") ?? false;
 }
-function stringField2(record, key) {
-  const value = record[key];
+function stringField2(record2, key) {
+  const value = record2[key];
   return typeof value === "string" ? value : "";
 }
-function recordField(record, key) {
-  const value = record[key];
+function recordField(record2, key) {
+  const value = record2[key];
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
@@ -582,8 +620,8 @@ var PendingControls = class {
 var longestUtteranceCharacters = 4e3;
 var greeting = /^hey[\s-]?term(?:inal)?\b[\s,.:!-]*/i;
 var UtteranceLimits = class {
-  static check(text) {
-    const utterance = text.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").trim().replace(greeting, "").trim();
+  static check(text2) {
+    const utterance = text2.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").trim().replace(greeting, "").trim();
     if (!utterance) return { ok: false, reason: "empty" };
     if (utterance.length > longestUtteranceCharacters) return { ok: false, reason: "too_long" };
     return { ok: true, utterance };
@@ -640,7 +678,7 @@ var CatchUpDigest = class _CatchUpDigest {
       parts.push("Nothing new since you looked.");
     } else {
       const counts = [plural(commands.length, "command"), changedFiles.length > 0 ? `${plural(changedFiles.length, "file")} changed` : ""];
-      const countText = counts.filter((text) => text && !text.startsWith("0 ")).join(", ");
+      const countText = counts.filter((text2) => text2 && !text2.startsWith("0 ")).join(", ");
       if (countText) parts.push(`${countText}.`);
     }
     if (lead) parts.push(lead);
@@ -692,9 +730,9 @@ var SessionActions = class {
         return { text: "I did not catch what to do.", tone: "warning", speak: true };
     }
   }
-  async deliver(sessionName, text) {
+  async deliver(sessionName, text2) {
     this.markSeen(sessionName);
-    const result = await this.launcher.deliverText(sessionName, text);
+    const result = await this.launcher.deliverText(sessionName, text2);
     if (result === "submitted") return { text: `Sent to ${sessionName}.`, tone: "success", speak: false };
     if (result === "queued") return { text: `Queued for ${sessionName}; it reads it after its current step.`, tone: "info", speak: false };
     return { text: `${sessionName} did not take the message. Check its terminal.`, tone: "error", speak: true };
@@ -825,8 +863,8 @@ function permissionSpoken(sessionName, pending) {
   if (editingTools.includes(pending.toolName)) return `${sessionName} wants to edit a file. Say approve or deny.`;
   return `${sessionName} wants to use a tool. Say approve or deny.`;
 }
-function endSentence(text) {
-  return /[.?!]$/.test(text.trim()) ? text.trim() : `${text.trim()}.`;
+function endSentence(text2) {
+  return /[.?!]$/.test(text2.trim()) ? text2.trim() : `${text2.trim()}.`;
 }
 function questionHeadline(sessionName, pending) {
   const [first, ...rest] = pending.questions;
@@ -839,24 +877,59 @@ var countWords = ["zero", "one", "two", "three", "four", "five", "six", "seven",
 function countWord(count) {
   return countWords[count] ?? String(count);
 }
-function capitalize(text) {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+function capitalize(text2) {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 }
 
+// src/shared/request-thread.ts
+var decisionKinds = ["permission", "question", "trust", "failed"];
+var RequestThread = class _RequestThread {
+  static isDecision(kind) {
+    return decisionKinds.includes(kind);
+  }
+  // The same session asking the same kind of thing since the same moment is the same request.
+  static isStillWaiting(request, sessions) {
+    return AttentionQueue.build(sessions).some((item) => item.sessionName === request.session && item.kind === request.kind && item.since === request.since);
+  }
+  static waitingDecisions(sessions) {
+    return AttentionQueue.build(sessions).filter((item) => _RequestThread.isDecision(item.kind));
+  }
+  // Requests the conversation has no line for, so they can still be shown and answered.
+  static waitingWithoutEntry(entries, sessions) {
+    const told = entries.flatMap((entry) => entry.request ? [entry.request] : []);
+    return _RequestThread.waitingDecisions(sessions).filter((item) => !told.some((request) => request.session === item.sessionName && request.kind === item.kind && request.since === item.since));
+  }
+  // A click on a request's button, put the way the user would have said it.
+  static replyWords(action) {
+    switch (action.type) {
+      case "approve":
+        return `Approve ${action.session}`;
+      case "deny":
+        return `Deny ${action.session}`;
+      case "trust":
+        return `Trust ${action.session}`;
+      case "answer":
+        return `${action.session}: ${Object.values(action.answers).join(", ")}`;
+      default:
+        return void 0;
+    }
+  }
+};
+
 // src/server/router/utterance-text.ts
-function wordSpans(text) {
-  return [...text.matchAll(/[a-z0-9][a-z0-9'-]*/gi)].map((match) => ({
+function wordSpans(text2) {
+  return [...text2.matchAll(/[a-z0-9][a-z0-9'-]*/gi)].map((match) => ({
     word: match[0].toLowerCase(),
     start: match.index,
     end: match.index + match[0].length
   }));
 }
-function normalizedPhrase(text) {
-  return wordSpans(text).map((span) => span.word).join(" ");
+function normalizedPhrase(text2) {
+  return wordSpans(text2).map((span) => span.word).join(" ");
 }
-function textFromWord(text, spans, wordIndex) {
+function textFromWord(text2, spans, wordIndex) {
   const span = spans[wordIndex];
-  return span ? text.slice(span.start).trim() : "";
+  return span ? text2.slice(span.start).trim() : "";
 }
 var SpokenPhrases = {
   yes: /^(yes|yeah|yep|yup|sure|ok|okay|approve|approved|allow|accept|fine|sounds good|looks good|go ahead|do it)( (it|that|this|please|go ahead|do it))*$/,
@@ -948,8 +1021,8 @@ var SpokenNameMatcher = class _SpokenNameMatcher {
     return mentions;
   }
 };
-function compactForm(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]/g, "");
+function compactForm(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
 function spanLength(mention) {
   return mention.lastWordIndex - mention.firstWordIndex;
@@ -1063,7 +1136,7 @@ var sessionCommands = [
   { pattern: /^(?:stop|interrupt|pause|halt|hold) (.+)$/, build: (session) => ({ type: "interrupt", session }) },
   { pattern: /^(?:bring back|resume|reopen|restart) (.+)$/, build: (session) => ({ type: "resume", session }), isResume: true }
 ];
-var spawnPattern = /^(?:start|open|spin up|create|launch|begin)(?: a| an)?(?: new)?(?: (claude|codex|gemini))?(?: (?:session|agent|terminal))? (?:in|on|for|at) /;
+var spawnPattern = /^(?:start|open|spin up|create|launch|begin)(?: a| an)?(?: new)?(?: (claude|codex|gemini|grok(?: build)?|cursor))?(?: (?:session|agent|terminal))? (?:in|on|for|at) /;
 var taskJoinWords = /* @__PURE__ */ new Set(["and", "to", "then", "so"]);
 var FastPathRouter = class {
   constructor(options = { sendUnaddressedWordsToFocusedSession: true }) {
@@ -1111,7 +1184,7 @@ var FastPathRouter = class {
       let taskWordIndex = firstProjectWord + wordCount;
       while (spans[taskWordIndex] && taskJoinWords.has(spans[taskWordIndex].word)) taskWordIndex += 1;
       const task = textFromWord(utterance, spans, taskWordIndex);
-      const agent = prefix[1] === "codex" || prefix[1] === "gemini" ? prefix[1] : void 0;
+      const agent = namedAgent(prefix[1]);
       return { type: "spawn", project: project.name, ...agent ? { agent } : {}, ...task ? { task } : {} };
     }
     return void 0;
@@ -1134,16 +1207,16 @@ var FastPathRouter = class {
     if (!mention) return void 0;
     let textWordIndex = mention.lastWordIndex + 1;
     while (spans[textWordIndex] && ["session", "agent", "one", "to"].includes(spans[textWordIndex].word)) textWordIndex += 1;
-    const text = textFromWord(utterance, spans, textWordIndex);
-    return text ? { type: "send", session: mention.name, text, needsPreview: true } : void 0;
+    const text2 = textFromWord(utterance, spans, textWordIndex);
+    return text2 ? { type: "send", session: mention.name, text: text2, needsPreview: true } : void 0;
   }
   // "Peeker, run the tests again."
   routeAddressed(utterance, spans, sessionMatcher) {
     const mentions = sessionMatcher.findMentions(utterance);
     const [first] = mentions;
     if (!first || first.firstWordIndex !== 0 || mentions.length > 1) return void 0;
-    const text = textFromWord(utterance, spans, first.lastWordIndex + 1);
-    return text ? { type: "send", session: first.name, text, needsPreview: true } : void 0;
+    const text2 = textFromWord(utterance, spans, first.lastWordIndex + 1);
+    return text2 ? { type: "send", session: first.name, text: text2, needsPreview: true } : void 0;
   }
   routeToFocusedSession(utterance, phrase, context, sessionMatcher) {
     if (sessionMatcher.findMentions(utterance).length > 0) return void 0;
@@ -1156,6 +1229,11 @@ var FastPathRouter = class {
 function acceptsText(session) {
   return !["needs_permission", "needs_trust", "stopped", "starting"].includes(session.state) && session.pending === void 0 && !session.blockedByTerminalDialog;
 }
+function namedAgent(spoken) {
+  if (spoken === "codex" || spoken === "gemini" || spoken === "cursor") return spoken;
+  if (spoken?.startsWith("grok")) return "grok";
+  return void 0;
+}
 
 // src/server/conductor/conductor-rules.ts
 var longestSpokenReply = 280;
@@ -1184,9 +1262,9 @@ var NarrationRules = class {
 function itemKey(item) {
   return `${item.sessionName}|${item.kind}|${item.since}`;
 }
-function shortenedForSpeech(text) {
-  if (text.length <= longestSpokenReply) return text;
-  const sentences = text.match(/[^.!?]+[.!?]+/g) ?? [text];
+function shortenedForSpeech(text2) {
+  if (text2.length <= longestSpokenReply) return text2;
+  const sentences = text2.match(/[^.!?]+[.!?]+/g) ?? [text2];
   return `${sentences.slice(0, 2).join("").trim()} The rest is on screen.`;
 }
 var ConductorSafety = class {
@@ -1195,8 +1273,8 @@ var ConductorSafety = class {
     return /privatekeys/i.test(JSON.stringify(input ?? {}));
   }
 };
-function speakable(text) {
-  return text.replace(/```[\s\S]*?```/g, " ").replace(/[`*_#>]/g, "").replace(/^\s*[-•]\s+/gm, "").replace(/\s+/g, " ").trim();
+function speakable(text2) {
+  return text2.replace(/```[\s\S]*?```/g, " ").replace(/[`*_#>]/g, "").replace(/^\s*[-•]\s+/gm, "").replace(/\s+/g, " ").trim();
 }
 
 // src/server/actions/action-executor.ts
@@ -1246,8 +1324,8 @@ var ActionExecutor = class extends EventEmitter {
   currentMode() {
     return this.mode;
   }
-  async handleUtterance(text, source, focusOverride) {
-    const checked = UtteranceLimits.check(text);
+  async handleUtterance(text2, source, focusOverride) {
+    const checked = UtteranceLimits.check(text2);
     if (!checked.ok) {
       if (checked.reason === "too_long") this.tell({ text: "That was far longer than speech, so I left it. Say it in a sentence or two.", tone: "warning", speak: true });
       return;
@@ -1265,6 +1343,12 @@ var ActionExecutor = class extends EventEmitter {
     if (this.controls.preview && action.type !== "cancel" && action.type !== "send_now") await this.sendPreviewNow();
     await this.perform(action, source === "voice" ? utterance : "keyboard", utterance);
   }
+  // A button on the page. An answer to a request also shows in the conversation as the user's reply.
+  async performClick(action) {
+    const replyWords = RequestThread.replyWords(action);
+    if (replyWords) this.assistant?.recordReply(replyWords);
+    return this.perform(action, "click");
+  }
   async perform(action, decidedBy, utterance = "") {
     const decision = { decidedBy };
     switch (action.type) {
@@ -1305,14 +1389,14 @@ var ActionExecutor = class extends EventEmitter {
         return this.tell(await this.sessionActions.perform(action, (sessionName) => this.setFocus(sessionName)));
     }
   }
-  async send(sessionName, text, needsPreview) {
+  async send(sessionName, text2, needsPreview) {
     const session = this.registry.get(sessionName);
     if (!session) return this.tell({ text: `There is no session called ${sessionName}.`, tone: "warning", speak: true });
     if (session.origin === "external") return this.tell({ text: outsideSessionReason(sessionName), tone: "warning", speak: true });
     if (session.blockedByTerminalDialog) return this.tell({ text: `${sessionName} is showing a dialog in its terminal. Answer it there.`, tone: "warning", speak: true });
     if (!acceptsText(session)) return this.tell({ text: blockedReason(sessionName, session.state), tone: "warning", speak: true });
-    if (!needsPreview) return this.tell(await this.sessionActions.deliver(sessionName, text));
-    this.controls.startPreview({ session: sessionName, text }, () => void this.sendPreviewNow());
+    if (!needsPreview) return this.tell(await this.sessionActions.deliver(sessionName, text2));
+    this.controls.startPreview({ session: sessionName, text: text2 }, () => void this.sendPreviewNow());
   }
   async sendPreviewNow() {
     const preview = this.controls.takePreview();
@@ -1433,8 +1517,8 @@ function describeSession(session) {
   }
   return parts.join("; ");
 }
-function clip(text) {
-  const oneLine = text.replace(/\s+/g, " ").replaceAll("</session_text>", "");
+function clip(text2) {
+  const oneLine = text2.replace(/\s+/g, " ").replaceAll("</session_text>", "");
   return oneLine.length > 300 ? `${oneLine.slice(0, 300)}\u2026` : oneLine;
 }
 
@@ -1519,7 +1603,7 @@ var Assistant = class extends EventEmitter2 {
     this.conductor = conductor;
     this.situation = situation;
     this.announcementMode = announcementMode;
-    conductor.on("activity", (kind, text) => this.record(kind, text));
+    conductor.on("activity", (kind, text2) => this.record(kind, text2));
     conductor.on("busy", (busy) => this.emit("thinking", busy));
   }
   conductor;
@@ -1533,16 +1617,20 @@ var Assistant = class extends EventEmitter2 {
   // One announcement at a time; what arrives meanwhile is told together after it.
   narrating = false;
   // Said straight away, outside a turn: the assistant's own request for a confirm.
-  sayNow(text) {
-    this.record("assistant", text);
-    this.emit("say", text);
+  sayNow(text2) {
+    this.record("assistant", text2);
+    this.emit("say", text2);
   }
   // Something HeyTerm did at once, without the assistant, still belongs in the conversation.
   recordInstant(utterance) {
     this.record("user", utterance);
   }
-  recordOutcome(text) {
-    this.record("event", text);
+  // A request answered with a click, shown as the user's reply under it.
+  recordReply(words) {
+    this.record("user", words);
+  }
+  recordOutcome(text2) {
+    this.record("event", text2);
   }
   close() {
     clearTimeout(this.groupTimer);
@@ -1564,6 +1652,10 @@ var Assistant = class extends EventEmitter2 {
   noteSessions(sessions) {
     const arrived = this.arrivals.note(AttentionQueue.build(sessions));
     if (arrived.length === 0) return;
+    for (const item of arrived) {
+      if (RequestThread.isDecision(item.kind)) this.record("request", item.headline, { session: item.sessionName, kind: item.kind, since: item.since });
+      else this.record("event", item.headline);
+    }
     this.waitingArrivals.push(...arrived);
     this.scheduleNarration();
   }
@@ -1584,7 +1676,6 @@ var Assistant = class extends EventEmitter2 {
   async narrate() {
     const items = this.waitingArrivals;
     this.waitingArrivals = [];
-    for (const item of items) this.record("event", item.headline);
     const mode = this.announcementMode();
     const told = mode === "mute" ? [] : mode === "quiet" ? items.filter((item) => kindsToldInQuietMode.includes(item.kind)) : items;
     if (told.length === 0) return;
@@ -1623,8 +1714,9 @@ var Assistant = class extends EventEmitter2 {
     this.record("error", message);
     if (this.announcementMode() !== "mute") this.emit("say", "Something went wrong on my side. It's on screen.");
   }
-  record(kind, text) {
-    this.entries = [...this.entries, { id: this.nextEntryId++, at: Date.now(), kind, text }].slice(-keptEntries);
+  record(kind, text2, request) {
+    const entry = request ? { id: this.nextEntryId++, at: Date.now(), kind, text: text2, request } : { id: this.nextEntryId++, at: Date.now(), kind, text: text2 };
+    this.entries = [...this.entries, entry].slice(-keptEntries);
     this.emit("conversation", this.entries);
   }
 };
@@ -1685,9 +1777,9 @@ var Conductor = class extends EventEmitter3 {
   sendToSession;
   turnTimer;
   // Resolves with the assistant's reply to this turn. Turns run one at a time, in order.
-  ask(text, priority) {
+  ask(text2, priority) {
     return new Promise((resolve, reject) => {
-      this.turns.add({ text, resolve, reject }, priority);
+      this.turns.add({ text: text2, resolve, reject }, priority);
       this.startNextTurn();
     });
   }
@@ -1850,7 +1942,7 @@ function createConductorTools(dependencies) {
         "send_to_session",
         "Give a session its next prompt, as if the developer typed it.",
         { name: z.string(), text: z.string() },
-        ({ name, text }) => withSession(name, (session) => ownSessionOnly(session, async () => (await sessionActions.deliver(name, text)).text))
+        ({ name, text: text2 }) => withSession(name, (session) => ownSessionOnly(session, async () => (await sessionActions.deliver(name, text2)).text))
       ),
       tool(
         "answer_question",
@@ -1881,11 +1973,11 @@ function createConductorTools(dependencies) {
       ),
       tool(
         "start_session",
-        "Start a new coding agent session in a folder, with its first task if there is one. The folder is a project name from list_projects or any folder path on this Mac, such as ~/Documents/Projects. The agent is Claude Code unless the developer asks for Codex or Gemini.",
+        "Start a new coding agent session in a folder, with its first task if there is one. The folder is a project name from list_projects or any folder path on this Mac, such as ~/Documents/Projects. The agent is Claude Code unless the developer asks for Codex, Gemini, Grok (Grok Build) or Cursor.",
         {
           project: z.string().describe("A project name, or a folder path"),
           task: z.string().optional(),
-          agent: z.enum(["claude", "codex", "gemini"]).optional()
+          agent: z.enum(["claude", "codex", "gemini", "grok", "cursor"]).optional()
         },
         async ({ project, task, agent }) => reply((await sessionActions.perform({ type: "spawn", project, ...task ? { task } : {}, ...agent ? { agent } : {} }, (sessionName) => executor.setFocus(sessionName))).text)
       ),
@@ -1940,8 +2032,8 @@ function createConductorTools(dependencies) {
     ]
   });
 }
-function reply(text) {
-  return { content: [{ type: "text", text }] };
+function reply(text2) {
+  return { content: [{ type: "text", text: text2 }] };
 }
 
 // src/server/conductor/create-assistant.ts
@@ -2098,6 +2190,102 @@ var HeldHookRequests = class {
   }
 };
 
+// src/server/hooks/agent-hook-files.ts
+import { copyFile as copyFile2, mkdir as mkdir5, readFile as readFile4, rename as rename3, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import os3 from "node:os";
+import path8 from "node:path";
+
+// src/server/hooks/global-agent-hooks.ts
+var grokEvents = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "StopCancelled", "StopFailure", "Notification", "SessionEnd"];
+var cursorEvents = ["sessionStart", "sessionEnd", "beforeSubmitPrompt", "postToolUse", "afterAgentResponse", "stop"];
+var hookTimeoutSeconds = 10;
+var GlobalAgentHooks = class _GlobalAgentHooks {
+  static grokHookFile(scriptPath) {
+    const hooks = Object.fromEntries(
+      grokEvents.map((eventName) => [eventName, [{ hooks: [{ type: "command", command: HookCommands.forAgent(scriptPath, eventName, "grok"), timeout: hookTimeoutSeconds }] }]])
+    );
+    return { hooks };
+  }
+  static cursorWithHeyTerm(file, scriptPath) {
+    const cleaned = _GlobalAgentHooks.cursorWithoutHeyTerm(file);
+    const hooks = { ...cleaned.hooks ?? {} };
+    for (const eventName of cursorEvents) hooks[eventName] = [...hooks[eventName] ?? [], { command: HookCommands.forAgent(scriptPath, eventName, "cursor"), timeout: hookTimeoutSeconds }];
+    return { ...cleaned, version: cleaned.version ?? 1, hooks };
+  }
+  static cursorWithoutHeyTerm(file) {
+    if (!file.hooks) return file;
+    const remaining = {};
+    for (const [eventName, entries] of Object.entries(file.hooks)) {
+      const kept = entries.filter((entry) => !HookCommands.isHeyTerm(entry.command ?? ""));
+      if (kept.length > 0) remaining[eventName] = kept;
+    }
+    const { hooks: _removedHooks, ...rest } = file;
+    return Object.keys(remaining).length > 0 ? { ...rest, hooks: remaining } : rest;
+  }
+};
+
+// src/server/hooks/agent-hook-files.ts
+function agentHookPaths() {
+  return {
+    grokPath: process.env.HEYTERM_GROK_HOOKS_PATH ?? path8.join(process.env.GROK_HOME ?? path8.join(os3.homedir(), ".grok"), "hooks", "heyterm.json"),
+    cursorPath: process.env.HEYTERM_CURSOR_HOOKS_PATH ?? path8.join(os3.homedir(), ".cursor", "hooks.json")
+  };
+}
+var AgentHookFiles = class {
+  constructor(scriptPath, backupDirectory, paths = agentHookPaths()) {
+    this.scriptPath = scriptPath;
+    this.backupDirectory = backupDirectory;
+    this.paths = paths;
+  }
+  scriptPath;
+  backupDirectory;
+  paths;
+  async install() {
+    if (await isFolder2(path8.dirname(path8.dirname(this.paths.grokPath)))) {
+      await mkdir5(path8.dirname(this.paths.grokPath), { recursive: true });
+      await writeAtomically(this.paths.grokPath, GlobalAgentHooks.grokHookFile(this.scriptPath));
+    }
+    if (await isFolder2(path8.dirname(this.paths.cursorPath))) {
+      const current = await readJson(this.paths.cursorPath);
+      if (!current) return;
+      await this.backUp(this.paths.cursorPath);
+      await writeAtomically(this.paths.cursorPath, GlobalAgentHooks.cursorWithHeyTerm(current, this.scriptPath));
+    }
+  }
+  async remove() {
+    await rm2(this.paths.grokPath, { force: true });
+    const current = await readJson(this.paths.cursorPath);
+    if (!current || !current.hooks) return;
+    const cleaned = GlobalAgentHooks.cursorWithoutHeyTerm(current);
+    if (JSON.stringify(cleaned) === JSON.stringify(current)) return;
+    const holdsNothingElse = Object.keys(cleaned).every((key) => key === "version");
+    if (holdsNothingElse) await rm2(this.paths.cursorPath, { force: true });
+    else await writeAtomically(this.paths.cursorPath, cleaned);
+  }
+  async backUp(filePath) {
+    await mkdir5(this.backupDirectory, { recursive: true });
+    await copyFile2(filePath, path8.join(this.backupDirectory, `cursor-hooks-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}.json`)).catch(() => void 0);
+  }
+};
+async function isFolder2(folder) {
+  return stat2(folder).then((info) => info.isDirectory(), () => false);
+}
+async function readJson(filePath) {
+  const text2 = await readFile4(filePath, "utf8").catch((error) => error.code === "ENOENT" ? "{}" : void 0);
+  if (text2 === void 0) return void 0;
+  try {
+    return JSON.parse(text2 || "{}");
+  } catch {
+    return void 0;
+  }
+}
+async function writeAtomically(filePath, content) {
+  const temporaryPath = `${filePath}.heyterm.tmp`;
+  await writeFile4(temporaryPath, `${JSON.stringify(content, null, 2)}
+`);
+  await rename3(temporaryPath, filePath);
+}
+
 // src/server/http/heyterm-http-server.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { createServer } from "node:http";
@@ -2113,7 +2301,7 @@ var HeyTermHttpServer = class {
     this.hub = hub;
     this.terminals = terminals;
     this.tickets = tickets;
-    this.serveWeb = existsSync2(webDirectory) ? sirv(webDirectory, { single: true }) : void 0;
+    this.serveWeb = existsSync2(webDirectory) ? sirv(webDirectory, { single: true, setHeaders: cachingHeaders }) : void 0;
     this.server.on("upgrade", (request, socket, head) => {
       if (!this.guard.isFromThisMac(request) || !this.guard.hasToken(request)) return socket.destroy();
       const url = new URL(request.url ?? "/", "http://127.0.0.1");
@@ -2178,6 +2366,8 @@ var HeyTermHttpServer = class {
   async handleHook(request, response, url) {
     if (!this.guard.hasToken(request)) return respond(response, 401, "");
     const eventName = url.pathname.slice("/hooks/".length);
+    const agent = url.searchParams.get("agent");
+    if (agent === "grok" || agent === "cursor") return this.handleAgentHook(request, response, agent, eventName);
     const sessionName = url.searchParams.get("session") ?? "";
     const isExternal = url.searchParams.get("external") === "1";
     if (!forwardedHookEvents.includes(eventName) || !sessionName && !isExternal) return respond(response, 400, "");
@@ -2190,7 +2380,21 @@ var HeyTermHttpServer = class {
     const answer = isExternal ? await this.registry.applyExternalHookEvent(eventName, payload, Date.now()) : await this.registry.applyHookEvent({ name: eventName, sessionName, payload, receivedAt: Date.now() });
     respond(response, 200, answer, "application/json");
   }
+  // Grok Build and Cursor name events their own way; the registry translates them.
+  async handleAgentHook(request, response, agent, eventName) {
+    if (!/^[A-Za-z]+$/.test(eventName)) return respond(response, 400, "");
+    let payload;
+    try {
+      payload = JSON.parse(await readBody(request, largestHookBodyBytes));
+    } catch {
+      return respond(response, 400, "");
+    }
+    respond(response, 200, await this.registry.applyAgentHookEvent(agent, eventName, payload, Date.now()), "application/json");
+  }
 };
+function cachingHeaders(response, pathname) {
+  response.setHeader("Cache-Control", pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache");
+}
 function securityHeaders(port) {
   const ownSockets = `ws://127.0.0.1:${port} ws://localhost:${port}`;
   return {
@@ -2212,9 +2416,9 @@ function securityHeaders(port) {
     "Cross-Origin-Opener-Policy": "same-origin"
   };
 }
-function safeJson(text) {
+function safeJson(text2) {
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch {
     return void 0;
   }
@@ -2253,7 +2457,7 @@ var EventHub = class {
     this.macVoice = macVoice;
     this.assistant = assistant;
     assistant.on("conversation", (entries) => this.broadcast({ type: "conversation", entries }));
-    assistant.on("say", (text) => this.broadcast({ type: "say", text }));
+    assistant.on("say", (text2) => this.broadcast({ type: "say", text: text2 }));
     registry.on("changed", () => this.scheduleSnapshot());
     executor.on("changed", () => this.scheduleSnapshot());
     executor.on("feedback", (feedback) => this.broadcast({ type: "feedback", feedback }));
@@ -2286,16 +2490,16 @@ var EventHub = class {
       this.onPageCountChange(this.sockets.size);
     });
   }
-  async receive(text, socket) {
+  async receive(text2, socket) {
     let message;
     try {
-      message = JSON.parse(text);
+      message = JSON.parse(text2);
     } catch {
       return;
     }
     try {
       if (message.type === "utterance") await this.executor.handleUtterance(String(message.text), message.source === "voice" ? "voice" : "keyboard");
-      if (message.type === "action") await this.executor.perform(message.action, "click");
+      if (message.type === "action") await this.executor.performClick(message.action);
       if (message.type === "focus") this.executor.setFocus(String(message.session));
       if (message.type === "setup_refresh") await this.sendSetup();
       if (message.type === "set_project_roots") await this.changeProjectRoots(message.roots);
@@ -2329,8 +2533,8 @@ var EventHub = class {
   }
   async connectExistingSessions(connected) {
     await this.setup.setExistingSessionsConnected(connected);
-    const text = connected ? "Connected. Claude sessions you start in any terminal now show up here." : "Disconnected. HeyTerm's hooks are out of your Claude settings.";
-    this.broadcast({ type: "feedback", feedback: { text, tone: "success", speak: false } });
+    const text2 = connected ? "Connected. Claude sessions you start in any terminal now show up here." : "Disconnected. HeyTerm's hooks are out of your Claude settings.";
+    this.broadcast({ type: "feedback", feedback: { text: text2, tone: "success", speak: false } });
     await this.sendSetup();
   }
   async refreshProjects() {
@@ -2354,8 +2558,8 @@ var EventHub = class {
     }, snapshotThrottleMilliseconds);
   }
   broadcast(message) {
-    const text = JSON.stringify(message);
-    for (const socket of this.sockets) if (socket.readyState === socket.OPEN) socket.send(text);
+    const text2 = JSON.stringify(message);
+    for (const socket of this.sockets) if (socket.readyState === socket.OPEN) socket.send(text2);
   }
 };
 
@@ -2445,18 +2649,18 @@ var TerminalBridge = class {
       return;
     }
     socket.on("message", (raw) => {
-      const text = raw.toString();
-      if (text.length > largestInputBytes) return;
-      const message = parseMessage(text);
+      const text2 = raw.toString();
+      if (text2.length > largestInputBytes) return;
+      const message = parseMessage(text2);
       if (message?.type === "input") attachment.write(message.data);
       if (message?.type === "resize") attachment.resize(message.columns, message.rows);
     });
     socket.on("close", () => attachment.detach());
   }
 };
-function parseMessage(text) {
+function parseMessage(text2) {
   try {
-    const message = JSON.parse(text);
+    const message = JSON.parse(text2);
     if (message.type === "input" && typeof message.data === "string") return message;
     if (message.type === "resize" && Number.isFinite(message.columns) && Number.isFinite(message.rows)) return message;
     return void 0;
@@ -2466,9 +2670,9 @@ function parseMessage(text) {
 }
 
 // src/server/projects/project-catalog.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
-import os3 from "node:os";
-import path8 from "node:path";
+import { readdir, stat as stat3 } from "node:fs/promises";
+import os4 from "node:os";
+import path9 from "node:path";
 var deepestFolderLevel = 3;
 var skippedFolders = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "vendor", "Pods", "DerivedData", "target"]);
 var refreshMilliseconds = 5 * 6e4;
@@ -2495,9 +2699,9 @@ var ProjectCatalog = class {
     const listed = (await this.list()).find((project) => project.name === nameOrPath);
     if (listed) return listed;
     if (!looksLikePath(nameOrPath)) return void 0;
-    const folder = path8.resolve(nameOrPath.replace(/^~(?=$|[\\/])/, os3.homedir()));
-    const isFolder3 = await stat2(folder).then((info) => info.isDirectory(), () => false);
-    return isFolder3 ? { name: path8.basename(folder).toLowerCase() || "root", path: folder } : void 0;
+    const folder = path9.resolve(nameOrPath.replace(/^~(?=$|[\\/])/, os4.homedir()));
+    const isFolder4 = await stat3(folder).then((info) => info.isDirectory(), () => false);
+    return isFolder4 ? { name: path9.basename(folder).toLowerCase() || "root", path: folder } : void 0;
   }
   async refresh() {
     const found = [];
@@ -2506,49 +2710,50 @@ var ProjectCatalog = class {
     this.refreshedAt = Date.now();
   }
 };
-function looksLikePath(text) {
-  return text.startsWith("~") || path8.isAbsolute(text) || text.includes("/") || text.includes("\\");
+function looksLikePath(text2) {
+  return text2.startsWith("~") || path9.isAbsolute(text2) || text2.includes("/") || text2.includes("\\");
 }
 async function collectRepositories(folder, level, found) {
   const entries = await readdir(folder, { withFileTypes: true }).catch(() => []);
   if (entries.some((entry) => entry.name === ".git")) {
-    found.push({ name: path8.basename(folder), path: folder });
+    found.push({ name: path9.basename(folder), path: folder });
     return;
   }
   if (level >= deepestFolderLevel) return;
   for (const entry of entries) {
     if (entry.name.startsWith(".") || skippedFolders.has(entry.name)) continue;
-    const childPath = path8.join(folder, entry.name);
-    const isFolder3 = entry.isDirectory() || entry.isSymbolicLink() && await stat2(childPath).then((info) => info.isDirectory(), () => false);
-    if (isFolder3) await collectRepositories(childPath, level + 1, found);
+    const childPath = path9.join(folder, entry.name);
+    const isFolder4 = entry.isDirectory() || entry.isSymbolicLink() && await stat3(childPath).then((info) => info.isDirectory(), () => false);
+    if (isFolder4) await collectRepositories(childPath, level + 1, found);
   }
 }
 function withUniqueNames(projects) {
   const seen = /* @__PURE__ */ new Set();
   return projects.map((project) => {
     const baseName = project.name.toLowerCase();
-    const name = seen.has(baseName) ? `${path8.basename(path8.dirname(project.path)).toLowerCase()}-${baseName}` : baseName;
+    const name = seen.has(baseName) ? `${path9.basename(path9.dirname(project.path)).toLowerCase()}-${baseName}` : baseName;
     seen.add(name);
     return { ...project, name };
   });
 }
 
 // src/server/safety/audit-log.ts
-import { appendFile, mkdir as mkdir5 } from "node:fs/promises";
-import path9 from "node:path";
+import { appendFile, mkdir as mkdir6 } from "node:fs/promises";
+import path10 from "node:path";
 var AuditLog = class {
   filePath;
   constructor(dataDirectory2) {
-    this.filePath = path9.join(dataDirectory2, "audit.jsonl");
+    this.filePath = path10.join(dataDirectory2, "audit.jsonl");
   }
   async record(entry) {
-    await mkdir5(path9.dirname(this.filePath), { recursive: true });
+    await mkdir6(path10.dirname(this.filePath), { recursive: true });
     await appendFile(this.filePath, `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry })}
 `, { mode: 384 });
   }
 };
 
 // src/server/sessions/session-launcher.ts
+import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { access } from "node:fs/promises";
 import { promisify } from "node:util";
@@ -2556,6 +2761,8 @@ import { promisify } from "node:util";
 // src/server/sessions/screen-reader.ts
 var trustOptionText = /Yes, I trust this folder|\bTrust (?:all )?and continue\b/;
 var hookReviewText = /Hooks need review/;
+var grokTrustText = /Do you trust the contents of this directory\?[\s\S]*Yes, proceed\s+y\b/;
+var cursorTrustText = /Do you trust the contents of this directory\?[\s\S]*\[a\] Trust this workspace[\s\S]*press the key shown/;
 var selectionMarkers = ["\u276F", "\u203A"];
 var greatestOptionDistance = 4;
 var ScreenReader = class _ScreenReader {
@@ -2564,6 +2771,8 @@ var ScreenReader = class _ScreenReader {
   }
   // Keys that select "Yes, I trust this folder" and confirm it, or undefined when the dialog is not showing.
   static trustDialogKeys(screenText) {
+    if (grokTrustText.test(screenText)) return ["y"];
+    if (cursorTrustText.test(screenText)) return ["a"];
     const lines = screenText.split("\n");
     const trustLineIndex = lines.findIndex((line) => trustOptionText.test(line));
     if (trustLineIndex === -1) return void 0;
@@ -2631,10 +2840,12 @@ var SessionLauncher = class {
       createdAt: now,
       lastSeenAt: now,
       activitySinceSeen: [],
-      waitedMillisecondsToday: 0
+      waitedMillisecondsToday: 0,
+      // Grok's hooks come from a global file; the id HeyTerm gives it is how its events find this session.
+      agentSessionId: AgentAdapters.get(agent).choosesSessionIdAtLaunch ? randomUUID() : void 0
     };
     this.registry.add(session);
-    this.launch(session, AgentAdapters.get(agent).newSession(this.launchContext(name)));
+    this.launch(session, AgentAdapters.get(agent).newSession({ ...this.launchContext(name), agentSessionId: session.agentSessionId }));
     if (task) void this.sendWhenReady(name, task);
     return session;
   }
@@ -2645,7 +2856,10 @@ var SessionLauncher = class {
     this.registry.add(session);
     const conversationSaved = closed.transcriptPath ? await fileExists(closed.transcriptPath) : closed.lastPrompt !== void 0;
     const point = { agentSessionId: closed.agentSessionId, conversationSaved };
-    this.launch(session, AgentAdapters.get(closed.agent).resume(point, this.launchContext(session.name)));
+    const adapter = AgentAdapters.get(closed.agent);
+    if (adapter.choosesSessionIdAtLaunch && !conversationSaved) this.registry.update(session.name, (current) => ({ ...current, agentSessionId: randomUUID() }));
+    const launchId = this.registry.get(session.name)?.agentSessionId;
+    this.launch(session, adapter.resume(point, { ...this.launchContext(session.name), agentSessionId: launchId }));
     return session;
   }
   async close(name) {
@@ -2666,11 +2880,11 @@ var SessionLauncher = class {
     this.registry.update(name, (session) => ({ ...session, state: session.trustSubject === "hooks" ? "idle" : "starting", stateSince: Date.now(), trustSubject: void 0 }));
     return true;
   }
-  async deliverText(name, text) {
+  async deliverText(name, text2) {
     const session = this.registry.get(name);
     if (!session || !this.host.hasSession(name)) return "failed";
     const isWorking = session.state === "working";
-    this.host.pasteText(name, text);
+    this.host.pasteText(name, text2);
     await delay(pasteSettleMilliseconds);
     const firstConfirmation = this.registry.waitForPromptSubmitted(name, promptConfirmationMilliseconds);
     this.host.pressKeys(name, ["Enter"]);
@@ -2772,15 +2986,28 @@ function delay(milliseconds) {
 }
 
 // src/server/sessions/session-registry.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { EventEmitter as EventEmitter4 } from "node:events";
+import path13 from "node:path";
+
+// src/server/sessions/agent-session-match.ts
 import path11 from "node:path";
+var AgentSessionMatch = class {
+  static find(sessions, agent, agentSessionId, workingDirectory) {
+    const ours = sessions.filter((session) => session.origin !== "external" && session.agent === agent);
+    const known = ours.find((session) => session.agentSessionId === agentSessionId);
+    if (known) return { session: known, claimsId: false };
+    const folder = path11.resolve(workingDirectory || "/");
+    const unclaimed = ours.filter((session) => !session.agentSessionId && path11.resolve(session.projectPath) === folder).sort((left, right) => right.createdAt - left.createdAt);
+    return unclaimed[0] ? { session: unclaimed[0], claimsId: true } : void 0;
+  }
+};
 
 // src/server/sessions/external-session-naming.ts
-import path10 from "node:path";
+import path12 from "node:path";
 var ExternalSessionNaming = class {
   static nameFor(facts, takenNames) {
-    const base = slug(facts.sessionTitle ?? "") || slug(path10.basename(facts.workingDirectory)) || "session";
+    const base = slug(facts.sessionTitle ?? "") || slug(path12.basename(facts.workingDirectory)) || "session";
     if (!takenNames.includes(base)) return base;
     for (let suffix = 2; ; suffix += 1) {
       const candidate = `${base}-${suffix}`;
@@ -2788,8 +3015,101 @@ var ExternalSessionNaming = class {
     }
   }
 };
-function slug(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+function slug(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+
+// src/server/agents/agent-hook-translator.ts
+var grokToolNames = {
+  run_terminal_command: "Bash",
+  search_replace: "Edit",
+  // Seen in a recorded session; the guide's alias list does not name it.
+  write: "Write",
+  read_file: "Read",
+  list_dir: "Glob",
+  grep: "Grep",
+  web_search: "WebSearch",
+  spawn_subagent: "Task",
+  ask_user_question: "AskUserQuestion"
+};
+var cursorToolNames = { Shell: "Bash", Write: "Edit", Delete: "Edit" };
+var AgentHookTranslator = class {
+  static translate(agent, eventName, payload) {
+    return agent === "grok" ? fromGrok(eventName, payload) : fromCursor(eventName, payload);
+  }
+  // What the hook prints when HeyTerm has nothing to say. Cursor reads a prompt hook's reply as a
+  // verdict, so it gets an explicit "go ahead"; everything else stays silent and the agent decides.
+  static defaultReply(agent, eventName) {
+    return agent === "cursor" && eventName === "beforeSubmitPrompt" ? '{"continue":true}' : "";
+  }
+};
+function fromGrok(eventName, payload) {
+  const agentSessionId = text(payload.session_id) || text(payload.sessionId);
+  if (!agentSessionId) return void 0;
+  const base = { session_id: agentSessionId, cwd: text(payload.cwd) || text(payload.workspaceRoot) };
+  const event = (name, extra = {}) => ({ name, agentSessionId, payload: { ...base, ...extra } });
+  switch (eventName) {
+    case "SessionStart":
+    case "SessionEnd":
+      return event(eventName);
+    case "UserPromptSubmit":
+      return event("UserPromptSubmit", { prompt: text(payload.prompt) || text(payload.userPrompt) });
+    case "PreToolUse":
+    case "PostToolUse":
+      return event(eventName, grokTool(payload));
+    case "Stop":
+      if (text(payload.reason) === "shutdown") return void 0;
+      return event("Stop", { last_assistant_message: text(payload.last_assistant_message) || text(payload.lastAssistantMessage) });
+    case "StopCancelled":
+      return event("Stop", { turn_cancelled: true });
+    case "StopFailure":
+      return event("StopFailure", { error: text(payload.error_details) || text(payload.errorDetails) || text(payload.error) });
+    case "Notification": {
+      const notificationType = text(payload.notification_type) || text(payload.notificationType);
+      return notificationType === "permission_prompt" ? event("Notification", { waits_in_terminal: true }) : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function grokTool(payload) {
+  const toolName = text(payload.tool_name) || text(payload.toolName);
+  return { tool_name: grokToolNames[toolName] ?? toolName, tool_input: record(payload.tool_input) ?? record(payload.toolInput) ?? {} };
+}
+function fromCursor(eventName, payload) {
+  const agentSessionId = text(payload.conversation_id) || text(payload.session_id);
+  if (!agentSessionId) return void 0;
+  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots.filter((root) => typeof root === "string") : [];
+  const base = { session_id: agentSessionId, cwd: roots[0] ?? text(payload.cwd) };
+  const event = (name, extra = {}) => ({ name, agentSessionId, payload: { ...base, ...extra } });
+  switch (eventName) {
+    case "sessionStart":
+      return event("SessionStart");
+    case "sessionEnd":
+      return event("SessionEnd");
+    case "beforeSubmitPrompt":
+      return event("UserPromptSubmit", { prompt: text(payload.prompt) });
+    case "postToolUse": {
+      const toolName = text(payload.tool_name);
+      return event("PostToolUse", { tool_name: cursorToolNames[toolName] ?? toolName, tool_input: record(payload.tool_input) ?? {} });
+    }
+    case "afterAgentResponse":
+      return event("Notification", { assistant_message: text(payload.text) });
+    case "stop": {
+      const status = text(payload.status);
+      if (status === "error") return event("StopFailure", { error: "the turn ended on an error" });
+      if (status === "aborted") return event("Stop", { turn_cancelled: true });
+      return event("Stop", { keep_last_message: true });
+    }
+    default:
+      return void 0;
+  }
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 
 // src/server/sessions/session-registry.ts
@@ -2852,7 +3172,7 @@ var SessionRegistry = class extends EventEmitter4 {
     this.resetWaitsOnNewDay(event.receivedAt);
     const before = this.sessions.get(event.sessionName);
     if (!before) return "";
-    const requestId = event.name === "PermissionRequest" ? randomUUID() : void 0;
+    const requestId = event.name === "PermissionRequest" ? randomUUID2() : void 0;
     const after = SessionLifecycle.apply(before, event, { requestId });
     this.set(after);
     if (before.pending && before.pending.requestId !== after.pending?.requestId) {
@@ -2861,6 +3181,18 @@ var SessionRegistry = class extends EventEmitter4 {
     if (event.name === "UserPromptSubmit") this.resolvePromptWaiters(event.sessionName);
     return requestId ? this.heldRequests.hold(requestId, event.sessionName) : "";
   }
+  // An event from Grok Build or Cursor, which run HeyTerm's hooks from a global file in every session.
+  // Only the sessions HeyTerm started move; the reply is what the hook prints.
+  async applyAgentHookEvent(agent, eventName, rawPayload, receivedAt) {
+    const defaultReply = AgentHookTranslator.defaultReply(agent, eventName);
+    const event = AgentHookTranslator.translate(agent, eventName, rawPayload);
+    if (!event) return defaultReply;
+    const found = AgentSessionMatch.find(this.list(), agent, event.agentSessionId, String(event.payload.cwd ?? ""));
+    if (!found) return defaultReply;
+    if (found.claimsId) this.set({ ...found.session, agentSessionId: event.agentSessionId });
+    const answer = await this.applyHookEvent({ name: event.name, sessionName: found.session.name, payload: event.payload, receivedAt });
+    return answer || defaultReply;
+  }
   // An event from a session the user started in their own terminal, known by its Claude session id.
   async applyExternalHookEvent(name, payload, receivedAt) {
     const agentSessionId = typeof payload.session_id === "string" ? payload.session_id : "";
@@ -2883,7 +3215,7 @@ var SessionRegistry = class extends EventEmitter4 {
       name,
       origin: "external",
       projectPath: workingDirectory,
-      projectName: path11.basename(workingDirectory) || name,
+      projectName: path13.basename(workingDirectory) || name,
       agent: "claude",
       state: "idle",
       stateSince: now,
@@ -2949,9 +3281,9 @@ function localDayKey(time) {
 }
 
 // src/server/sessions/state-store.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
-import path12 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir7, readFile as readFile5, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
+import path14 from "node:path";
 function upgraded(saved) {
   const { claudeSessionId, ...session } = saved;
   return { ...session, agent: session.agent ?? "claude", agentSessionId: session.agentSessionId ?? claudeSessionId };
@@ -2959,13 +3291,13 @@ function upgraded(saved) {
 var StateStore = class {
   filePath;
   constructor(dataDirectory2) {
-    this.filePath = path12.join(dataDirectory2, "state.json");
+    this.filePath = path14.join(dataDirectory2, "state.json");
   }
   async load() {
-    const text = await readFile4(this.filePath, "utf8").catch(() => "");
-    if (!text) return { sessions: [], recentlyClosed: [] };
+    const text2 = await readFile5(this.filePath, "utf8").catch(() => "");
+    if (!text2) return { sessions: [], recentlyClosed: [] };
     try {
-      const parsed = JSON.parse(text);
+      const parsed = JSON.parse(text2);
       return { sessions: (parsed.sessions ?? []).map(upgraded), recentlyClosed: (parsed.recentlyClosed ?? []).map(upgraded) };
     } catch {
       return { sessions: [], recentlyClosed: [] };
@@ -2980,10 +3312,10 @@ var StateStore = class {
   }
   saving = Promise.resolve();
   async write(state) {
-    await mkdir6(path12.dirname(this.filePath), { recursive: true });
-    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID2()}.tmp`;
-    await writeFile4(temporaryPath, JSON.stringify(state), { mode: 384 });
-    await rename3(temporaryPath, this.filePath);
+    await mkdir7(path14.dirname(this.filePath), { recursive: true });
+    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID3()}.tmp`;
+    await writeFile5(temporaryPath, JSON.stringify(state), { mode: 384 });
+    await rename4(temporaryPath, this.filePath);
   }
 };
 
@@ -3023,9 +3355,9 @@ var TrustDialogWatcher = class {
 
 // src/server/setup/setup-service.ts
 import { execFile as execFile2 } from "node:child_process";
-import { stat as stat3 } from "node:fs/promises";
-import os4 from "node:os";
-import path13 from "node:path";
+import { stat as stat4 } from "node:fs/promises";
+import os5 from "node:os";
+import path15 from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
 var testedClaudeVersion = "2.1.310";
@@ -3074,7 +3406,7 @@ var SetupService = class {
   async setProjectRoots(roots) {
     const expanded = roots.map((root) => root.trim()).filter(Boolean).map(expandHome);
     const existing = [];
-    for (const root of expanded) if (await isFolder2(root)) existing.push(root);
+    for (const root of expanded) if (await isFolder3(root)) existing.push(root);
     await this.userConfig.update({ projectRoots: existing });
     await this.projects.setRoots(existing);
     return expanded.filter((root) => !existing.includes(root));
@@ -3105,38 +3437,38 @@ function compareVersions(left, right) {
   return 0;
 }
 function expandHome(folder) {
-  return folder === "~" || folder.startsWith("~/") ? path13.join(os4.homedir(), folder.slice(1)) : path13.resolve(folder);
+  return folder === "~" || folder.startsWith("~/") ? path15.join(os5.homedir(), folder.slice(1)) : path15.resolve(folder);
 }
-async function isFolder2(folder) {
-  return stat3(folder).then((info) => info.isDirectory(), () => false);
+async function isFolder3(folder) {
+  return stat4(folder).then((info) => info.isDirectory(), () => false);
 }
 
 // src/server/setup/input-log.ts
-import { appendFile as appendFile2, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
-import path14 from "node:path";
+import { appendFile as appendFile2, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
+import path16 from "node:path";
 var keptLines = 1e3;
 var InputLog = class {
   filePath;
   writing = Promise.resolve();
   constructor(dataDirectory2) {
-    this.filePath = path14.join(dataDirectory2, "input-log.jsonl");
+    this.filePath = path16.join(dataDirectory2, "input-log.jsonl");
   }
   record(records) {
-    const safe = records.slice(0, 500).map((record) => JSON.stringify(withoutText(record))).join("\n");
+    const safe = records.slice(0, 500).map((record2) => JSON.stringify(withoutText(record2))).join("\n");
     if (!safe) return;
     this.writing = this.writing.then(async () => {
       await appendFile2(this.filePath, `${safe}
 `, { mode: 384 });
-      const lines = (await readFile5(this.filePath, "utf8")).split("\n").filter(Boolean);
-      if (lines.length > keptLines * 2) await writeFile5(this.filePath, `${lines.slice(-keptLines).join("\n")}
+      const lines = (await readFile6(this.filePath, "utf8")).split("\n").filter(Boolean);
+      if (lines.length > keptLines * 2) await writeFile6(this.filePath, `${lines.slice(-keptLines).join("\n")}
 `, { mode: 384 });
     }).catch(() => void 0);
   }
 };
-function withoutText(record) {
+function withoutText(record2) {
   const kept = {};
   for (const key of ["at", "type", "inputType", "length", "key", "target", "windowHasFocus"]) {
-    const value = record[key];
+    const value = record2[key];
     if (typeof value === "number" || typeof value === "boolean" || typeof value === "string" && value.length <= 40) kept[key] = value;
   }
   return kept;
@@ -3160,7 +3492,10 @@ var keySequences = {
   Up: "\x1B[A",
   Down: "\x1B[B",
   Right: "\x1B[C",
-  Left: "\x1B[D"
+  Left: "\x1B[D",
+  // Grok Build's and Cursor's dialogs answer to a letter.
+  y: "y",
+  a: "a"
 };
 var pasteStart = "\x1B[200~";
 var pasteEnd = "\x1B[201~";
@@ -3174,8 +3509,8 @@ var TerminalInput = class {
   }
   // Dictated text as the program would get it from a real paste. Control characters are dropped,
   // so text can never press keys; without bracketed paste, line breaks become spaces.
-  static paste(text, { bracketedPaste }) {
-    const withoutMarkers = text.replaceAll(pasteStart, "").replaceAll(pasteEnd, "");
+  static paste(text2, { bracketedPaste }) {
+    const withoutMarkers = text2.replaceAll(pasteStart, "").replaceAll(pasteEnd, "");
     const lines = withoutMarkers.split(/\r\n|\r|\n/).map((line) => line.replace(/[\x00-\x1f\x7f]/g, ""));
     if (!bracketedPaste) return lines.join(" ");
     return `${pasteStart}${lines.join("\r")}${pasteEnd}`;
@@ -3229,10 +3564,10 @@ var TerminalHost = class extends EventEmitter5 {
     killQuietly(hosted.process);
   }
   // Text as one paste, so line breaks and symbols arrive as text, never as key presses.
-  pasteText(name, text) {
+  pasteText(name, text2) {
     const hosted = this.terminals.get(name);
     if (!hosted) return;
-    hosted.process.write(TerminalInput.paste(text, { bracketedPaste: hosted.screen.modes.bracketedPasteMode }));
+    hosted.process.write(TerminalInput.paste(text2, { bracketedPaste: hosted.screen.modes.bracketedPasteMode }));
   }
   pressKeys(name, keys) {
     this.terminals.get(name)?.process.write(TerminalInput.keys(keys));
@@ -3310,15 +3645,15 @@ var MacVoice = class {
   available = process.platform === "darwin";
   speaking;
   deduplicator = new SpokenLineDeduplicator(duplicateWindowMilliseconds);
-  speak(text, done) {
-    if (!this.available || !text.trim() || !this.deduplicator.shouldSpeak(text, Date.now())) return done();
+  speak(text2, done) {
+    if (!this.available || !text2.trim() || !this.deduplicator.shouldSpeak(text2, Date.now())) return done();
     this.stop();
     const child = spawn("say", ["-f", "-"], { stdio: ["pipe", "ignore", "ignore"] });
     const line = { child, done };
     child.on("error", () => this.finish(line));
     child.on("exit", () => this.finish(line));
     child.stdin.on("error", () => void 0);
-    child.stdin.end(text);
+    child.stdin.end(text2);
     this.speaking = line;
   }
   stop() {
@@ -3339,8 +3674,8 @@ var SpokenLineDeduplicator = class {
   }
   windowMilliseconds;
   lastSaidAt = /* @__PURE__ */ new Map();
-  shouldSpeak(text, now) {
-    const key = text.trim();
+  shouldSpeak(text2, now) {
+    const key = text2.trim();
     const last = this.lastSaidAt.get(key);
     for (const [line, at] of this.lastSaidAt) if (now - at > this.windowMilliseconds) this.lastSaidAt.delete(line);
     if (last !== void 0 && now - last <= this.windowMilliseconds) return false;
@@ -3359,6 +3694,8 @@ async function startHeyTerm() {
   const userConfig = new UserConfig(config.dataDirectory);
   const savedChoices = await userConfig.load();
   const hooks = await new HookInstaller(config.dataDirectory, config.port).install();
+  const agentHookFiles = new AgentHookFiles(hooks.forwardScriptPath, path17.join(config.dataDirectory, "backups"));
+  await agentHookFiles.install().catch((error) => console.error(`Could not add HeyTerm's Grok and Cursor hooks: ${error.message}`));
   await stopSessionsFromOlderVersion(config.tmuxSocketName);
   const host = new TerminalHost();
   const heldRequests = new HeldHookRequests();
@@ -3375,12 +3712,12 @@ async function startHeyTerm() {
   const decisions = new DecisionActions(registry, heldRequests, audit);
   const sessionActions = new SessionActions(registry, launcher, projects, audit);
   const executor = new ActionExecutor(registry, projects, new FastPathRouter({ sendUnaddressedWordsToFocusedSession: false }), decisions, sessionActions);
-  const assistant = createAssistant({ model: config.routerModel, workingDirectory: os5.homedir(), registry, launcher, projects, sessionActions, decisions, executor, audit });
+  const assistant = createAssistant({ model: config.routerModel, workingDirectory: os6.homedir(), registry, launcher, projects, sessionActions, decisions, executor, audit });
   executor.attachAssistant(assistant);
   executor.on("feedback", (feedback) => assistant.recordOutcome(feedback.text));
   registry.on("changed", () => assistant.noteSessions(registry.list()));
   assistant.noteSessions(registry.list());
-  const connector = new ExistingSessionConnector(hooks.forwardScriptPath, path15.join(config.dataDirectory, "backups"));
+  const connector = new ExistingSessionConnector(hooks.forwardScriptPath, path17.join(config.dataDirectory, "backups"));
   const showOwnTerminalSessions = savedChoices.showOwnTerminalSessions ?? await connector.isConnected();
   if (savedChoices.showOwnTerminalSessions === void 0 && showOwnTerminalSessions) await userConfig.update({ showOwnTerminalSessions });
   if (showOwnTerminalSessions) await connector.connect().catch((error) => console.error(error.message));
@@ -3402,6 +3739,7 @@ Stopping HeyTerm (${reason}).`);
       assistant.close();
       launcher.shutdown();
       if ((await userConfig.load()).showOwnTerminalSessions) await connector.disconnect().catch(() => void 0);
+      await agentHookFiles.remove().catch(() => void 0);
       await registry.saveNow().catch(() => void 0);
       await server.close();
       console.log("HeyTerm stopped. Its sessions are under Recently closed next time.");
@@ -3440,30 +3778,30 @@ async function stopSessionsFromOlderVersion(tmuxSocketName) {
 
 // src/server/setup/trash.ts
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir7, rename as rename4, stat as stat4, writeFile as writeFile6 } from "node:fs/promises";
-import os6 from "node:os";
-import path16 from "node:path";
+import { mkdir as mkdir8, rename as rename5, stat as stat5, writeFile as writeFile7 } from "node:fs/promises";
+import os7 from "node:os";
+import path18 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 async function moveToTrash(target) {
-  if (process.platform === "darwin") return moveIntoFolder(target, path16.join(os6.homedir(), ".Trash"));
+  if (process.platform === "darwin") return moveIntoFolder(target, path18.join(os7.homedir(), ".Trash"));
   if (process.platform === "win32") return moveToRecycleBin(target);
   return moveToFreedesktopTrash(target);
 }
 async function moveIntoFolder(target, trashFolder) {
-  await rename4(target, await freeName(trashFolder, path16.basename(target)));
+  await rename5(target, await freeName(trashFolder, path18.basename(target)));
 }
 async function moveToFreedesktopTrash(target) {
-  const trashHome = path16.join(process.env.XDG_DATA_HOME ?? path16.join(os6.homedir(), ".local", "share"), "Trash");
-  await mkdir7(path16.join(trashHome, "files"), { recursive: true });
-  await mkdir7(path16.join(trashHome, "info"), { recursive: true });
-  const destination = await freeName(path16.join(trashHome, "files"), path16.basename(target));
+  const trashHome = path18.join(process.env.XDG_DATA_HOME ?? path18.join(os7.homedir(), ".local", "share"), "Trash");
+  await mkdir8(path18.join(trashHome, "files"), { recursive: true });
+  await mkdir8(path18.join(trashHome, "info"), { recursive: true });
+  const destination = await freeName(path18.join(trashHome, "files"), path18.basename(target));
   const info = `[Trash Info]
 Path=${encodeURI(target)}
 DeletionDate=${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19)}
 `;
-  await writeFile6(path16.join(trashHome, "info", `${path16.basename(destination)}.trashinfo`), info);
-  await rename4(target, destination);
+  await writeFile7(path18.join(trashHome, "info", `${path18.basename(destination)}.trashinfo`), info);
+  await rename5(target, destination);
 }
 async function moveToRecycleBin(target) {
   const quoted2 = target.replaceAll("'", "''");
@@ -3471,19 +3809,19 @@ async function moveToRecycleBin(target) {
   await execFileAsync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 3e4 });
 }
 async function freeName(folder, name) {
-  let candidate = path16.join(folder, name);
-  for (let number = 2; await exists2(candidate); number += 1) candidate = path16.join(folder, `${name} ${number}`);
+  let candidate = path18.join(folder, name);
+  for (let number = 2; await exists2(candidate); number += 1) candidate = path18.join(folder, `${name} ${number}`);
   return candidate;
 }
 async function exists2(target) {
-  return stat4(target).then(
+  return stat5(target).then(
     () => true,
     () => false
   );
 }
 
 // src/server/setup/uninstaller.ts
-import { readFile as readFile6, rename as rename5, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile7, rename as rename6, writeFile as writeFile8 } from "node:fs/promises";
 var Uninstaller = class {
   constructor(options) {
     this.options = options;
@@ -3491,6 +3829,7 @@ var Uninstaller = class {
   options;
   async run() {
     const removedHooks = await this.removeHooks();
+    await new AgentHookFiles("", "", this.options.agentHookPaths ?? agentHookPaths()).remove().catch(() => void 0);
     const report = { removedHooks, trashed: [], leftBehind: [] };
     try {
       await this.options.moveToTrash(this.options.dataDirectory);
@@ -3501,19 +3840,19 @@ var Uninstaller = class {
     return report;
   }
   async removeHooks() {
-    const text = await readFile6(this.options.claudeSettingsPath, "utf8").catch(() => void 0);
-    if (text === void 0) return false;
+    const text2 = await readFile7(this.options.claudeSettingsPath, "utf8").catch(() => void 0);
+    if (text2 === void 0) return false;
     let settings;
     try {
-      settings = JSON.parse(text || "{}");
+      settings = JSON.parse(text2 || "{}");
     } catch {
       return false;
     }
     if (!UserSettingsHooks.isConnected(settings)) return false;
     const temporaryPath = `${this.options.claudeSettingsPath}.heyterm.tmp`;
-    await writeFile7(temporaryPath, `${JSON.stringify(UserSettingsHooks.withoutHeyTerm(settings), null, 2)}
+    await writeFile8(temporaryPath, `${JSON.stringify(UserSettingsHooks.withoutHeyTerm(settings), null, 2)}
 `);
-    await rename5(temporaryPath, this.options.claudeSettingsPath);
+    await rename6(temporaryPath, this.options.claudeSettingsPath);
     return true;
   }
 };
@@ -3616,12 +3955,12 @@ function baseUrl() {
   return `http://127.0.0.1:${process.env.HEYTERM_PORT ?? 4747}`;
 }
 function dataDirectory() {
-  return process.env.HEYTERM_DATA_DIRECTORY ?? path17.join(os7.homedir(), ".heyterm");
+  return process.env.HEYTERM_DATA_DIRECTORY ?? path19.join(os8.homedir(), ".heyterm");
 }
 async function readToken() {
-  const folders = [dataDirectory(), path17.join(os7.homedir(), ".callsign")];
+  const folders = [dataDirectory(), path19.join(os8.homedir(), ".callsign")];
   for (const folder of folders) {
-    const token = (await readFile7(path17.join(folder, "token"), "utf8").catch(() => "")).trim();
+    const token = (await readFile8(path19.join(folder, "token"), "utf8").catch(() => "")).trim();
     if (token) return token;
   }
   return void 0;