@higherdev/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -1216,8 +1216,8 @@ function toolDetail(payload) {
   const command = str(input.command || input.cmd);
   const additions = Number(input.additions ?? input.added);
   const deletions = Number(input.deletions ?? input.removed);
-  const stat = Number.isFinite(additions) || Number.isFinite(deletions) ? ` +${Number.isFinite(additions) ? additions : 0}/-${Number.isFinite(deletions) ? deletions : 0}` : "";
-  if (file) return `${file}${stat}`;
+  const stat2 = Number.isFinite(additions) || Number.isFinite(deletions) ? ` +${Number.isFinite(additions) ? additions : 0}/-${Number.isFinite(deletions) ? deletions : 0}` : "";
+  if (file) return `${file}${stat2}`;
   if (command) return command.length > 80 ? `${command.slice(0, 77)}...` : command;
   return "";
 }
@@ -1519,6 +1519,119 @@ var init_theme = __esm({
   }
 });
 
+// src/architect/connection.ts
+var connection_exports = {};
+__export(connection_exports, {
+  classifyAuthFile: () => classifyAuthFile,
+  codexConnection: () => codexConnection,
+  codexHome: () => codexHome,
+  connectCodex: () => connectCodex,
+  connectionSummary: () => connectionSummary,
+  howToFix: () => howToFix,
+  onPath: () => onPath
+});
+import { execFile, spawn } from "child_process";
+import { access, readFile as readFile2 } from "fs/promises";
+import { constants } from "fs";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+import { promisify } from "util";
+function codexHome(env = process.env) {
+  return env.CODEX_HOME ?? path2.join(homedir2(), ".codex");
+}
+function classifyAuthFile(auth) {
+  if (!auth) return null;
+  const apiKey = typeof auth.OPENAI_API_KEY === "string" ? auth.OPENAI_API_KEY.trim() : "";
+  if (apiKey) {
+    return {
+      state: "api_key",
+      detail: "Codex is signed in with an API key, which bills per token."
+    };
+  }
+  const refresh = auth.tokens?.refresh_token;
+  if (auth.auth_mode === "chatgpt" && typeof refresh === "string" && refresh.length > 0) {
+    const accountId = typeof auth.tokens?.account_id === "string" ? auth.tokens.account_id : null;
+    return { state: "connected", accountId, detail: "Codex is connected to a ChatGPT subscription." };
+  }
+  return { state: "signed_out", detail: "Codex is installed but not signed in." };
+}
+async function onPath(bin, env = process.env) {
+  const dirs = (env.PATH ?? "").split(path2.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    try {
+      await access(path2.join(dir, bin), constants.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function codexConnection(env = process.env) {
+  if (!await onPath("codex")) {
+    return {
+      state: "not_installed",
+      detail: "The Codex CLI is not on PATH. Install it, then run `hd connect`."
+    };
+  }
+  let auth = null;
+  try {
+    auth = JSON.parse(await readFile2(path2.join(codexHome(env), "auth.json"), "utf8"));
+  } catch {
+    auth = null;
+  }
+  const fromFile = classifyAuthFile(auth);
+  if (fromFile) return fromFile;
+  try {
+    const { stdout } = await run("codex", ["login", "status"], { timeout: 2e4 });
+    const text = stdout.trim();
+    if (/chatgpt/i.test(text)) {
+      return { state: "connected", accountId: null, detail: text };
+    }
+    if (/api key/i.test(text)) {
+      return { state: "api_key", detail: text };
+    }
+    return { state: "signed_out", detail: text || "Codex is not signed in." };
+  } catch {
+    return { state: "signed_out", detail: "Codex is installed but not signed in." };
+  }
+}
+function connectionSummary(connection) {
+  switch (connection.state) {
+    case "connected":
+      return connection.accountId ? `${connection.detail} Account ${connection.accountId}.` : connection.detail;
+    default:
+      return connection.detail;
+  }
+}
+function howToFix(connection) {
+  switch (connection.state) {
+    case "connected":
+      return null;
+    case "not_installed":
+      return "Install the Codex CLI, then run `hd connect`.";
+    case "api_key":
+      return "Run `codex logout` then `hd connect` to sign in with the subscription instead.";
+    default:
+      return "Run `hd connect` to sign in through ChatGPT.";
+  }
+}
+async function connectCodex() {
+  const code = await new Promise((resolve, reject) => {
+    const child = spawn("codex", ["login"], { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (status) => resolve(status ?? 1));
+  });
+  if (code !== 0) throw new Error(`codex login exited ${code}`);
+  return codexConnection();
+}
+var run;
+var init_connection = __esm({
+  "src/architect/connection.ts"() {
+    "use strict";
+    run = promisify(execFile);
+  }
+});
+
 // src/read/queries.ts
 function unwrap(result) {
   if (result.error) fail(result.error.message);
@@ -1803,53 +1916,289 @@ var init_subscribe = __esm({
   }
 });
 
-// ../runner/src/providers.ts
-import { execFile as execFile2, execFileSync } from "child_process";
-import { promisify as promisify2 } from "util";
-function isOnPath(bin) {
+// src/architect/chatgpt.ts
+var chatgpt_exports = {};
+__export(chatgpt_exports, {
+  ChatGptAuthError: () => ChatGptAuthError,
+  MAX_STEPS: () => MAX_STEPS,
+  getAuth: () => getAuth,
+  mergeRefreshed: () => mergeRefreshed,
+  msUntilExpiry: () => msUntilExpiry,
+  newSessionId: () => newSessionId,
+  runAgent: () => runAgent
+});
+import { readFileSync, renameSync, writeFileSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import path4 from "path";
+function readAuthFile() {
+  let raw;
   try {
-    execFileSync("which", [bin], { stdio: "ignore" });
-    return true;
+    raw = readFileSync(authPath(), "utf8");
   } catch {
-    return false;
+    throw new ChatGptAuthError(
+      "No ChatGPT session found. Install the Codex CLI (npm i -g @openai/codex), then run `hd connect`."
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ChatGptAuthError(`${authPath()} is unreadable. Run \`hd connect\`.`);
   }
 }
-function detectProviders() {
-  const found = [];
-  for (const [provider, bin] of Object.entries(PROVIDER_BINS)) {
-    if (isOnPath(bin)) found.push(provider);
+function msUntilExpiry(jwt, now = Date.now()) {
+  try {
+    const payload = jwt.split(".")[1];
+    if (!payload) return Number.POSITIVE_INFINITY;
+    const claims = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    if (typeof claims.exp !== "number") return Number.POSITIVE_INFINITY;
+    return claims.exp * 1e3 - now;
+  } catch {
+    return Number.POSITIVE_INFINITY;
   }
-  return found;
 }
-async function captureCli(bin, args, timeoutMs = MODEL_DISCOVER_TIMEOUT_MS) {
+function mergeRefreshed(file, body, at = /* @__PURE__ */ new Date()) {
+  return {
+    ...file,
+    tokens: {
+      ...file.tokens,
+      access_token: body.access_token,
+      // Refreshing rotates this. Dropping the new value would leave both this
+      // CLI and `codex login` holding a token the server has retired.
+      ...body.refresh_token ? { refresh_token: body.refresh_token } : {},
+      ...body.id_token ? { id_token: body.id_token } : {}
+    },
+    last_refresh: at.toISOString()
+  };
+}
+async function refreshSession(file) {
+  const refresh = file.tokens?.refresh_token;
+  if (!refresh) throw new ChatGptAuthError("Your ChatGPT session has expired. Run `hd connect`.");
+  let res;
   try {
-    const { stdout, stderr } = await execFileAsync(bin, args, {
-      encoding: "utf8",
-      timeout: timeoutMs,
-      maxBuffer: 512 * 1024
+    res = await fetch(TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: refresh,
+        client_id: CLIENT_ID,
+        scope: "openid profile email"
+      })
     });
-    return [stdout, stderr].filter(Boolean).join("\n");
-  } catch (error) {
-    if (error && typeof error === "object") {
-      const err = error;
-      const text = [err.stdout, err.stderr].filter(Boolean).join("\n").trim();
-      if (text) return text;
+  } catch {
+    throw new ChatGptAuthError("Could not reach OpenAI to renew your ChatGPT session.");
+  }
+  if (!res.ok) throw new ChatGptAuthError("Your ChatGPT session could not be renewed. Run `hd connect`.");
+  const body = await res.json();
+  if (!body.access_token) {
+    throw new ChatGptAuthError("Your ChatGPT session could not be renewed. Run `hd connect`.");
+  }
+  const merged = mergeRefreshed(file, body);
+  const target = authPath();
+  const tmp = `${target}.hd.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify(merged, null, 2)}
+`, { mode: 384 });
+    renameSync(tmp, target);
+  } catch {
+  }
+  return merged;
+}
+async function getAuth(force = false) {
+  let file = readAuthFile();
+  const accessToken = file.tokens?.access_token;
+  const accountId = file.tokens?.account_id;
+  if (!accessToken || !accountId) {
+    throw new ChatGptAuthError("No ChatGPT subscription token found. Run `hd connect`.");
+  }
+  if (force || msUntilExpiry(accessToken) < RENEW_BEFORE_MS) {
+    file = await refreshSession(file);
+  }
+  return {
+    accessToken: file.tokens?.access_token ?? accessToken,
+    accountId: file.tokens?.account_id ?? accountId
+  };
+}
+async function streamTurn(opts) {
+  const res = await fetch(ENDPOINT, {
+    method: "POST",
+    signal: opts.signal,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${opts.auth.accessToken}`,
+      "chatgpt-account-id": opts.auth.accountId,
+      "OpenAI-Beta": "responses=experimental",
+      originator: "codex_cli_rs",
+      session_id: opts.sessionId,
+      Accept: "text/event-stream"
+    },
+    body: JSON.stringify({
+      model: opts.model,
+      instructions: opts.instructions,
+      input: opts.input,
+      tools: opts.tools.map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        strict: false,
+        parameters: tool.parameters ?? { type: "object", properties: {} }
+      })),
+      tool_choice: "auto",
+      parallel_tool_calls: false,
+      store: false,
+      stream: true
+    })
+  });
+  if (res.status === 401 || res.status === 403) {
+    throw new ChatGptAuthError("ChatGPT rejected the session. Run `hd connect`.");
+  }
+  if (!res.ok) {
+    const body = (await res.text().catch(() => "")).slice(0, 300);
+    throw new Error(`ChatGPT request failed (${res.status}): ${body || res.statusText}`);
+  }
+  if (!res.body) throw new Error("ChatGPT returned no body.");
+  const out2 = { text: "", calls: [], usage: null };
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") continue;
+      let event;
+      try {
+        event = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      if (event.type === "response.output_text.delta" && event.delta) {
+        out2.text += event.delta;
+        opts.onText?.(event.delta);
+      } else if (event.type === "response.output_item.done" && event.item?.type === "function_call") {
+        out2.calls.push({
+          name: String(event.item.name ?? ""),
+          arguments: String(event.item.arguments ?? "{}"),
+          call_id: String(event.item.call_id ?? "")
+        });
+      } else if (event.type === "response.completed" && event.response?.usage) {
+        out2.usage = event.response.usage;
+      } else if (event.type === "response.failed") {
+        throw new Error(event.response?.error?.message ?? "ChatGPT reported a failed response.");
+      }
     }
-    return "";
   }
+  return out2;
 }
-var execFileAsync, PROVIDER_BINS, MODEL_DISCOVER_TIMEOUT_MS;
-var init_providers = __esm({
-  "../runner/src/providers.ts"() {
+async function runAgent(opts) {
+  let auth = await getAuth();
+  const byName = new Map(opts.tools.map((tool) => [tool.name, tool]));
+  const specs = opts.tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+  const input = [];
+  for (const message of opts.history.slice(-20)) {
+    input.push({
+      type: "message",
+      role: message.role,
+      content: [
+        { type: message.role === "user" ? "input_text" : "output_text", text: message.content }
+      ]
+    });
+  }
+  input.push({ type: "message", role: "user", content: [{ type: "input_text", text: opts.prompt }] });
+  let text = "";
+  let usage = null;
+  let renewed = false;
+  let toolCalls = 0;
+  let step = 0;
+  const maxSteps = opts.maxSteps ?? MAX_STEPS;
+  for (; step < maxSteps; step += 1) {
+    let turn;
+    const send = () => streamTurn({
+      auth,
+      sessionId: opts.sessionId,
+      model: opts.model,
+      instructions: opts.instructions,
+      input,
+      tools: specs,
+      onText: (delta) => opts.onEvent?.({ kind: "text", delta }),
+      signal: opts.signal
+    });
+    try {
+      turn = await send();
+    } catch (error) {
+      if (error instanceof ChatGptAuthError && !renewed) {
+        renewed = true;
+        auth = await getAuth(true);
+        turn = await send();
+      } else {
+        throw error;
+      }
+    }
+    if (turn.usage) usage = turn.usage;
+    if (turn.text) text = turn.text;
+    if (turn.calls.length === 0) break;
+    for (const call of turn.calls) {
+      toolCalls += 1;
+      let args = {};
+      try {
+        args = JSON.parse(call.arguments || "{}");
+      } catch {
+      }
+      opts.onEvent?.({ kind: "tool", name: call.name, args });
+      const tool = byName.get(call.name);
+      let output;
+      let ok2 = true;
+      if (!tool) {
+        ok2 = false;
+        output = `Error: no tool named ${call.name}.`;
+      } else {
+        try {
+          const result = await tool.run(args);
+          output = typeof result === "string" ? result : JSON.stringify(result ?? null);
+          if (!output) output = "(no result)";
+        } catch (error) {
+          ok2 = false;
+          output = `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      }
+      opts.onEvent?.({ kind: "tool_result", name: call.name, ok: ok2, detail: output.slice(0, 200) });
+      input.push({
+        type: "function_call",
+        name: call.name,
+        arguments: call.arguments,
+        call_id: call.call_id
+      });
+      input.push({ type: "function_call_output", call_id: call.call_id, output });
+    }
+  }
+  return { text: text.trim(), usage, steps: step + 1, toolCalls };
+}
+function newSessionId() {
+  return randomUUID2();
+}
+var ChatGptAuthError, ENDPOINT, TOKEN_ENDPOINT, CLIENT_ID, RENEW_BEFORE_MS, authPath, MAX_STEPS;
+var init_chatgpt = __esm({
+  "src/architect/chatgpt.ts"() {
     "use strict";
-    execFileAsync = promisify2(execFile2);
-    PROVIDER_BINS = {
-      claude: "claude",
-      codex: "codex",
-      gemini: "agy",
-      grok: "grok"
+    init_connection();
+    ChatGptAuthError = class extends Error {
     };
-    MODEL_DISCOVER_TIMEOUT_MS = 2e3;
+    ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+    TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
+    CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+    RENEW_BEFORE_MS = 60 * 60 * 1e3;
+    authPath = () => path4.join(codexHome(), "auth.json");
+    MAX_STEPS = 16;
   }
 });
 
@@ -2061,6 +2410,56 @@ var init_App = __esm({
   }
 });
 
+// ../runner/src/providers.ts
+import { execFile as execFile3, execFileSync } from "child_process";
+import { promisify as promisify3 } from "util";
+function isOnPath(bin) {
+  try {
+    execFileSync("which", [bin], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectProviders() {
+  const found = [];
+  for (const [provider, bin] of Object.entries(PROVIDER_BINS)) {
+    if (isOnPath(bin)) found.push(provider);
+  }
+  return found;
+}
+async function captureCli(bin, args, timeoutMs = MODEL_DISCOVER_TIMEOUT_MS) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      maxBuffer: 512 * 1024
+    });
+    return [stdout, stderr].filter(Boolean).join("\n");
+  } catch (error) {
+    if (error && typeof error === "object") {
+      const err = error;
+      const text = [err.stdout, err.stderr].filter(Boolean).join("\n").trim();
+      if (text) return text;
+    }
+    return "";
+  }
+}
+var execFileAsync, PROVIDER_BINS, MODEL_DISCOVER_TIMEOUT_MS;
+var init_providers = __esm({
+  "../runner/src/providers.ts"() {
+    "use strict";
+    execFileAsync = promisify3(execFile3);
+    PROVIDER_BINS = {
+      claude: "claude",
+      codex: "codex",
+      gemini: "agy",
+      grok: "grok"
+    };
+    MODEL_DISCOVER_TIMEOUT_MS = 2e3;
+  }
+});
+
 // ../runner/src/auth-check.ts
 function firstLine(text) {
   const line = text.split(/\r?\n/).map((row) => row.trim()).find(Boolean);
@@ -2268,8 +2667,8 @@ __export(init_exports, {
   parseInitArgs: () => parseInitArgs
 });
 import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir5, hostname, tmpdir as tmpdir2 } from "os";
-import path6 from "path";
+import { homedir as homedir4, hostname, tmpdir as tmpdir2 } from "os";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -2334,7 +2733,7 @@ function xmlEscape(value) {
 }
 function launchdPlist(opts) {
   const label = opts.label ?? LAUNCHD_LABEL;
-  const program = path6.join(opts.repoRoot, "deploy/run-runner.sh");
+  const program = path7.join(opts.repoRoot, "deploy/run-runner.sh");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -2365,16 +2764,16 @@ function launchdPlist(opts) {
 `;
 }
 function defaultRepoRoot(fromFile = fileURLToPath(import.meta.url)) {
-  return path6.resolve(path6.dirname(fromFile), "../../..");
+  return path7.resolve(path7.dirname(fromFile), "../../..");
 }
 async function initHost(flags, deps = {}) {
   const env = deps.env ?? process.env;
   const platform = deps.platform ?? process.platform;
-  const home = (deps.homedir ?? homedir5)();
+  const home = (deps.homedir ?? homedir4)();
   const repoRoot = defaultRepoRoot();
   const host = flags.host || env.RUNNER_HOST || (deps.hostname ?? hostname)().replace(/\..*$/, "").toLowerCase();
-  const envFile = flags.envFile || path6.join(repoRoot, "apps/runner/.env");
-  const worktreeRoot = flags.worktreeRoot || env.WORKTREE_ROOT || path6.join(home, "higherdev-worktrees");
+  const envFile = flags.envFile || path7.join(repoRoot, "apps/runner/.env");
+  const worktreeRoot = flags.worktreeRoot || env.WORKTREE_ROOT || path7.join(home, "higherdev-worktrees");
   const steps = [
     "Write the runner env file",
     "Register the host",
@@ -2400,13 +2799,13 @@ async function initHost(flags, deps = {}) {
     RUNNER_STOP_TIMEOUT_MS: existing.RUNNER_STOP_TIMEOUT_MS || "90000"
   });
   if (!flags.dryRun) {
-    await ensureDir(path6.dirname(envFile), { recursive: true });
+    await ensureDir(path7.dirname(envFile), { recursive: true });
     await write(envFile, formatEnvFile(merged), "utf8");
   }
-  const plistPath = flags.plistOut || (flags.installLaunchd && !flags.dryRun && platform === "darwin" ? path6.join(home, "Library/LaunchAgents", `${LAUNCHD_LABEL}.plist`) : path6.join((deps.tmpdir ?? tmpdir2)(), "higherdev-runner.plist"));
-  const logPath = path6.join(home, "Library/Logs/higherdev-runner.log");
+  const plistPath = flags.plistOut || (flags.installLaunchd && !flags.dryRun && platform === "darwin" ? path7.join(home, "Library/LaunchAgents", `${LAUNCHD_LABEL}.plist`) : path7.join((deps.tmpdir ?? tmpdir2)(), "higherdev-runner.plist"));
+  const logPath = path7.join(home, "Library/Logs/higherdev-runner.log");
   const plist = launchdPlist({ repoRoot, envFile, logPath });
-  await ensureDir(path6.dirname(plistPath), { recursive: true });
+  await ensureDir(path7.dirname(plistPath), { recursive: true });
   await write(plistPath, plist, "utf8");
   let launchdInstalled = false;
   if (flags.installLaunchd && !flags.dryRun && platform === "darwin") {
@@ -2720,105 +3119,7 @@ Run \`hd use <slug>\` or pass --workspace.`
 // src/auth.ts
 init_theme();
 init_json();
-
-// src/architect/connection.ts
-import { execFile, spawn } from "child_process";
-import { access, readFile as readFile2 } from "fs/promises";
-import { constants } from "fs";
-import { homedir as homedir2 } from "os";
-import path2 from "path";
-import { promisify } from "util";
-var run = promisify(execFile);
-function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path2.join(homedir2(), ".codex");
-}
-function classifyAuthFile(auth) {
-  if (!auth) return null;
-  const apiKey = typeof auth.OPENAI_API_KEY === "string" ? auth.OPENAI_API_KEY.trim() : "";
-  if (apiKey) {
-    return {
-      state: "api_key",
-      detail: "Codex is signed in with an API key, which bills per token."
-    };
-  }
-  const refresh = auth.tokens?.refresh_token;
-  if (auth.auth_mode === "chatgpt" && typeof refresh === "string" && refresh.length > 0) {
-    const accountId = typeof auth.tokens?.account_id === "string" ? auth.tokens.account_id : null;
-    return { state: "connected", accountId, detail: "Codex is connected to a ChatGPT subscription." };
-  }
-  return { state: "signed_out", detail: "Codex is installed but not signed in." };
-}
-async function onPath(bin, env = process.env) {
-  const dirs = (env.PATH ?? "").split(path2.delimiter).filter(Boolean);
-  for (const dir of dirs) {
-    try {
-      await access(path2.join(dir, bin), constants.X_OK);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function codexConnection(env = process.env) {
-  if (!await onPath("codex")) {
-    return {
-      state: "not_installed",
-      detail: "The Codex CLI is not on PATH. Install it, then run `hd connect`."
-    };
-  }
-  let auth = null;
-  try {
-    auth = JSON.parse(await readFile2(path2.join(codexHome(env), "auth.json"), "utf8"));
-  } catch {
-    auth = null;
-  }
-  const fromFile = classifyAuthFile(auth);
-  if (fromFile) return fromFile;
-  try {
-    const { stdout } = await run("codex", ["login", "status"], { timeout: 2e4 });
-    const text = stdout.trim();
-    if (/chatgpt/i.test(text)) {
-      return { state: "connected", accountId: null, detail: text };
-    }
-    if (/api key/i.test(text)) {
-      return { state: "api_key", detail: text };
-    }
-    return { state: "signed_out", detail: text || "Codex is not signed in." };
-  } catch {
-    return { state: "signed_out", detail: "Codex is installed but not signed in." };
-  }
-}
-function connectionSummary(connection) {
-  switch (connection.state) {
-    case "connected":
-      return connection.accountId ? `${connection.detail} Account ${connection.accountId}.` : connection.detail;
-    default:
-      return connection.detail;
-  }
-}
-function howToFix(connection) {
-  switch (connection.state) {
-    case "connected":
-      return null;
-    case "not_installed":
-      return "Install the Codex CLI, then run `hd connect`.";
-    case "api_key":
-      return "Run `codex logout` then `hd connect` to sign in with the subscription instead.";
-    default:
-      return "Run `hd connect` to sign in through ChatGPT.";
-  }
-}
-async function connectCodex() {
-  const code = await new Promise((resolve, reject) => {
-    const child = spawn("codex", ["login"], { stdio: "inherit" });
-    child.on("error", reject);
-    child.on("exit", (status) => resolve(status ?? 1));
-  });
-  if (code !== 0) throw new Error(`codex login exited ${code}`);
-  return codexConnection();
-}
-
-// src/auth.ts
+init_connection();
 var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 var CODE_RE = /^\d{6}$/;
 async function prompt(question) {
@@ -4536,22 +4837,22 @@ function registerAttachCommands(program) {
       if (!contentType) fail(`${name} is not a jpg, png, gif, or webp.`);
       const ext = extensionForContentType(contentType);
       if (!ext) fail(`${name} is not a jpg, png, gif, or webp.`);
-      const path7 = attachmentObjectPath(ctx.workspace.id, ticket.id, randomUUID(), ext);
-      const { error } = await ctx.db.storage.from(TICKET_IMAGES_BUCKET).upload(path7, bytes, { contentType, upsert: false });
+      const path8 = attachmentObjectPath(ctx.workspace.id, ticket.id, randomUUID(), ext);
+      const { error } = await ctx.db.storage.from(TICKET_IMAGES_BUCKET).upload(path8, bytes, { contentType, upsert: false });
       if (error) fail(`${name}: ${error.message}`);
       const { error: rowError } = await ctx.db.from("attachments").insert({
         workspace_id: ctx.workspace.id,
         ticket_id: ticket.id,
         message_id: null,
-        path: path7,
+        path: path8,
         content_type: contentType,
         created_by: "human"
       });
       if (rowError) {
-        await ctx.db.storage.from(TICKET_IMAGES_BUCKET).remove([path7]);
+        await ctx.db.storage.from(TICKET_IMAGES_BUCKET).remove([path8]);
         fail(rowError.message);
       }
-      uploaded.push(path7);
+      uploaded.push(path8);
     }
     await ctx.audit(ctx.workspace.id, "create", { ticket_key: ticket.key, subject: "attachments" });
     ok(`Attached ${uploaded.length} file${uploaded.length === 1 ? "" : "s"} to ${c.bold(ticket.key)}.`, {
@@ -4577,7 +4878,7 @@ function registerAttachCommands(program) {
 }
 
 // src/architect/commands.ts
-import { createInterface as createInterface3 } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
 init_json();
 init_theme();
 
@@ -4587,7 +4888,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z3 } from "zod";
 
 // src/version.ts
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 
 // src/architect/tools.ts
 init_src();
@@ -5019,6 +5320,13 @@ var TOOLS = [
 function toolsFor(access2) {
   return access2 === "read" ? TOOLS.filter((tool) => tool.access === "read") : TOOLS;
 }
+function toolJsonSchema(tool) {
+  const schema = z2.toJSONSchema(tool.schema);
+  delete schema.$schema;
+  if (!schema.type) schema.type = "object";
+  if (!schema.properties) schema.properties = {};
+  return schema;
+}
 async function toolContext(slug) {
   return requireWorkspace(slug);
 }
@@ -5090,361 +5398,172 @@ async function serveMcp(opts) {
 }
 
 // src/architect/plan.ts
-init_src();
-import { execFile as execFile3 } from "child_process";
-import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import path5 from "path";
-import { promisify as promisify3 } from "util";
 init_json();
 init_theme();
-
-// src/architect/codex.ts
-import { spawn as spawn4 } from "child_process";
-import { createInterface as createInterface2 } from "readline";
-
-// ../runner/src/adapters/codex.ts
-init_providers();
+init_chatgpt();
+init_connection();
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import path4 from "path";
-import { readFile as readFile6 } from "fs/promises";
-
-// ../runner/src/adapters/final.ts
-var OUTCOMES = /* @__PURE__ */ new Set(["pr_opened", "pr_updated", "blocked", "failed"]);
-function extractFinal(text) {
-  const trimmed = text.trim();
-  const candidates = [trimmed];
-  const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (fence?.[1]) candidates.unshift(fence[1].trim());
-  const firstBrace = trimmed.indexOf("{");
-  const lastBrace = trimmed.lastIndexOf("}");
-  if (firstBrace >= 0 && lastBrace > firstBrace) {
-    candidates.unshift(trimmed.slice(firstBrace, lastBrace + 1));
-  }
-  for (const candidate of candidates) {
-    try {
-      const parsed = JSON.parse(candidate);
-      if (parsed && typeof parsed.summary === "string" && parsed.outcome && OUTCOMES.has(parsed.outcome)) {
-        return parsed;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-
-// ../runner/src/adapters/spawn.ts
-import { spawn as spawn3 } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
+import path6 from "path";
+import { promisify as promisify2 } from "util";
 
-// ../runner/src/adapters/cost.ts
-function costFromPayload(payload) {
-  if (!payload) return null;
-  const values = [payload.total_cost_usd, payload.cost_usd, payload.totalCostUsd, payload.costUsd];
-  pushUsageCosts(asRecord2(payload.usage), values);
-  pushUsageCosts(asRecord2(payload.info), values);
-  const result = asRecord2(payload.result);
-  if (result) {
-    values.push(result.total_cost_usd, result.cost_usd);
-    pushUsageCosts(asRecord2(result.usage), values);
-  }
-  for (const value of values) {
-    const n = toNonNegativeNumber(value);
-    if (n != null) return n;
-  }
-  return null;
-}
-function turnsFromPayload(payload) {
-  if (!payload) return null;
-  const values = [payload.num_turns, payload.numTurns, payload.turns];
-  const usage = asRecord2(payload.usage);
-  if (usage) values.push(usage.num_turns, usage.numTurns, usage.turns);
-  const result = asRecord2(payload.result);
-  if (result) values.push(result.num_turns, result.numTurns, result.turns);
-  for (const value of values) {
-    const n = toNonNegativeInt(value);
-    if (n != null) return n;
-  }
-  return null;
-}
-function pushUsageCosts(usage, values) {
-  if (!usage) return;
-  values.push(usage.total_cost_usd, usage.cost_usd, usage.totalCostUsd, usage.costUsd);
-}
-function asRecord2(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function toNonNegativeNumber(value) {
-  if (typeof value === "number") return Number.isFinite(value) && value >= 0 ? value : null;
-  if (typeof value === "string" && value.trim()) {
-    const n = Number(value);
-    return Number.isFinite(n) && n >= 0 ? n : null;
+// src/architect/repo.ts
+import { readFile as readFile6, readdir, stat } from "fs/promises";
+import path5 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".vercel",
+  ".pnpm-store"
+]);
+var MAX_FILE_BYTES = 2e5;
+var MAX_LIST = 400;
+var MAX_MATCHES = 60;
+function resolveInside(root, candidate) {
+  const full = path5.resolve(root, candidate ?? ".");
+  const rel = path5.relative(root, full);
+  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
+    throw new Error(`${candidate} is outside the checkout.`);
+  }
+  return full;
+}
+function isSkipped(name) {
+  return SKIP_DIRS.has(name) || name.startsWith(".DS_Store");
+}
+async function walk(root, dir, out2, depth) {
+  if (out2.length >= MAX_LIST || depth > 12) return;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
   }
-  return null;
-}
-function toNonNegativeInt(value) {
-  const n = toNonNegativeNumber(value);
-  return n != null && Number.isInteger(n) ? n : null;
-}
-
-// ../runner/src/adapters/spawn.ts
-function spawnCli(opts) {
-  let sessionId = opts.sessionId ?? randomUUID2();
-  const child = spawn3(opts.bin, opts.args, {
-    cwd: opts.cwd,
-    env: process.env,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const queue = [];
-  let notify = null;
-  let closed = false;
-  let resultText = "";
-  let costUsd = null;
-  let turns = null;
-  const wait = collectLines(child, (line) => {
-    const event = opts.parse(line);
-    const sid = event?.payload?.session_id;
-    if (typeof sid === "string" && sid) sessionId = sid;
-    const thread = event?.payload?.thread_id;
-    if (typeof thread === "string" && thread) sessionId = thread;
-    const structured = event?.payload?.structured_output;
-    if (structured && typeof structured === "object") {
-      resultText = JSON.stringify(structured);
-    } else if (typeof event?.payload?.result === "string") {
-      resultText = event.payload.result;
-    }
-    const cost = costFromPayload(event?.payload);
-    if (cost != null) costUsd = cost;
-    const turnCount = turnsFromPayload(event?.payload);
-    if (turnCount != null) turns = turnCount;
-    queue.push(line);
-    notify?.();
-  }).then(({ stdout, stderr, exitCode, signal }) => {
-    closed = true;
-    notify?.();
-    return {
-      exitCode,
-      signal,
-      final: extractFinal(resultText || stdout),
-      rawText: resultText || stdout,
-      stderr,
-      costUsd,
-      turns
-    };
-  });
-  async function* stream() {
-    while (!closed || queue.length > 0) {
-      if (queue.length === 0) {
-        await new Promise((resolve) => {
-          notify = resolve;
-        });
-        notify = null;
-      }
-      while (queue.length > 0) {
-        yield queue.shift();
-      }
+  for (const entry of entries) {
+    if (out2.length >= MAX_LIST) return;
+    if (isSkipped(entry.name)) continue;
+    const full = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(root, full, out2, depth + 1);
+    } else if (entry.isFile()) {
+      out2.push(path5.relative(root, full));
     }
   }
-  return {
-    get sessionId() {
-      return sessionId;
-    },
-    stream: stream(),
-    kill() {
-      child.kill("SIGINT");
-      setTimeout(() => {
-        if (!child.killed) child.kill("SIGTERM");
-      }, 1e4).unref();
-    },
-    wait: () => wait
-  };
 }
-function collectLines(child, onLine) {
-  return new Promise((resolve, reject) => {
-    let buffer = "";
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) onLine(line);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (exitCode, signal) => {
-      if (buffer) onLine(buffer);
-      resolve({ stdout, stderr, exitCode, signal });
-    });
-  });
+function matchesGlob(rel, glob) {
+  if (!glob) return true;
+  const pattern = glob.split("").map((ch) => {
+    if (ch === "*") return "\0";
+    return /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+  }).join("").replace(//g, ".*").replace(//g, "[^/]*");
+  return new RegExp(`^${pattern}$`).test(rel);
 }
-
-// ../runner/src/adapters/codex.ts
-function effortConfig(effort) {
-  const level = effort ?? "high";
-  return ["-c", `model_reasoning_effort="${level}"`];
-}
-var codexAdapter = {
-  name: "codex",
-  start({ prompt: prompt2, cwd, model, effort }) {
-    return spawnCli({
-      bin: "codex",
-      args: [
-        "exec",
-        "--json",
-        "--model",
-        model,
-        ...effortConfig(effort),
-        "--dangerously-bypass-approvals-and-sandbox",
-        "-C",
-        cwd,
-        prompt2
-      ],
-      cwd,
-      parse: codexAdapter.parse
-    });
-  },
-  resume({ sessionId, prompt: prompt2, cwd, effort }) {
-    return spawnCli({
-      bin: "codex",
-      args: ["exec", "resume", sessionId, "--json", ...effortConfig(effort), prompt2],
-      cwd,
-      parse: codexAdapter.parse,
-      sessionId
-    });
-  },
-  parse(line) {
-    const trimmed = line.trim();
-    if (!trimmed) return null;
-    if (!trimmed.startsWith("{")) return { type: "text", payload: { text: trimmed } };
-    try {
-      const event = JSON.parse(trimmed);
-      const type = String(event.type ?? event.kind ?? "");
-      if (type === "thread.started" || type === "session" || type === "thread_started") {
-        const sessionId = typeof event.thread_id === "string" && event.thread_id || typeof event.session_id === "string" && event.session_id || void 0;
-        return { type: "status", payload: { phase: "init", session_id: sessionId, thread_id: sessionId } };
-      }
-      if (type.includes("tool") && (type.includes("call") || type === "tool_use")) {
-        return { type: "tool_use", payload: event };
-      }
-      if (type.includes("tool") && type.includes("result")) {
-        return { type: "tool_result", payload: event };
+function buildRepoTools(root) {
+  if (!root) return [];
+  return [
+    {
+      name: "list_files",
+      description: "List files in the workspace checkout, so you can see the shape of the codebase before reading anything. Optionally filter with a glob such as apps/web/**/*.tsx.",
+      parameters: {
+        type: "object",
+        properties: {
+          dir: { type: "string", description: "Directory relative to the repo root. Defaults to the root." },
+          glob: { type: "string", description: "Optional glob filter, e.g. **/*.ts" }
+        }
+      },
+      async run(args) {
+        const dir = resolveInside(root, String(args.dir ?? "."));
+        const found = [];
+        await walk(root, dir, found, 0);
+        const glob = args.glob ? String(args.glob) : void 0;
+        const filtered = found.filter((rel) => matchesGlob(rel, glob)).sort();
+        return {
+          root: path5.basename(root),
+          count: filtered.length,
+          truncated: found.length >= MAX_LIST,
+          files: filtered
+        };
       }
-      if (type === "item.completed" || type === "agent_message" || type === "message") {
-        return { type: "text", payload: event };
+    },
+    {
+      name: "read_file",
+      description: "Read a file from the workspace checkout. Large files come back truncated.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path relative to the repo root." }
+        },
+        required: ["path"]
+      },
+      async run(args) {
+        const file = resolveInside(root, String(args.path ?? ""));
+        const info = await stat(file).catch(() => null);
+        if (!info?.isFile()) throw new Error(`${args.path} is not a file in the checkout.`);
+        const raw = await readFile6(file, "utf8");
+        const truncated = raw.length > MAX_FILE_BYTES;
+        return {
+          path: path5.relative(root, file),
+          bytes: info.size,
+          truncated,
+          content: truncated ? raw.slice(0, MAX_FILE_BYTES) : raw
+        };
       }
-      if (type === "error" || event.error) {
-        return { type: "error", payload: event };
+    },
+    {
+      name: "search_code",
+      description: "Search the workspace checkout for a string or regular expression, returning matching lines with their file and line number.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Text or regular expression to find." },
+          glob: { type: "string", description: "Optional glob to narrow the search, e.g. **/*.ts" }
+        },
+        required: ["query"]
+      },
+      async run(args) {
+        const query = String(args.query ?? "");
+        if (!query) throw new Error("search_code needs a query.");
+        let re;
+        try {
+          re = new RegExp(query, "i");
+        } catch {
+          re = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+        }
+        const files = [];
+        await walk(root, root, files, 0);
+        const glob = args.glob ? String(args.glob) : void 0;
+        const matches = [];
+        for (const rel of files) {
+          if (matches.length >= MAX_MATCHES) break;
+          if (!matchesGlob(rel, glob)) continue;
+          let content;
+          try {
+            content = await readFile6(path5.join(root, rel), "utf8");
+          } catch {
+            continue;
+          }
+          if (content.length > MAX_FILE_BYTES) content = content.slice(0, MAX_FILE_BYTES);
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i += 1) {
+            if (matches.length >= MAX_MATCHES) break;
+            if (re.test(lines[i])) {
+              matches.push({ path: rel, line: i + 1, text: lines[i].trim().slice(0, 200) });
+            }
+          }
+        }
+        return { count: matches.length, truncated: matches.length >= MAX_MATCHES, matches };
       }
-      return { type: "status", payload: event };
-    } catch {
-      return { type: "text", payload: { text: trimmed } };
     }
-  },
-  extractFinal
-};
-
-// src/architect/codex.ts
-function mcpEndpoint(entry = process.argv[1], execPath = process.execPath) {
-  const mcpArgs = ["mcp"];
-  if (entry.endsWith(".ts") || entry.endsWith(".tsx")) {
-    return { command: "tsx", args: [entry, ...mcpArgs] };
-  }
-  return { command: execPath, args: [entry, ...mcpArgs] };
-}
-function mcpConfigArgs(endpoint, extraArgs = []) {
-  const args = [...endpoint.args, ...extraArgs];
-  return [
-    "-c",
-    `mcp_servers.hd.command=${JSON.stringify(endpoint.command)}`,
-    "-c",
-    `mcp_servers.hd.args=${JSON.stringify(args)}`
-  ];
-}
-function buildCodexArgs(opts) {
-  const shared = [
-    "--json",
-    "-c",
-    `model_reasoning_effort="${opts.effort}"`,
-    "-c",
-    'sandbox_mode="read-only"',
-    "--skip-git-repo-check",
-    ...opts.mcp
   ];
-  if (opts.resumeSessionId) {
-    return ["exec", "resume", opts.resumeSessionId, ...shared, opts.prompt];
-  }
-  return ["exec", "--model", opts.model, "--sandbox", "read-only", ...shared, "-C", opts.cwd, opts.prompt];
-}
-function spawnArchitect(opts) {
-  const args = buildCodexArgs(opts);
-  const child = spawn4("codex", args, {
-    cwd: opts.cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    env: process.env
-  });
-  let sessionId = opts.resumeSessionId ?? null;
-  const chunks = [];
-  let stderr = "";
-  child.stderr.on("data", (data) => {
-    stderr += data.toString();
-  });
-  const queue = [];
-  let notify = null;
-  let finished = false;
-  const lines = createInterface2({ input: child.stdout });
-  lines.on("line", (line) => {
-    chunks.push(line);
-    const event = codexAdapter.parse(line);
-    if (!event) return;
-    const candidate = event.payload.session_id ?? event.payload.thread_id;
-    if (!sessionId && typeof candidate === "string") sessionId = candidate;
-    queue.push(event);
-    notify?.();
-  });
-  const done = new Promise(
-    (resolve) => {
-      child.on("close", (code) => {
-        finished = true;
-        notify?.();
-        resolve({
-          exitCode: code,
-          text: chunks.join("\n") + (stderr ? `
-${stderr}` : ""),
-          sessionId
-        });
-      });
-      child.on("error", () => {
-        finished = true;
-        notify?.();
-        resolve({ exitCode: 1, text: stderr || "codex failed to start", sessionId });
-      });
-    }
-  );
-  const events = {
-    async *[Symbol.asyncIterator]() {
-      while (true) {
-        while (queue.length > 0) yield queue.shift();
-        if (finished) return;
-        await new Promise((resolve) => {
-          notify = () => {
-            notify = null;
-            resolve();
-          };
-        });
-      }
-    }
-  };
-  return { args, events, kill: () => child.kill("SIGINT"), done };
 }
 
 // src/architect/plan.ts
-var run2 = promisify3(execFile3);
+var run2 = promisify2(execFile2);
 var ARCHITECT_ROLE = "architect";
 async function architectAgent(ctx) {
   const { data, error } = await ctx.db.from("agents").select("*").eq("workspace_id", ctx.workspace.id).eq("role", ARCHITECT_ROLE).maybeSingle();
@@ -5461,14 +5580,12 @@ async function repoCheckout(ctx) {
   const here = process.cwd();
   try {
     const { stdout } = await run2("git", ["remote", "get-url", "origin"], { cwd: here });
-    const origin = stdout.trim().toLowerCase();
-    const repo = ctx.workspace.repo.toLowerCase();
-    if (origin.includes(repo)) return here;
+    if (stdout.trim().toLowerCase().includes(ctx.workspace.repo.toLowerCase())) return here;
   } catch {
   }
-  const root = path5.join(homedir4(), ".cache", "higherdev", "architect");
+  const root = path6.join(homedir3(), ".cache", "higherdev", "architect");
   await mkdir2(root, { recursive: true });
-  const dir = path5.join(root, ctx.workspace.slug);
+  const dir = path6.join(root, ctx.workspace.slug);
   try {
     await run2("git", ["-C", dir, "fetch", "--depth", "1", "origin", ctx.workspace.default_branch], {
       timeout: 12e4
@@ -5476,6 +5593,7 @@ async function repoCheckout(ctx) {
     await run2("git", ["-C", dir, "reset", "--hard", `origin/${ctx.workspace.default_branch}`], {
       timeout: 6e4
     });
+    return dir;
   } catch {
     try {
       await run2(
@@ -5483,51 +5601,43 @@ async function repoCheckout(ctx) {
         ["repo", "clone", ctx.workspace.repo, dir, "--", "--depth", "1", "--branch", ctx.workspace.default_branch],
         { timeout: 3e5 }
       );
-    } catch (error) {
-      fail(
-        `Could not get a checkout of ${ctx.workspace.repo} (${error instanceof Error ? error.message : String(error)}).
-Run \`hd plan\` from inside the repo, or check \`gh auth status\`.`
-      );
+      return dir;
+    } catch {
+      return null;
     }
   }
-  return dir;
 }
-function architectPrompt(opts) {
+function architectInstructions(opts) {
   const { ctx } = opts;
   return [
-    "You are the HigherDEV architect for the workspace below. You decide what should be built and",
-    "whether the platform is configured to build it. You do not write code: you file the work and the",
-    "orchestrator dispatches it to builders.",
+    "You are the HigherDEV architect, running in the owner's terminal.",
+    "You decide what should be built and whether the platform is configured to build it.",
+    "You do not write code: you file the work, and the orchestrator dispatches it to builders.",
     "",
-    `Workspace: ${ctx.workspace.slug} (${ctx.workspace.repo}, branch ${ctx.workspace.default_branch})`,
+    `Workspace: ${ctx.workspace.slug} (${ctx.workspace.repo}, branch ${ctx.workspace.default_branch}).`,
     `You are acting for ${ctx.email}.`,
     "",
-    "Tools: the `hd` MCP server is attached and is your only way to reach the platform. Call `status`",
-    "first, and `list_agents` before you assume who can build what. The repository is checked out at",
-    "your working directory, read only, so ground your assessment in the actual code.",
+    "Your tools are the only source of truth about the board. Call status before you assume anything,",
+    "and list_agents before you assume who can build what. Never invent tickets, agents, or state.",
+    opts.hasRepo ? "A checkout of the repository is readable through list_files, read_file, and search_code. Ground any claim about the code in what you actually read." : "No checkout is available, so do not claim anything about the code you have not been told.",
     "",
-    "How to hand work over:",
-    "- Prefer creating one epic with a well-written spec. `create_epic` triggers the orchestrator,",
-    "  which decomposes the spec into tickets itself and assigns them. That is the handoff.",
-    "- File individual tickets with `create_ticket` only for work that needs no decomposition.",
+    "Handing work over:",
+    "- Prefer one epic with a well-written spec. create_epic triggers the orchestrator, which",
+    "  decomposes the spec into tickets itself and assigns them. That is the handoff.",
+    "- Use create_ticket only for work that needs no decomposition.",
     "- A ticket is one PR, one area, under about 400 changed lines, with acceptance criteria and a",
     "  test expectation. Two live tickets must not share an area; chain them with blocked_by.",
     "",
-    "What only you can do: agent configuration. Model, effort, routing notes, prompt addenda,",
-    "conventions, budgets, pausing. The orchestrator has no action for any of it. If the work you are",
-    "planning needs a different builder lineup, change it with `update_agent` and say why.",
+    "Only you can change agent configuration: model, effort, routing notes, prompt addenda,",
+    "conventions, budgets, pausing. The orchestrator has no action for any of it.",
     "",
-    opts.readOnly ? "This run is read-only. Propose the plan in your reply; do not expect any write tool to exist." : "When you are done, summarise what you filed and what the owner should look at.",
-    "Never use an em dash in anything you write.",
+    opts.readOnly ? "This session is read-only. Propose in your reply; the tools that change things are not loaded." : "Say what you filed and what the owner should look at.",
+    "Answer conversationally and briefly. Lead with the answer. Never use an em dash.",
     opts.addendum ? `
-${opts.addendum}` : "",
-    "",
-    "---",
-    "",
-    opts.request
-  ].filter((line) => line !== null).join("\n");
+${opts.addendum}` : ""
+  ].filter(Boolean).join("\n");
 }
-async function runArchitect(opts) {
+async function openArchitect(opts) {
   const { ctx } = opts;
   const agent = await architectAgent(ctx);
   const connection = await codexConnection();
@@ -5535,92 +5645,100 @@ async function runArchitect(opts) {
     fail(`${connectionSummary(connection)}
 ${howToFix(connection) ?? ""}`.trim());
   }
-  if (connection.state !== "connected") {
-    opts.onLine(c.yellow(`${connectionSummary(connection)} Continuing because --allow-api-billing was passed.`));
-  }
-  const cwd = await repoCheckout(ctx);
-  const config = await loadConfig();
-  const sessionKey = `architect_session_${ctx.workspace.slug}`;
-  const previous = config[sessionKey];
-  const resumeSessionId = opts.resume && typeof previous === "string" ? previous : null;
-  if (opts.resume && !resumeSessionId) fail("No architect session to resume in this workspace.");
-  const endpoint = mcpEndpoint();
-  const mcp = mcpConfigArgs(endpoint, [
-    ...opts.readOnly ? ["--read-only"] : [],
-    "--workspace",
-    ctx.workspace.slug
-  ]);
+  const repo = await repoCheckout(ctx);
+  const platformTools = toolsFor(opts.readOnly ? "read" : "all").map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: toolJsonSchema(tool),
+    run: (args) => tool.run(ctx, args)
+  }));
+  return {
+    agent,
+    instructions: architectInstructions({
+      ctx,
+      addendum: agent.prompt_addendum,
+      readOnly: opts.readOnly,
+      hasRepo: Boolean(repo)
+    }),
+    tools: [...platformTools, ...buildRepoTools(repo)],
+    sessionId: newSessionId(),
+    history: [],
+    repo
+  };
+}
+async function architectTurn(opts) {
+  const { ctx, session } = opts;
   const { data: runRow, error: runError } = await ctx.db.from("runs").insert({
     workspace_id: ctx.workspace.id,
     ticket_id: null,
-    agent_id: agent.id,
+    agent_id: session.agent.id,
     kind: "architect",
-    provider: agent.provider,
-    model: agent.model,
+    provider: session.agent.provider,
+    model: session.agent.model,
     status: "running",
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    session_id: session.sessionId,
     host: null
   }).select("id").single();
   if (runError) fail(runError.message);
-  const prompt2 = architectPrompt({
-    ctx,
-    request: opts.request,
-    addendum: agent.prompt_addendum,
-    readOnly: opts.readOnly
-  });
-  const spawned = spawnArchitect({
-    prompt: prompt2,
-    cwd,
-    model: agent.model,
-    effort: agent.effort ?? "high",
-    mcp,
-    resumeSessionId
-  });
   let seq = 0;
-  const pending = [];
+  const events = [];
+  const record = (type, payload) => events.push({ run_id: runRow.id, seq: seq++, type, payload });
   const flush = async () => {
-    if (pending.length === 0) return;
-    const batch = pending.splice(0, pending.length);
-    await ctx.db.from("run_events").insert(batch);
+    if (events.length) await ctx.db.from("run_events").insert(events);
   };
-  const ticker = setInterval(() => void flush(), 2e3);
-  const interrupt = () => spawned.kill();
-  process.once("SIGINT", interrupt);
-  for await (const event of spawned.events) {
-    pending.push({ run_id: runRow.id, seq: seq++, type: event.type, payload: event.payload });
-    const [line] = transcriptLines([{ id: String(seq), type: event.type, payload: event.payload }]);
-    if (!line) continue;
-    if (line.kind === "status" && line.title === "init") continue;
-    if (line.kind === "text") opts.onLine(line.title);
-    else if (line.kind === "error") opts.onLine(c.red(line.title));
-    else opts.onLine(c.dim(`  ${line.title}`));
-    if (line.body) opts.onLine(c.dim(`    ${line.body}`));
-  }
-  clearInterval(ticker);
-  await flush();
-  process.off("SIGINT", interrupt);
-  const result = await spawned.done;
-  await ctx.db.from("runs").update({
-    status: result.exitCode === 0 ? "succeeded" : "failed",
-    ended_at: (/* @__PURE__ */ new Date()).toISOString(),
-    exit_code: result.exitCode,
-    session_id: result.sessionId,
-    summary: result.exitCode === 0 ? "Architect session" : `Codex exited ${result.exitCode}`
-  }).eq("id", runRow.id);
-  if (result.sessionId) await saveConfig({ [sessionKey]: result.sessionId });
-  await ctx.audit(ctx.workspace.id, "architect", { subject: agent.display_name });
-  if (result.exitCode !== 0 && !isJsonMode()) {
-    opts.onLine(c.red(`codex exited ${result.exitCode}`));
-  }
-  return { sessionId: result.sessionId, exitCode: result.exitCode, runId: runRow.id };
+  try {
+    const result = await runAgent({
+      prompt: opts.request,
+      instructions: session.instructions,
+      history: session.history,
+      tools: session.tools,
+      model: session.agent.model,
+      sessionId: session.sessionId,
+      signal: opts.signal,
+      onEvent: (event) => {
+        if (event.kind === "tool") record("tool_use", { name: event.name, input: event.args });
+        else if (event.kind === "tool_result") {
+          record("tool_result", { name: event.name, ok: event.ok, content: event.detail });
+        }
+        opts.onEvent(event);
+      }
+    });
+    if (result.text) record("text", { text: result.text });
+    session.history.push({ role: "user", content: opts.request });
+    session.history.push({ role: "assistant", content: result.text });
+    await flush();
+    await ctx.db.from("runs").update({
+      status: "succeeded",
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      exit_code: 0,
+      turns: result.steps,
+      summary: result.text.slice(0, 500) || "Architect turn"
+    }).eq("id", runRow.id);
+    await ctx.audit(ctx.workspace.id, "architect", { subject: session.agent.display_name });
+    return { text: result.text, runId: runRow.id, toolCalls: result.toolCalls };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    record("error", { error: message });
+    await flush();
+    await ctx.db.from("runs").update({
+      status: "failed",
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      exit_code: 1,
+      summary: message.slice(0, 500)
+    }).eq("id", runRow.id);
+    if (error instanceof ChatGptAuthError) fail(message);
+    throw error;
+  }
 }
 
 // src/architect/commands.ts
+init_connection();
 function slugOf6(command) {
   return command.optsWithGlobals().workspace;
 }
 async function askLine(prompt2) {
-  const rl = createInterface3({ input: process.stdin, output: process.stderr });
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
   try {
     return await new Promise((resolve) => {
       rl.once("close", () => resolve(""));
@@ -5641,25 +5759,42 @@ ${howToFix(connection) ?? ""}`.trim()
   );
 }
 function registerArchitectCommands(program) {
-  program.command("plan").argument("[request...]", "what to plan, assess, or change; omit for a conversation").description("the architect: assess the repo, shape the work, tune the platform").option("--read-only", "let it look and propose, but change nothing").option("--resume", "continue the last architect session in this workspace").option("--once", "run a single turn and exit, even without a request").option("--allow-api-billing", "run even when Codex would bill per token instead of the subscription").action(async function(request) {
+  program.command("plan").argument("[request...]", "what to plan, assess, or change; omit for a conversation").description("the architect: assess the repo, shape the work, tune the platform").option("--read-only", "let it look and propose, but change nothing").option("--once", "run a single turn and exit, even without a request").option("--allow-api-billing", "run even when Codex would bill per token instead of the subscription").action(async function(request) {
     const opts = this.opts();
     const ctx = await requireWorkspace(slugOf6(this));
     const first = request.join(" ").trim();
     const conversational = !first && !opts.once && process.stdin.isTTY && !isJsonMode();
-    const turn = async (ask, resume2) => {
-      const lines = [];
-      const result = await runArchitect({
-        ctx,
-        request: ask,
-        readOnly: Boolean(opts.readOnly),
-        resume: resume2,
-        allowApiBilling: Boolean(opts.allowApiBilling),
-        onLine: (text) => {
-          lines.push(text);
-          if (!isJsonMode()) out(text);
+    const session = await openArchitect({
+      ctx,
+      readOnly: Boolean(opts.readOnly),
+      allowApiBilling: Boolean(opts.allowApiBilling)
+    });
+    let wroteText = false;
+    const onEvent = (event) => {
+      if (isJsonMode()) return;
+      if (event.kind === "text") {
+        process.stdout.write(event.delta);
+        wroteText = true;
+        return;
+      }
+      if (wroteText) {
+        process.stdout.write("\n");
+        wroteText = false;
+      }
+      if (event.kind === "tool") out(c.dim(`  ${event.name}`));
+      else if (!event.ok) out(c.red(`  ${event.name} failed: ${event.detail}`));
+    };
+    const turn = async (ask) => {
+      const result = await architectTurn({ ctx, session, request: ask, onEvent });
+      if (!isJsonMode()) {
+        if (wroteText) {
+          process.stdout.write("\n");
+          wroteText = false;
+        } else if (!result.text) {
+          out(c.dim("(no reply)"));
         }
-      });
-      return { result, lines };
+      }
+      return result;
     };
     if (!conversational) {
       let ask = first;
@@ -5668,30 +5803,24 @@ function registerArchitectCommands(program) {
         ask = await askLine("plan> ");
         if (!ask) fail("Nothing asked.");
       }
-      const { result, lines } = await turn(ask, Boolean(opts.resume));
+      const result = await turn(ask);
       if (isJsonMode()) {
-        emit(
-          { ok: result.exitCode === 0, run_id: result.runId, session_id: result.sessionId, output: lines },
-          () => ""
-        );
-        return;
-      }
-      if (result.sessionId) {
-        out(c.dim(`
-Continue with \`hd plan --resume "..."\`. Run ${result.runId.slice(0, 8)}.`));
+        emit({ ok: true, run_id: result.runId, text: result.text, tool_calls: result.toolCalls }, () => "");
       }
       return;
     }
-    out(c.dim("Talking to the architect. Enter sends, blank line or /exit leaves, ctrl-c stops a turn."));
-    let resume = Boolean(opts.resume);
+    out(
+      c.dim(
+        `Talking to the architect (${session.agent.model}${session.repo ? ", repo readable" : ""}). Blank line or /exit leaves.`
+      )
+    );
     for (; ; ) {
       const ask = await askLine("\nplan> ");
       if (!ask || ask === "/exit" || ask === "/quit") {
-        out(c.dim('Left the architect. `hd plan --resume "..."` picks the thread back up.'));
+        out(c.dim("Left the architect."));
         return;
       }
-      const { result } = await turn(ask, resume);
-      if (result.sessionId) resume = true;
+      await turn(ask);
     }
   });
   program.command("mcp").description("serve the platform as MCP tools on stdio, for Codex, Claude Code, or Mel").option("--read-only", "expose only the tools that change nothing").option("--list", "print the tools instead of serving them").action(async function() {
@@ -5727,19 +5856,34 @@ Run \`codex login\` in a terminal.`);
     report(connection);
     if (connection.state !== "connected") process.exitCode = 1;
   });
-  program.command("doctor").description("check the architect's Codex connection and how a run would bill").action(async function() {
+  program.command("doctor").description("check the architect's ChatGPT connection and how a turn would bill").action(async function() {
     const connection = await codexConnection();
-    const endpoint = mcpEndpoint();
+    const expiry = await tokenExpiry();
     emit(
-      { codex: connection, mcp: endpoint, config_args: mcpConfigArgs(endpoint) },
+      { codex: connection, token_expires_in_hours: expiry },
       () => [
-        `${c.dim("codex")}       ${connection.state === "connected" ? c.green(connectionSummary(connection)) : c.yellow(connectionSummary(connection))}`,
-        `${c.dim("mcp server")}  ${endpoint.command} ${endpoint.args.join(" ")}`,
-        connection.state === "connected" ? c.dim("Architect runs bill the ChatGPT subscription, not per token.") : c.yellow(howToFix(connection) ?? "")
-      ].join("\n")
+        `${c.dim("chatgpt")}  ${connection.state === "connected" ? c.green(connectionSummary(connection)) : c.yellow(connectionSummary(connection))}`,
+        expiry == null ? "" : `${c.dim("session")}  renews automatically, valid for ${expiry}h`,
+        connection.state === "connected" ? c.dim("The architect calls the ChatGPT backend directly on your subscription. No Codex process, no per-token billing.") : c.yellow(howToFix(connection) ?? "")
+      ].filter(Boolean).join("\n")
     );
   });
 }
+async function tokenExpiry() {
+  try {
+    const { readFile: readFile8 } = await import("fs/promises");
+    const path8 = await import("path");
+    const { codexHome: codexHome2 } = await Promise.resolve().then(() => (init_connection(), connection_exports));
+    const { msUntilExpiry: msUntilExpiry2 } = await Promise.resolve().then(() => (init_chatgpt(), chatgpt_exports));
+    const raw = await readFile8(path8.join(codexHome2(), "auth.json"), "utf8");
+    const token = JSON.parse(raw).tokens?.access_token;
+    if (!token) return null;
+    const ms = msUntilExpiry2(token);
+    return Number.isFinite(ms) ? Math.round(ms / 36e5) : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/tui/commands.ts
 init_json();
@@ -5808,7 +5952,7 @@ ${runner.HD_HELP}`);
 
 // src/host/upgrade.ts
 import { execFile as execFile5 } from "child_process";
-import { createInterface as createInterface4 } from "readline/promises";
+import { createInterface as createInterface3 } from "readline/promises";
 import { promisify as promisify5 } from "util";
 init_json();
 init_theme();
@@ -5857,7 +6001,7 @@ async function offerUpdate(now = Date.now()) {
   await saveUpdateState({ checked_at: now });
   if (!latest || !isNewer(latest, VERSION)) return;
   if (state.skipped === latest) return;
-  const rl = createInterface4({ input: process.stdin, output: process.stderr });
+  const rl = createInterface3({ input: process.stdin, output: process.stderr });
   let answer = "";
   try {
     answer = (await rl.question(