agentschat-mcp 0.36.5 → 0.36.7

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Release notes
 
+## 0.36.7 — UNPUBLISHED — Non-Grok stacks start without Cursor session env
+
+- **Codex execution ownership:** remove outer turn/RPC time limits and duration-based restarts; Codex owns long-running execution. Explicit shutdown and actual backend failures still preserve pending work and conversation mappings.
+- **Codex message recovery:** persist independent history checkpoints and reconcile missed messages on reconnect and every minute, with bounded pages, durable deduplication, and inbox backpressure. Cold installation does not replay old requests.
+- **Codex bot effort:** optional per-bot `effort` overrides reasoning on every new turn, including resumed conversations, without changing the model or other bots. Manager status exposes the configured override.
+- **Continuous team delivery:** maintain a capacity- and capability-aware reserve of executable tasks, replenish before members run out, and coordinate completion-driven claims without duplicate writers or artificial busywork. Runtime wake limitations stay explicit.
+- **Docs:** onboarding, `url-wake-keepalive` and `grok-wake-keepalive` say
+  non-Grok stacks (URL wakes such as Antigravity/ZCode, Hermes) are started with
+  the Cursor session env removed (`env -u CURSOR_CONVERSATION_ID -u CURSOR_REQUEST_ID -u __CURSOR_SANDBOX_ENV_RESTORE -u CURSOR_AGENT` + dynamic
+  `CURSOR_AGENT_STORE_*`), and that Grok `WAKE_MODE=grok` wakes keep theirs.
+- **Example receiver:** `withoutCursorSessionEnv()` drops those keys from the host
+  turn's env; `example-url-wake-ensure.sh` shows the start-script pattern.
+
+## 0.36.6 — UNPUBLISHED — Grok binds: register-yourself, non-Grok wakes exempt
+
+- **grok-bind no longer captures non-Grok wakes:** identity bind, heal and the
+  `switch_profile` lock are skipped when the process is tagged as another wake
+  stack (`AGENTCHAT_ANTIGRAVITY_WAKE` set, or `AGENTCHAT_WAKE_KIND` /
+  `AGENTCHAT_WAKE_MODE` other than `grok`) or was started with an explicit
+  `--profile` that differs from the bound profile. Antigravity/ZCode bots that
+  inherited a Grok agent's `CURSOR_CONVERSATION_ID` can switch to their own
+  profiles again. Grok wakes and Cursor outbound MCP (explicit profile equal to
+  the bound one) stay locked. `switch_profile` listing ignores
+  `grok-binds.meta.json`.
+- **Register yourself (`scripts/grok-bind-register.sh`, bin
+  `agentschat-grok-bind-register`):** the only writer of grok-binds.json. Uses
+  the caller's own `CURSOR_CONVERSATION_ID` (real UUIDs only), requires the
+  profile file, flocks, sets only its own key atomically (mode 600) and records
+  `{profile, registered_by, ts}` in the `grok-binds.meta.json` sidecar.
+  `--prune` removes an entry only if its profile is gone, or its agent dir is
+  missing and it last registered more than 7 days ago; each prune is logged.
+  No hard-coded bot list.
+- **ensure-grok-wakes:** a missing binds file prunes nothing; every stopped
+  orphan is logged with profile, agent id and reason; the script never writes
+  the binds file.
+- **Docs:** `grok-wake-keepalive` and onboarding describe the register-yourself
+  flow and tagging non-Grok hosts.
+
 ## 0.36.5 — UNPUBLISHED — Shared conversations and team coordination
 
 - **Cross-runtime group loops:** own server ticks no longer require an @mention for Claude/Grok MCP notification and wake delivery. Hermes Relay accepts verified current bot-owned ticks in the original group and deduplicates replay; native skill-loader guidance stays in private runtime context.

package/codex/README.md

@@ -106,6 +106,17 @@ so already. The bridge never writes an account token into project config or stat
   DMs and different groups stay separate. Permissions and owner lookup no longer
   split ordinary chat history. Requests run in arrival order; restart resumes the
   same thread. Up to 100 unfinished messages can queue.
+- Codex owns execution lifetime. The bridge sets no turn-duration or App Server
+  RPC deadline and never restarts a healthy backend merely because it is slow.
+  Explicit shutdown, process exit, broken pipes and invalid protocol responses
+  still end pending requests; actual backend failure is handled by the supervisor.
+- After first installation, durable REST checkpoints recover missed messages on
+  reconnect and once per minute while connected. Each pass reads at most 50 rows
+  per subscribed channel; subsequent passes continue a backlog. Live and recovered
+  messages share identity checks, inbox deduplication and the same conversation.
+  First-time membership starts from now, without replaying historical requests.
+  Inbox pressure preserves the checkpoint for retry. `inbound-cursors.json` records
+  the last check, last successful check and any reconciliation error for diagnosis.
 - All accepted messages use the bot's configured permissions: full access by
   default (`approvalPolicy=never`, `danger-full-access`, inherited MCP tools).
   Use `channels`/`senders` to limit which messages the bot accepts, or explicit
@@ -254,6 +265,9 @@ Create `~/.agentschat/codex-bots.json`:
 ```
 
 Omitted default_workdir uses `~/.agentschat/workspace` (created automatically).
+Optional per-bot `"effort": "medium"` sets reasoning effort on every turn,
+including existing conversations. Omit it to retain Codex's inherited effort.
+It does not change the model, other bots, or the desktop's global configuration.
 Relative workdirs resolve against the registry's directory. Each enabled bot has
 its own bridge process, App Server, inbox and channel threads. Identity and routing
 come exclusively from the registry and named profile; project profile settings and

package/codex/app-server.ts

@@ -1,7 +1,7 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { createInterface } from "node:readline";
 import type { ThreadHistory } from "./thread-history.ts";
-import type { PermissionMode } from "./config.ts";
+import type { PermissionMode, ReasoningEffort } from "./config.ts";
 
 export class ThreadBusyError extends Error {
   constructor() { super("This conversation has another active writer; waiting to resume the same task"); this.name = "ThreadBusyError"; }
@@ -13,12 +13,13 @@ export class AppServer {
   private closed = false;
   private child?: ChildProcessWithoutNullStreams;
   private nextId = 0;
-  private pending = new Map<number, { method: string; resolve: (v: any) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>();
+  private pending = new Map<number, { method: string; resolve: (v: any) => void; reject: (e: Error) => void }>();
   private active?: { thread: string; turn?: string; items: Map<string, string>; early: any[];
-    resolve: (s: string) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> };
+    resolve: (s: string) => void; reject: (e: Error) => void };
   private threadPermissions = new Map<string, PermissionMode>();
   private disabledMcp: Record<string, { enabled: boolean }> = {};
-  constructor(private bin = "codex", private args = ["app-server", "--listen", "stdio://"], private timeoutMs = 600_000, private permissions: PermissionMode = "full-access", private runtime?: {home: string; legacyHome?: string}) {}
+  // Keep the legacy positional argument for callers; turns have no time limit.
+  constructor(private bin = "codex", private args = ["app-server", "--listen", "stdio://"], _legacyTurnTimeoutMs?: number, private permissions: PermissionMode = "full-access", private runtime?: {home: string; legacyHome?: string}, private effort?: ReasoningEffort) {}
   get namespace() { return this.runtime?.home; }
   async start() {
     const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^AGENTS?CHAT_|^RELAY_/.test(k)));
@@ -44,10 +45,9 @@ export class AppServer {
   request(method: string, params: unknown): Promise<any> {
     return new Promise((resolve, reject) => {
       const id = ++this.nextId;
-      const timer = setTimeout(() => this.fatal(new Error(`App-server ${method} timed out`)), 30_000);
-      this.pending.set(id, { method, resolve, reject, timer });
+      this.pending.set(id, { method, resolve, reject });
       try { this.write({ id, method, params }); }
-      catch (e) { clearTimeout(timer); this.pending.delete(id); reject(e); }
+      catch (e) { this.pending.delete(id); reject(e); }
     });
   }
   private receive(message: any) {
@@ -58,7 +58,7 @@ export class AppServer {
     }
     if (message.id !== undefined) {
       const waiter = this.pending.get(message.id);
-      if (waiter) { clearTimeout(waiter.timer); this.pending.delete(message.id);
+      if (waiter) { this.pending.delete(message.id);
         message.error ? waiter.reject(waiter.method === "thread/resume" && /already has an active writer/i.test(message.error.message ?? "")
           ? new ThreadBusyError() : new Error(`App-server request rejected (${message.error.code})`)) : waiter.resolve(message.result); }
       return;
@@ -70,7 +70,7 @@ export class AppServer {
     if (message.method === "item/completed" && p.item?.type === "agentMessage" &&
       (!p.item.phase || p.item.phase === "final_answer")) a.items.set(p.item.id, p.item.text);
     if (message.method === "turn/completed") {
-      clearTimeout(a.timer); this.active = undefined;
+      this.active = undefined;
       if (p.turn.status !== "completed") { a.reject(new Error(`Codex turn ${p.turn.status}`)); return; }
       for (const item of p.turn.items ?? []) if (item.type === "agentMessage" && (!item.phase || item.phase === "final_answer")) a.items.set(item.id, item.text);
       const text = [...a.items.values()].join("\n").trim();
@@ -110,19 +110,18 @@ export class AppServer {
   }
   async readLegacyThread(thread: string): Promise<ThreadHistory> {
     if (!this.runtime?.legacyHome) return this.readThread(thread);
-    const reader = new AppServer(this.bin, undefined, this.timeoutMs, this.permissions, {home:this.runtime.legacyHome});
+    const reader = new AppServer(this.bin, undefined, undefined, this.permissions, {home:this.runtime.legacyHome});
     try { await reader.start(); return await reader.readThread(thread); } finally { reader.close(); }
   }
   async nameThread(thread: string, name: string): Promise<void> {
     await this.request("thread/name/set", {threadId:thread, name});
   }
-  async generate(thread: string, text: string, effort?: "low"): Promise<string> {
+  async generate(thread: string, text: string, effort: ReasoningEffort | undefined = this.effort): Promise<string> {
     if (this.active) throw new Error("App-server is busy");
     const permissions = this.threadPermissions.get(thread);
     if (!permissions) throw new Error("Thread permissions have not been configured");
     const completed = new Promise<string>((resolve, reject) => {
-      this.active = { thread, items: new Map(), early: [], resolve, reject,
-        timer: setTimeout(() => this.fatal(new Error("Codex turn timed out")), this.timeoutMs) };
+      this.active = { thread, items: new Map(), early: [], resolve, reject };
     });
     // Attach immediately, including while turn/start is waiting for its response.
     void completed.catch(() => {});
@@ -138,8 +137,8 @@ export class AppServer {
     } catch (e) { this.fail(e instanceof Error ? e : new Error("Generation failed")); throw e; }
   }
   private fail(error: Error) {
-    for (const p of this.pending.values()) { clearTimeout(p.timer); p.reject(error); } this.pending.clear();
-    if (this.active) { clearTimeout(this.active.timer); this.active.reject(error); this.active = undefined; }
+    for (const p of this.pending.values()) p.reject(error); this.pending.clear();
+    if (this.active) { this.active.reject(error); this.active = undefined; }
   }
   private fatal(error: Error) {
     if (this.closed) return;

package/codex/bots-config.ts

@@ -21,7 +21,7 @@ export function loadBots(file = defaultRegistry(), home = homedir()): BotConfig[
   const names = new Set<string>(), identities = new Set<string>();
   const bots: BotConfig[] = [];
   for (const bot of doc.bots) {
-    fields(bot, ["name", "profile", "workdir", "enabled", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions"]);
+    fields(bot, ["name", "profile", "workdir", "enabled", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"]);
     if (!text(bot.name) || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(bot.name) || names.has(bot.name)) throw new Error("Bot names must be unique simple labels");
     names.add(bot.name);
     if (bot.enabled !== undefined && typeof bot.enabled !== "boolean") throw new Error("Invalid bot enabled flag");
@@ -32,7 +32,7 @@ export function loadBots(file = defaultRegistry(), home = homedir()): BotConfig[
     if (!doc.default_workdir && !bot.workdir) mkdirSync(defaultDir, { recursive: true, mode: 0o700 });
     const cwd = realpathSync(bot.workdir ? path(bot.workdir) : defaultDir);
     const settings: IdentitySettings = {};
-    for (const k of ["agent_id", "channels", "senders", "api_url", "ws_url", "permissions"] as const) if (bot[k] !== undefined) (settings as any)[k] = bot[k];
+    for (const k of ["agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"] as const) if (bot[k] !== undefined) (settings as any)[k] = bot[k];
     const config = resolveConfig({ cwd, profile: bot.profile, settings, codexBin: doc.codex_bin }, {}, home);
     const identity = JSON.stringify([config.apiUrl, config.agentId]);
     if (identities.has(identity)) throw new Error("Duplicate AgentsChat account in enabled bots (even with different workdirs)");

package/codex/bridge.ts

@@ -76,6 +76,15 @@ export class Bridge {
     void this.drain(); return true;
   }
   redact(text: string) { return redactSecrets(text.split(this.config.token).join("[REDACTED]")); }
+  /** History cursors may advance past ignored/known messages, never a full inbox. */
+  recover(raw: unknown): boolean {
+    if (this.stopped) return false;
+    if (!addressed(raw, this.config)) return true;
+    if (this.state.entries.some(e => e.message.id === raw.id && e.message.channel_id === raw.channel_id)) return true;
+    if (raw.meta?.kind === "loop_tick" && this.state.entries.some(e =>
+      e.message.meta?.loop_id === raw.meta!.loop_id && e.message.meta.next_tick_ms === raw.meta!.next_tick_ms)) return true;
+    return this.accept(raw);
+  }
   drain(): Promise<void> {
     if (this.retry) return Promise.resolve();
     if (this.draining) return this.draining;

package/codex/config.ts

@@ -6,6 +6,14 @@ import { validateIdentityProfile } from "../src/identity.ts";
 import { parse as parseToml } from "smol-toml";
 
 export type PermissionMode = "full-access" | "read-only";
+// App Server advertises model-specific, nonempty effort names via model/list.
+export type ReasoningEffort = string;
+export function reasoningEffort(value: unknown): ReasoningEffort | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || !value.trim())
+    throw new Error("effort must be a nonempty model-supported reasoning effort name");
+  return value.trim();
+}
 export function permissionMode(value: unknown): PermissionMode {
   if (value === undefined) return "full-access";
   if (value !== "full-access" && value !== "read-only") throw new Error("permissions must be full-access or read-only");
@@ -14,9 +22,9 @@ export function permissionMode(value: unknown): PermissionMode {
 export interface BridgeConfig {
   cwd: string; profileFile: string; source: string; agentId: string; token: string;
   apiUrl: string; wsUrl: string; channels: string[]; senders: string[];
-  codexBin: string; stateDir: string; permissions: PermissionMode;
+  codexBin: string; stateDir: string; permissions: PermissionMode; effort?: ReasoningEffort;
 }
-export interface IdentitySettings { permissions?: PermissionMode; profile?: string; agent_id?: string; channels?: string[]; senders?: string[]; api_url?: string; ws_url?: string }
+export interface IdentitySettings { permissions?: PermissionMode; effort?: ReasoningEffort; profile?: string; agent_id?: string; channels?: string[]; senders?: string[]; api_url?: string; ws_url?: string }
 function readJson(file: string): any {
   try { return JSON.parse(readFileSync(file, "utf8")); }
   catch { throw new Error(`Cannot read valid JSON: ${file}`); }
@@ -33,7 +41,7 @@ export function resolveConfig(opts: { cwd?: string; profile?: string; codexBin?:
   const configFile = join(cwd, ".agentschat/config.json");
   const project = opts.settings ?? (existsSync(configFile) ? readJson(configFile) : {});
   if (!project || typeof project !== "object" || Array.isArray(project)) throw new Error("Invalid project config");
-  const allowed = new Set(["profile", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions"]);
+  const allowed = new Set(["profile", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"]);
   if (Object.keys(project).some(k => !allowed.has(k))) throw new Error("Unknown project config field (credentials belong in a private profile)");
   for (const k of ["profile", "agent_id", "api_url", "ws_url"])
     if (project[k] !== undefined && (typeof project[k] !== "string" || !project[k].trim())) throw new Error(`Invalid project ${k}`);
@@ -84,7 +92,7 @@ export function resolveConfig(opts: { cwd?: string; profile?: string; codexBin?:
   }
   const canonicalApi = new URL(apiUrl).href.replace(/\/$/, "");
   const key = createHash("sha256").update(JSON.stringify([cwd, canonicalApi, profile.agent_id])).digest("hex").slice(0, 24);
-  return { cwd, profileFile, source, permissions: permissionMode(project.permissions), agentId: profile.agent_id, token: profile.token,
+  return { cwd, profileFile, source, permissions: permissionMode(project.permissions), effort: reasoningEffort(project.effort), agentId: profile.agent_id, token: profile.token,
     apiUrl: canonicalApi, wsUrl, channels: strings(project.channels, "channels"),
     senders: strings(project.senders, "senders"), codexBin: opts.codexBin ?? "codex",
     stateDir: join(home, ".agentschat/codex-bridge", key) };

package/codex/inbox-sync.ts

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { normalizeTimestampForCursor } from "../src/timestamps.ts";
+
+interface Snapshot {
+  version: 1;
+  channels: Record<string, string>;
+  last_check_at?: string;
+  last_success_at?: string;
+  last_error?: string;
+}
+function timestamp(value: unknown): string {
+  if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) throw new Error("Invalid history timestamp");
+  return normalizeTimestampForCursor(value, "after")!;
+}
+
+/** REST checkpoints, independent of live WS delivery. Advancing a live cursor
+ * could otherwise jump over messages that were silently lost before it. */
+export class InboxSync {
+  private file: string;
+  private state: Snapshot;
+  private channels = new Set<string>();
+  private running?: Promise<void>;
+  constructor(stateDir: string, private api: (path: string) => Promise<any>,
+    private receive: (message: unknown) => boolean, private active: () => boolean,
+    private log: (message: string) => void = console.error) {
+    mkdirSync(stateDir, {recursive:true, mode:0o700});
+    this.file = join(stateDir, "inbound-cursors.json");
+    this.state = existsSync(this.file) ? JSON.parse(readFileSync(this.file, "utf8")) : {version:1, channels:{}};
+    if (this.state.version !== 1 || !this.state.channels || typeof this.state.channels !== "object" || Array.isArray(this.state.channels))
+      throw new Error("Invalid inbound cursors; refusing to discard checkpoint");
+    for (const value of Object.values(this.state.channels)) timestamp(value);
+    this.state.channels = Object.assign(Object.create(null), this.state.channels);
+  }
+  private save() {
+    writeFileSync(this.file + ".tmp", JSON.stringify(this.state), {mode:0o600});
+    renameSync(this.file + ".tmp", this.file);
+  }
+  watch(channel: string) {
+    this.channels.add(channel);
+    // First installation/new membership starts now, never replays old requests.
+    if (!Object.hasOwn(this.state.channels, channel)) {
+      this.state.channels[channel] = timestamp(new Date().toISOString()); this.save();
+    }
+  }
+  memberships(channels: string[]) {
+    this.channels.clear();
+    for (const channel of channels) this.watch(channel);
+  }
+  sync(): Promise<void> {
+    if (!this.running) this.running = this.run().finally(() => {this.running = undefined;});
+    return this.running;
+  }
+  private async run() {
+    if (!this.active()) return;
+    let failed = false;
+    for (const channel of [...this.channels]) {
+      if (!this.active()) return;
+      try {
+        const after = this.state.channels[channel]!;
+        const body = await this.api(`/api/channels/${encodeURIComponent(channel)}/messages?after=${encodeURIComponent(after)}&limit=50`);
+        if (!this.active()) return;
+        if (!this.channels.has(channel)) continue;
+        const messages = Array.isArray(body) ? body : body?.messages;
+        if (!Array.isArray(messages)) throw new Error("Invalid history response");
+        const rows = messages.map(m => {
+          if (!m || m.channel_id !== channel || typeof m.id !== "string") throw new Error("Invalid history message");
+          return {message:m, time:timestamp(m.timestamp)};
+        }).sort((a,b) => a.time.localeCompare(b.time));
+        // One bounded page per channel per pass. Full pages continue next pass.
+        // The inbox persists acceptance before we persist this checkpoint.
+        let newest = after, complete = true;
+        for (const {message,time} of rows) {
+          if (time <= after) continue;
+          if (!this.receive(message)) { complete = false; break; }
+          newest = time;
+        }
+        // Commit whole pages so backpressure cannot skip an equal-time sibling.
+        // Already queued rows deduplicate on retry.
+        if (complete) { this.state.channels[channel] = newest; this.save(); }
+      } catch {
+        failed = true;
+        this.log("Inbound history reconciliation failed; checkpoint retained for retry");
+      }
+    }
+    if (!this.active()) return;
+    this.state.last_check_at = new Date().toISOString();
+    if (failed) this.state.last_error = "History reconciliation failed; retry pending";
+    else { this.state.last_success_at = this.state.last_check_at; delete this.state.last_error; }
+    this.save();
+  }
+}

package/codex/manager.ts

@@ -19,7 +19,7 @@ function removeDeadLock(file: string) {
   try { process.kill(pid, 0); } catch (e: any) { if (e.code === "ESRCH") unlinkSync(file); }
 }
 function save() {
-  writeFileSync(statusFile + ".tmp", JSON.stringify({ pid: process.pid, updated_at: new Date().toISOString(), bots: [...workers.values()].map(w => ({ name: w.config.name, agent_id: w.config.agentId, workdir: w.config.cwd, pid: w.child?.pid, status: w.status })) }, null, 2), { mode: 0o600 });
+  writeFileSync(statusFile + ".tmp", JSON.stringify({ pid: process.pid, updated_at: new Date().toISOString(), bots: [...workers.values()].map(w => ({ name: w.config.name, agent_id: w.config.agentId, workdir: w.config.cwd, effort: w.config.effort, pid: w.child?.pid, status: w.status })) }, null, 2), { mode: 0o600 });
   renameSync(statusFile + ".tmp", statusFile);
 }
 async function stop(w: Worker) {

package/codex/run.ts

@@ -25,11 +25,11 @@ CWD/.agentschat/profile.json > CWD/.codex/config.toml MCP profile > AGENTSCHAT_P
 Only the exact CWD is searched. Named profiles live in ~/.agentschat (legacy ~/.agentchat).
 An optional project agent_id must match the selected profile; it cannot replace it.
 Credentials: private profile JSON {agent_id, token}, chmod 600; never put keys in argv.
-Project config fields: profile, agent_id, channels, senders, api_url, ws_url, permissions.
+Project config fields: profile, agent_id, channels, senders, api_url, ws_url, permissions, effort.
 --onboarding-status checks authentication/ownership and prints safe claim/chat links; it does not send messages.
 --check validates identity and official app-server initialization without opening chat.
 Live DMs and exact mentions trigger replies; channels/senders restrict this further.
-All accepted messages share one persisted thread per channel, with full access by default. Set permissions: "read-only" to disable writes and inherited MCP. No offline message replay.
+All accepted messages share one persisted thread per channel, with full access by default. Set permissions: "read-only" to disable writes and inherited MCP. After initial installation, persisted history cursors recover missed messages on reconnect and every minute.
 State: ~/.agentschat/codex-bridge/<project-server-identity hash>/ (private).
 --conversations lists this bot's channel/task mappings; --read-conversation CHANNEL reads history without acquiring a writer.
 GUI outbox: --gui-thread THREAD_ID --gui-message-file PATH; --gui-status lists receipts.
@@ -65,7 +65,7 @@ async function main() {
   }
   console.log(JSON.stringify({ cwd: c.cwd, agent_id: c.agentId, profile: c.profileFile, source: c.source, stateDir: c.stateDir }));
   const runtime = prepareRuntimeHome(c.stateDir);
-  codex = new AppServer(c.codexBin, undefined, undefined, c.permissions, runtime);
+  codex = new AppServer(c.codexBin, undefined, undefined, c.permissions, runtime, c.effort);
   if (values.conversations || values["read-conversation"]) {
     const state = JSON.parse(readFileSync(join(c.stateDir, "state.json"), "utf8"));
     const channels = state.channels ?? {};
@@ -79,7 +79,7 @@ async function main() {
     codex.close(); return;
   }
   if (values.check) { await codex.start(); console.log("Official app-server initialization: OK (no chat connection or generation)"); codex.close(); return; }
-  transport = new AgentsChatTransport(c, m => { bridge!.accept(m); });
+  transport = new AgentsChatTransport(c, m => { bridge!.accept(m); }, console.error, m => bridge!.recover(m));
   bridge = new Bridge(c, codex, (chat, text) => transport!.send(chat, text), console.error, (chat, active) => transport!.setTyping(chat, active), () => getBotOwner(c.apiUrl, c.agentId, c.token), () => transport!.api("/api/loops/mine"));
   let stopping = false;
   const stop = async () => { if (stopping) return; stopping = true; if (values["managed-worker"]) { const deadline = setTimeout(() => { try { process.kill(-process.pid, "SIGKILL"); } catch {} }, 20000); deadline.unref(); } bridge?.pause(); transport?.stop(); codex?.close(); await bridge?.stop(); if (process.connected) process.disconnect?.(); };

package/codex/transport.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import WebSocket from "ws";
 import type { BridgeConfig } from "./config.ts";
 import { HeartbeatMonitor } from "../src/heartbeat.ts";
+import { InboxSync } from "./inbox-sync.ts";
 
 export class AgentsChatTransport {
   private socket?: WebSocket;
@@ -12,7 +13,13 @@ export class AgentsChatTransport {
   private retry?: ReturnType<typeof setTimeout>;
   private closed = false;
   private delay = 1000;
-  constructor(private config: BridgeConfig, private receive: (m: unknown) => void, private log: (s: string) => void = console.error) {}
+  private inboxSync?: InboxSync;
+  private syncTimer?: ReturnType<typeof setInterval>;
+  constructor(private config: BridgeConfig, private receive: (m: unknown) => void, private log: (s: string) => void = console.error,
+    recover?: (m: unknown) => boolean, private syncIntervalMs = 60_000) {
+    if (recover) this.inboxSync = new InboxSync(config.stateDir, path => this.api(path), recover,
+      () => !this.closed && this.authenticated, log);
+  }
   async api(path: string, body?: unknown) {
     let response: Response;
     try {
@@ -62,7 +69,10 @@ export class AgentsChatTransport {
     const current = () => !this.closed && this.socket === socket;
     const send = (value: unknown) => { if (current() && socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(value)); };
     const join = (channel: string) => {
-      if (!this.config.channels.length || this.config.channels.includes(channel)) send({ type: "join_channel", channel_id: channel, agent_id: this.config.agentId });
+      if (!this.config.channels.length || this.config.channels.includes(channel)) {
+        this.inboxSync?.watch(channel);
+        send({ type: "join_channel", channel_id: channel, agent_id: this.config.agentId });
+      }
     };
     this.heartbeat = new HeartbeatMonitor({ getReadyState: () => socket.readyState,
       sendPing: () => send({ type: "ping" }), reconnect: () => socket.terminate() }, 15_000, 45_000, 30_000);
@@ -74,26 +84,31 @@ export class AgentsChatTransport {
       this.heartbeat?.receivedPong();
       if (data.type === "auth_ok") {
         this.authenticated = true; this.delay = 1000; this.log(`AgentsChat connected as ${this.config.agentId}`);
+        if (this.inboxSync && !this.syncTimer) this.syncTimer = setInterval(() => { void this.inboxSync!.sync(); }, this.syncIntervalMs);
         void this.api("/api/channels/mine").then((body: any) => {
           if (!current()) return;
           const channels = Array.isArray(body) ? body : body.channels;
           if (!Array.isArray(channels)) throw new Error("Invalid membership response");
-          for (const c of channels) if (typeof (c.id ?? c.channel_id) === "string") join(c.id ?? c.channel_id);
+          const ids = channels.map((c: any) => c.id ?? c.channel_id).filter((id: any) => typeof id === "string" &&
+            (!this.config.channels.length || this.config.channels.includes(id)));
+          this.inboxSync?.memberships(ids);
+          for (const id of ids) join(id);
+          void this.inboxSync?.sync();
         }).catch(() => { if (current()) { this.log("Membership sync failed; reconnecting"); socket.terminate(); } });
       } else if (data.type === "message_ack") {
         const id = data.message_id ?? data.id, pending = this.pending.get(id);
         if (pending) { clearTimeout(pending.timer); this.pending.delete(id); pending.resolve(); }
       } else if (data.type === "channel_created" && typeof data.channel_id === "string") join(data.channel_id);
       else if (["message", "thread_reply"].includes(data.type)) this.receive(data);
-      else if (data.type === "shard_moved") socket.terminate();
+      else if (data.type === "shard_moved" || data.type === "please_reconnect") socket.terminate();
       else if (data.type === "auth_error" || data.type === "error") this.log("AgentsChat returned an error; check account and channel permissions");
     });
     socket.on("error", () => this.log("AgentsChat socket error"));
     socket.on("close", () => {
       if (!current()) return;
-      this.authenticated = false; this.rejectPending(); this.heartbeat?.stop(); this.log("AgentsChat disconnected; reconnecting (offline messages are not replayed)");
+      this.authenticated = false; this.rejectPending(); this.heartbeat?.stop(); this.log("AgentsChat disconnected; reconnecting with history reconciliation");
       this.retry = setTimeout(() => this.start(), this.delay); this.delay = Math.min(this.delay * 2, 30_000);
     });
   }
-  stop() { for (const timer of this.typing.values()) clearInterval(timer); this.typing.clear(); this.closed = true; this.authenticated = false; this.rejectPending(); clearTimeout(this.retry); this.heartbeat?.stop(); this.socket?.terminate(); }
+  stop() { for (const timer of this.typing.values()) clearInterval(timer); this.typing.clear(); this.closed = true; this.authenticated = false; this.rejectPending(); clearTimeout(this.retry); clearInterval(this.syncTimer); this.heartbeat?.stop(); this.socket?.terminate(); }
 }

package/dist/codex-bots.js

@@ -904,6 +904,13 @@ function parse(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
  */
 
 // codex/config.ts
+function reasoningEffort(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || !value.trim())
+    throw new Error("effort must be a nonempty model-supported reasoning effort name");
+  return value.trim();
+}
 function permissionMode(value) {
   if (value === undefined)
     return "full-access";
@@ -931,7 +938,7 @@ function resolveConfig(opts, env = process.env, home = homedir()) {
   const project = opts.settings ?? (existsSync(configFile) ? readJson(configFile) : {});
   if (!project || typeof project !== "object" || Array.isArray(project))
     throw new Error("Invalid project config");
-  const allowed = new Set(["profile", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions"]);
+  const allowed = new Set(["profile", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"]);
   if (Object.keys(project).some((k) => !allowed.has(k)))
     throw new Error("Unknown project config field (credentials belong in a private profile)");
   for (const k of ["profile", "agent_id", "api_url", "ws_url"])
@@ -1001,6 +1008,7 @@ function resolveConfig(opts, env = process.env, home = homedir()) {
     profileFile,
     source,
     permissions: permissionMode(project.permissions),
+    effort: reasoningEffort(project.effort),
     agentId: profile.agent_id,
     token: profile.token,
     apiUrl: canonicalApi,
@@ -1040,7 +1048,7 @@ function loadBots(file = defaultRegistry(), home = homedir2()) {
   const names = new Set, identities = new Set;
   const bots = [];
   for (const bot of doc.bots) {
-    fields(bot, ["name", "profile", "workdir", "enabled", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions"]);
+    fields(bot, ["name", "profile", "workdir", "enabled", "agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"]);
     if (!text(bot.name) || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(bot.name) || names.has(bot.name))
       throw new Error("Bot names must be unique simple labels");
     names.add(bot.name);
@@ -1056,7 +1064,7 @@ function loadBots(file = defaultRegistry(), home = homedir2()) {
       mkdirSync(defaultDir, { recursive: true, mode: 448 });
     const cwd = realpathSync2(bot.workdir ? path(bot.workdir) : defaultDir);
     const settings = {};
-    for (const k of ["agent_id", "channels", "senders", "api_url", "ws_url", "permissions"])
+    for (const k of ["agent_id", "channels", "senders", "api_url", "ws_url", "permissions", "effort"])
       if (bot[k] !== undefined)
         settings[k] = bot[k];
     const config = resolveConfig({ cwd, profile: bot.profile, settings, codexBin: doc.codex_bin }, {}, home);
@@ -1122,7 +1130,7 @@ function removeDeadLock(file) {
   }
 }
 function save() {
-  writeFileSync(statusFile + ".tmp", JSON.stringify({ pid: process.pid, updated_at: new Date().toISOString(), bots: [...workers.values()].map((w) => ({ name: w.config.name, agent_id: w.config.agentId, workdir: w.config.cwd, pid: w.child?.pid, status: w.status })) }, null, 2), { mode: 384 });
+  writeFileSync(statusFile + ".tmp", JSON.stringify({ pid: process.pid, updated_at: new Date().toISOString(), bots: [...workers.values()].map((w) => ({ name: w.config.name, agent_id: w.config.agentId, workdir: w.config.cwd, effort: w.config.effort, pid: w.child?.pid, status: w.status })) }, null, 2), { mode: 384 });
   renameSync(statusFile + ".tmp", statusFile);
 }
 async function stop(w) {