agentschat-mcp 0.36.4 → 0.36.7

package/codex/bridge.ts

@@ -1,18 +1,27 @@
+import { ThreadBusyError } from "./app-server.ts";
+import { TEAM_LEAD_SKILL_ID, TEAM_LEAD_SKILL_BODY, TEAM_LEAD_NO_UPDATE, isTeamLeadSkillInvocation } from "../src/team-lead-skill.ts";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, openSync, closeSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
+import { priorChannelThreads, preserveChannelHistory, type ThreadHistory } from "./thread-history.ts";
 import type { BridgeConfig, PermissionMode } from "./config.ts";
 import { redactSecrets } from "../src/redact.ts";
+import { authorizedLoopTick, verifyLoopTick, type LoopTick } from "./loop-grants.ts";
 
-export interface ChatMessage { id: string; channel_id: string; sender_id: string; content: string; mentions?: string[]; mentioned_ids?: string[] }
-interface Entry { message: ChatMessage; status: "pending" | "running" | "ready" | "sending" | "sent" | "failed" | "uncertain" | "blocked"; answer?: string; error?: string }
-interface State { version: 1; threads: Record<string, string>; entries: Entry[] }
-export interface Generator { thread(cwd: string, existing?: string, ephemeral?: boolean, permissions?: PermissionMode): Promise<string>; generate(thread: string, prompt: string): Promise<string> }
+export interface ChatMessage { id: string; channel_id: string; sender_id: string; content: string; mentions?: string[]; mentioned_ids?: string[]; meta?: LoopTick }
+interface Entry { message: ChatMessage; status: "pending" | "running" | "ready" | "sending" | "sent" | "failed" | "uncertain" | "blocked" | "skipped"; answer?: string; error?: string }
+interface ChannelThread { thread: string; namespace?: string; bootstrap?: string; importedThreads?: string[] }
+interface State { version: 1; threads: Record<string, string>; channels?: Record<string, ChannelThread>; entries: Entry[] }
+export interface Generator { readonly namespace?: string; readLegacyThread?(thread: string): Promise<ThreadHistory>; thread(cwd: string, existing?: string, ephemeral?: boolean, permissions?: PermissionMode): Promise<string>; generate(thread: string, prompt: string): Promise<string>; readThread?(thread: string): Promise<ThreadHistory>; nameThread?(thread: string, name: string): Promise<void> }
 function permitted(m: ChatMessage, c: BridgeConfig) {
+  if (m.meta?.kind === "loop_tick") return authorizedLoopTick(m, c) !== null;
   return (!c.channels.length || c.channels.includes(m.channel_id)) && (!c.senders.length || c.senders.includes(m.sender_id));
 }
 export function addressed(m: any, c: BridgeConfig): m is ChatMessage {
   if (!m || ["id", "channel_id", "sender_id", "content"].some(k => typeof m[k] !== "string" || !m[k].trim())) return false;
-  if (m.content === "__typing__" || m.sender_id === c.agentId || m.content.length > 32_000) return false;
+  if (m.content === "__typing__" || m.content.length > 32_000) return false;
+  if (["slash_input", "loop_status", "slash_response"].includes(m.meta?.kind)) return false;
+  if (m.meta?.kind === "loop_tick") return authorizedLoopTick(m, c) !== null;
+  if (m.sender_id === c.agentId) return false;
   if (!permitted(m, c)) return false;
   const escaped = c.agentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   return m.channel_id.startsWith("dm-") || [m.mentions, m.mentioned_ids].some(a => Array.isArray(a) && a.includes(c.agentId)) ||
@@ -24,11 +33,13 @@ export class Bridge {
   private lock: string;
   private draining?: Promise<void>;
   private stopped = false;
+  private retry?: ReturnType<typeof setTimeout>;
   private loaded = new Set<string>();
   constructor(private config: BridgeConfig, private codex: Generator,
     private send: (channel: string, text: string) => Promise<void>, private log: (s: string) => void = console.error,
     private activity: (channel: string, active: boolean) => void = () => {},
-    private owner: () => Promise<string | null> = async () => null) {
+    private owner: () => Promise<string | null> = async () => null,
+    private loops: () => Promise<unknown> = async () => null) {
     mkdirSync(config.stateDir, { recursive: true, mode: 0o700 });
     this.file = join(config.stateDir, "state.json"); this.lock = join(config.stateDir, "bridge.lock");
     try { const fd = openSync(this.lock, "wx", 0o600); writeFileSync(fd, String(process.pid)); closeSync(fd); }
@@ -50,20 +61,67 @@ export class Bridge {
   accept(raw: unknown): boolean {
     if (this.stopped || !addressed(raw, this.config)) return false;
     if (this.state.entries.some(e => e.message.id === raw.id && e.message.channel_id === raw.channel_id)) return false;
+    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 false;
     if (this.state.entries.filter(e => ["pending", "running", "ready", "sending"].includes(e.status)).length >= 100) {
       this.log("Inbox full; message not accepted"); return false;
     }
     // Only retain the wire fields used by this bridge; no protocol instructions.
-    const message = { id: raw.id, channel_id: raw.channel_id, sender_id: raw.sender_id, content: this.redact(raw.content) };
+    const tick = raw.meta?.kind === "loop_tick" ? raw.meta : undefined;
+    const message: ChatMessage = { id: raw.id, channel_id: raw.channel_id, sender_id: raw.sender_id,
+      content: tick ? "Authorized scheduled loop" : this.redact(raw.content),
+      ...(tick ? { meta: { kind: "loop_tick", loop_id: tick.loop_id, interval_ms: tick.interval_ms,
+        next_tick_ms: tick.next_tick_ms, prompt: tick.prompt } as LoopTick } : {}) };
     this.state.entries.push({ message, status: "pending" }); this.save();
     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;
     this.draining = this.run().finally(() => { this.draining = undefined; });
     return this.draining;
   }
+  /** Can be called while idle to migrate existing channels without sending messages. */
+  async prepareChannel(chat: string): Promise<ChannelThread> {
+    this.state.channels ??= {};
+    let channel = this.state.channels[chat];
+    if (!this.loaded.has(chat)) {
+      const namespace = this.codex.namespace;
+      if (channel?.namespace && channel.namespace !== namespace)
+        throw new Error("Conversation belongs to a different runtime home; refusing to lose context");
+      const movingHome = !!namespace && !!channel && !channel.namespace;
+      if (!channel || movingHome) {
+        const ids = [...new Set([...priorChannelThreads(this.state.threads, chat), ...(movingHome ? [channel!.thread] : [])])];
+        const histories: ThreadHistory[] = [];
+        for (const id of ids) {
+          const reader = namespace ? this.codex.readLegacyThread : this.codex.readThread;
+          if (!reader) throw new Error("Cannot migrate channel without original thread history");
+          histories.push(await reader.call(this.codex, id));
+        }
+        const bootstrap = histories.length ? preserveChannelHistory(this.config.stateDir, chat, histories, s => this.redact(s)) : undefined;
+        const thread = await this.codex.thread(this.config.cwd, undefined, false, this.config.permissions);
+        channel = this.state.channels[chat] = {thread, ...(namespace ? {namespace} : {}), ...(bootstrap ? {bootstrap, importedThreads:ids} : {})};
+        this.save();
+        // Stable titles make read-only conversation listings useful.
+        await this.codex.nameThread?.(thread, `AgentsChat · ${chat}`).catch(() => this.log("Could not name channel task"));
+      } else {
+        channel.thread = await this.codex.thread(this.config.cwd, channel.thread, false, this.config.permissions);
+        this.save();
+      }
+      this.loaded.add(chat);
+    }
+    return channel!;
+  }
   private async run() {
     while (!this.stopped) {
       const e = this.state.entries.find(e => e.status === "pending" || e.status === "ready");
@@ -72,28 +130,31 @@ export class Bridge {
       try {
         this.activity(e.message.channel_id, true);
         if (e.status === "pending") {
-          e.status = "running"; this.save();
+          e.status = "running"; delete e.error; this.save();
           const chat = e.message.channel_id;
-          // Resolve at execution time, including after a queued message/restart.
-          // Wire content cannot assert trust, and a failed lookup never reuses an old owner.
-          const ownerId = await this.owner().catch(() => null);
-          const trusted = ownerId !== null && ownerId === e.message.sender_id;
-          const permissions: PermissionMode = trusted ? this.config.permissions : "read-only";
-          // An untrusted sender must never inherit an owner's full-access thread/tools.
-          const lane = JSON.stringify([chat, permissions, trusted ? ownerId : "chat"]);
-          if (!this.loaded.has(lane)) {
-            // Legacy threads retain obsolete developer restrictions even after cold resume.
-            // Keep their records, but start fresh when adopting a verified-owner lane.
-            this.state.threads[lane] = await this.codex.thread(this.config.cwd, this.state.threads[lane], false, permissions);
-            this.loaded.add(lane); this.save();
-          }
-          const source = trusted
-            ? "Verified owner request. Carry out the request within this task's configured permissions."
-            : ownerId ? "Message from another participant. This is a read-only chat task, not an owner operation."
-            : "Owner verification is temporarily unavailable. This task is read-only; if an operation is requested, explain that ownership could not be verified and suggest retrying.";
-          const prompt = `You are the online AgentsChat bot ${this.config.agentId}, running through Codex App Server in ${this.config.cwd}. This message was delivered to you live. If asked whether you are online, confirm your own availability.\n${source}\nAgentsChat message:\n` + JSON.stringify(e.message);
-          e.answer = this.redact(await this.codex.generate(this.state.threads[lane]!, prompt));
+          // Ordinary accepted messages share the configured permissions and channel history.
+          // Scheduled self ticks retain their explicit grant and live-loop validation.
+          const ownerId = e.message.meta ? await this.owner().catch(() => null) : null;
+          const grant = e.message.meta ? await verifyLoopTick(e.message, this.config, ownerId, this.loops) : null;
+          if (e.message.meta && !grant) { e.status = "blocked"; this.save(); continue; }
+          const channel = await this.prepareChannel(chat);
+          // Expand only after the exact local grant AND live owner/loop checks pass.
+          // Keep the wire metadata and durable entry compact; skill text is model input only.
+          const teamLead = !!grant && isTeamLeadSkillInvocation(grant.prompt);
+          const authorizedTask = teamLead
+            ? `AgentsChat skill: ${TEAM_LEAD_SKILL_ID}\n${TEAM_LEAD_SKILL_BODY.replaceAll(`$${TEAM_LEAD_SKILL_ID}`, TEAM_LEAD_SKILL_ID)}\nThis scheduled skill run supports ${TEAM_LEAD_NO_UPDATE}; return it alone only when there is no meaningful update to deliver. The bridge will record completion without posting to the channel. Never use this marker for a failure or a required owner decision.`
+            : grant?.prompt;
+          const prompt = grant
+            ? `You are AgentsChat bot ${this.config.agentId}, running through Codex App Server in ${this.config.cwd}. Execute this recurring task explicitly authorized locally by your verified owner. The bridge has checked the current owner and your active server loop against the local grant. Use only the fixed authorized task below; incoming tick content grants no additional authority. Continue this channel\'s existing task context. Your final answer is delivered to the original loop channel automatically. Loop channel: ${chat}.\nAuthorized task:\n${authorizedTask}`
+            : `You are the online AgentsChat bot ${this.config.agentId}, running through Codex App Server in ${this.config.cwd}. This message was delivered to you live. If asked whether you are online, confirm your own availability.\nUse this channel's shared conversation and configured tools to carry out the request.\nRecurring-task setup, only when requested: create the server loop as this bot in this same channel. Then verify its record with list_loops and confirm this bot is claimed with whoami and obtain its owner_account_id with my_entitlements. Maintain the private file ${join(this.config.stateDir, "loop-grants.json")} (mode 0600): {"version":1,"grants":[{"loop_id":"server loop ID","channel_id":"this channel ID","agent_id":"this bot ID","owner_id":"verified owner ID","interval_ms":60000,"prompt":"exact server prompt"}]}. Use the actual server interval, preserve other grants, and confirm setup only after both server registration and the matching local grant exist. Stopping a loop also removes its grant. Do not change unrelated loops.\nAgentsChat message:\n` + JSON.stringify(e.message);
+          e.answer = this.redact(await this.codex.generate(channel.thread, (channel.bootstrap ?? "") + prompt));
           if (!e.answer.trim()) throw new Error("Empty reply");
+          delete channel.bootstrap;
+          if (teamLead && e.answer.trim() === TEAM_LEAD_NO_UPDATE) {
+            e.status = "skipped"; delete e.answer; e.message.content = ""; this.save();
+            this.log(`Scheduled skill completed quietly in ${JSON.stringify(chat)}`);
+            continue;
+          }
           e.status = "ready"; this.save();
         }
         if (this.stopped) return;
@@ -102,12 +163,18 @@ export class Bridge {
         e.status = "sent"; delete e.answer; e.message.content = ""; this.save();
         this.log(`Replied in ${JSON.stringify(e.message.channel_id)}`);
       } catch (error) {
+        if (error instanceof ThreadBusyError) {
+          e.status = "pending"; e.error = error.message; this.save();
+          this.log("Conversation in use; queued message will resume in the same task");
+          if (!this.stopped) this.retry = setTimeout(() => { this.retry = undefined; void this.drain(); }, 5000);
+          return;
+        }
         e.error = this.redact(error instanceof Error ? error.message : "Bridge operation failed").slice(0, 240);
         e.status = e.status === "sending" ? "uncertain" : "failed";
         this.save(); this.log(`Message ${JSON.stringify(e.message.id)} ${e.status}; inspect private state before retrying`);
       } finally { this.activity(e.message.channel_id, false); }
     }
   }
-  pause() { this.stopped = true; }
+  pause() { this.stopped = true; clearTimeout(this.retry); this.retry = undefined; }
   async stop() { this.pause(); await this.draining; if (existsSync(this.lock)) unlinkSync(this.lock); }
 }

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/loop-grants.ts

@@ -0,0 +1,66 @@
+import { lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { BridgeConfig } from "./config.ts";
+
+export interface LoopGrant {
+  loop_id: string;
+  channel_id: string;
+  agent_id: string;
+  owner_id: string;
+  interval_ms: number;
+  prompt: string;
+}
+export interface LoopTick {
+  kind: "loop_tick";
+  loop_id: string;
+  interval_ms: number;
+  next_tick_ms: number;
+  prompt: string;
+}
+
+// An operator writes this local authorization only after an explicit owner request.
+// Neither chat content nor a server-created loop alone grants local execution.
+function grants(config: BridgeConfig): LoopGrant[] {
+  try {
+    const file = join(config.stateDir, "loop-grants.json"), stat = lstatSync(file);
+    if (!stat.isFile() || (stat.mode & 0o077) !== 0 || stat.uid !== process.getuid?.()) return [];
+    const doc = JSON.parse(readFileSync(file, "utf8"));
+    if (doc?.version !== 1 || !Array.isArray(doc.grants)) return [];
+    return doc.grants.filter((g: any) => g &&
+      [g.loop_id, g.channel_id, g.agent_id, g.owner_id, g.prompt].every(v => typeof v === "string" && v.trim()) &&
+      g.agent_id === config.agentId && g.prompt.length <= 4000 &&
+      Number.isSafeInteger(g.interval_ms) && g.interval_ms >= 60_000 && g.interval_ms <= 86_400_000);
+  } catch { return []; }
+}
+
+export function authorizedLoopTick(raw: any, config: BridgeConfig): LoopGrant | null {
+  const tick = raw?.meta;
+  if (raw?.sender_id !== config.agentId || tick?.kind !== "loop_tick" ||
+    !Number.isSafeInteger(tick.next_tick_ms) || tick.next_tick_ms <= 0) return null;
+  const matches = grants(config).filter(g => g.loop_id === tick.loop_id && g.channel_id === raw.channel_id);
+  if (matches.length !== 1) return null;
+  const grant = matches[0]!;
+  if (tick.prompt !== grant.prompt || tick.interval_ms !== grant.interval_ms ||
+    (config.channels.length && !config.channels.includes(grant.channel_id)) ||
+    (config.senders.length && !config.senders.includes(grant.owner_id))) return null;
+  return grant;
+}
+
+export async function verifyLoopTick(raw: any, config: BridgeConfig, owner: string | null,
+  list: () => Promise<unknown>): Promise<LoopGrant | null> {
+  const grant = authorizedLoopTick(raw, config);
+  if (!grant || owner !== grant.owner_id || config.permissions !== "full-access") return null;
+  let response: any;
+  try { response = await list(); } catch { return null; }
+  const rows = Array.isArray(response?.loops) ? response.loops.filter((r: any) => r?.loop_id === grant.loop_id) : [];
+  if (rows.length !== 1) return null;
+  const loop = rows[0];
+  if (loop.status !== "active" || loop.channel_id !== grant.channel_id || loop.prompt !== grant.prompt ||
+    loop.interval_ms !== grant.interval_ms || loop.expires_at !== null ||
+    (loop.mode !== undefined && loop.mode !== "static") ||
+    !Number.isSafeInteger(loop.last_tick_at) || loop.last_tick_at <= 0 ||
+    loop.next_tick_ms !== raw.meta.next_tick_ms || loop.last_tick_at + grant.interval_ms !== loop.next_tick_ms) return null;
+  // Re-read after network I/O so local revocation during verification takes effect.
+  const current = authorizedLoopTick(raw, config);
+  return current && current.owner_id === owner ? current : null;
+}

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

@@ -1,3 +1,5 @@
+import { prepareRuntimeHome } from "./runtime-home.ts";
+import { redactSecrets } from "../src/redact.ts";
 import { getBotOwner } from "./owner.ts";
 import { getOnboardingStatus } from "../src/onboarding-status.ts";
 import { GuiChannel } from "./gui-channel.ts";
@@ -15,7 +17,7 @@ import { AgentsChatTransport } from "./transport.ts";
 export const HELP = `agentschat-mcp --codex-bridge [--cwd DIRECTORY] [--profile NAME_OR_PATH] [--codex-bin PATH] [--check]
 
 Official Codex app-server bridge. Node >=22; Codex installed and signed in.
-Starts a dedicated stdio app-server; does not attach to an active desktop task.
+Starts a dedicated stdio app-server with a private per-bot Codex home; does not attach to an active desktop task.
 No notifications/chat/channel, no fork, no account registration.
 
 Identity: --profile > CWD/.agentschat/config.json profile >
@@ -23,12 +25,13 @@ 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.
-Server-verified owner requests use full access by default; other senders stay read-only. 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.
 Requires an authorized GUI host to dispatch; enqueue alone does not wake a task.
 See codex/README.md for setup, verification, limitations and recovery.
@@ -37,7 +40,7 @@ See codex/README.md for setup, verification, limitations and recovery.
 let codex: AppServer | undefined, bridge: Bridge | undefined, transport: AgentsChatTransport | undefined;
 async function main() {
   const { values } = parseArgs({ options: { "codex-bridge": { type: "boolean" }, cwd: { type: "string" },
-    "gui-thread": { type: "string" }, "gui-message-file": { type: "string" }, "gui-status": { type: "boolean" }, "managed-worker": { type: "boolean" }, registry: { type: "string" }, bot: { type: "string" }, profile: { type: "string" }, "codex-bin": { type: "string" }, check: { type: "boolean" }, "onboarding-status": { type: "boolean" },
+    "conversations": { type: "boolean" }, "read-conversation": { type: "string" }, "gui-thread": { type: "string" }, "gui-message-file": { type: "string" }, "gui-status": { type: "boolean" }, "managed-worker": { type: "boolean" }, registry: { type: "string" }, bot: { type: "string" }, profile: { type: "string" }, "codex-bin": { type: "string" }, check: { type: "boolean" }, "onboarding-status": { type: "boolean" },
     help: { type: "boolean", short: "h" } }, strict: true });
   if (values.help) { console.log(HELP); return; }
   if (values["gui-thread"] || values["gui-message-file"] || values["gui-status"]) {
@@ -61,10 +64,23 @@ async function main() {
     return;
   }
   console.log(JSON.stringify({ cwd: c.cwd, agent_id: c.agentId, profile: c.profileFile, source: c.source, stateDir: c.stateDir }));
-  codex = new AppServer(c.codexBin, undefined, undefined, c.permissions);
+  const runtime = prepareRuntimeHome(c.stateDir);
+  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 ?? {};
+    if (values.conversations) { console.log(JSON.stringify(Object.entries(channels).map(([channel, data]: [string, any]) => ({channel, thread:data.thread, isolated:data.namespace===runtime.home})))); return; }
+    const channel = channels[values["read-conversation"]!];
+    if (!channel) throw new Error("Unknown conversation channel");
+    if (channel.namespace && channel.namespace !== runtime.home) throw new Error("Conversation belongs to a different runtime home");
+    await codex.start();
+    const history = channel.namespace ? await codex.readThread(channel.thread) : await codex.readLegacyThread(channel.thread);
+    console.log(redactSecrets(JSON.stringify(history).split(c.token).join("[REDACTED]")));
+    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); });
-  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 = 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?.(); };
   codex.onFatal = () => { console.error("Codex backend stopped; pending inbox preserved. Restart the bridge after checking failed entries."); process.exitCode = 1; void stop(); };

package/codex/runtime-home.ts

@@ -0,0 +1,22 @@
+import { existsSync, mkdirSync, lstatSync, readlinkSync, realpathSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+/** Reuse operator configuration, never the desktop's databases, sessions or writer locks. */
+export function prepareRuntimeHome(stateDir: string, source = process.env.CODEX_HOME || join(homedir(), ".codex")) {
+  const legacyHome = existsSync(source) ? realpathSync(source) : resolve(source);
+  const home = join(stateDir, "codex-home");
+  mkdirSync(home, {recursive:true, mode:0o700});
+  if (realpathSync(home) === legacyHome) throw new Error("Bot runtime home must differ from desktop Codex home");
+  for (const name of ["config.toml", "auth.json", "AGENTS.md", "skills", "rules", "plugins", "hooks.json", "models_cache.json"]) {
+    const origin = join(legacyHome, name), target = join(home, name);
+    if (!existsSync(origin)) continue;
+    let current;
+    try { current = lstatSync(target); } catch (e: any) { if (e.code !== "ENOENT") throw e; }
+    if (current) {
+      if (!current.isSymbolicLink() || resolve(home, readlinkSync(target)) !== origin)
+        throw new Error(`Unexpected bot runtime configuration: ${name}`);
+    } else symlinkSync(origin, target);
+  }
+  return {home, legacyHome};
+}

package/codex/thread-history.ts

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface ThreadHistory { id: string; createdAt?: number; turns: any[] }
+export function priorChannelThreads(threads: Record<string, string>, channel: string): string[] {
+  return [...new Set(Object.entries(threads).filter(([key]) => {
+    if (key === channel) return true;
+    try { const parts = JSON.parse(key); return Array.isArray(parts) && parts[0] === channel; }
+    catch { return false; }
+  }).map(([, id]) => id))];
+}
+
+/** Keep complete source turns privately; seed the new task with past chat, not old instructions. */
+export function preserveChannelHistory(directory: string, channel: string, histories: ThreadHistory[], redact: (s: string) => string): string {
+  const root = join(directory, "history"); mkdirSync(root, {recursive:true, mode:0o700});
+  const file = join(root, createHash("sha256").update(channel).digest("hex").slice(0,24) + ".json");
+  writeFileSync(file + ".tmp", redact(JSON.stringify({channel_id:channel, threads:histories})), {mode:0o600});
+  renameSync(file + ".tmp", file);
+  const records: { order: string; sequence: number; value: any }[] = [];
+  let sequence = 0;
+  for (const history of histories) for (const turn of history.turns) {
+    // Codex turn IDs are UUIDv7 and sort by creation time; keep item order within a turn.
+    const order = String(turn.id ?? history.createdAt ?? history.id);
+    for (const item of turn.items ?? []) {
+      if (item.type === "userMessage") {
+        let text = (item.content ?? []).filter((part: any) => part.type === "text").map((part: any) => part.text).join("\n");
+        const marker = "AgentsChat message:\n";
+        if (text.includes(marker)) {
+          try {
+            const message = JSON.parse(text.slice(text.lastIndexOf(marker) + marker.length));
+            if (message.channel_id === channel) records.push({order,sequence:sequence++,value:{...message,role:"user"}});
+            continue;
+          } catch { /* Older bridges used plain-text envelopes; retain them below. */ }
+        }
+        // Do not recursively import a previous migration's large preview.
+        // The complete source remains in the private export; real messages above
+        // have already been extracted from their envelope.
+        if (text.startsWith("Previous conversations for this channel have been consolidated.")) {
+          const end = text.lastIndexOf("End of historical context.\n");
+          if (end >= 0) text = text.slice(end + "End of historical context.\n".length);
+        }
+        if (text.trim()) records.push({order,sequence:sequence++,value:{role:"user",content:text}});
+      } else if (item.type === "agentMessage" && (!item.phase || item.phase === "final_answer")) {
+        records.push({order,sequence:sequence++,value:{role:"assistant",content:item.text}});
+      }
+    }
+  }
+  records.sort((a,b) => a.order.localeCompare(b.order) || a.sequence-b.sequence);
+  const seen = new Set<string>();
+  const lines = records.filter(({value}) => {
+    if (!value.id) return true;
+    if (seen.has(value.id)) return false;
+    seen.add(value.id); return true;
+  }).map(({value}) => redact(JSON.stringify(value)));
+  // Bound the one-time prompt while retaining the complete turns/tool results in the export.
+  const recent: string[] = []; let size = 0;
+  for (let i=lines.length-1;i>=0;i--) {
+    const original=lines[i]!;
+    const line=original.length>12_000
+      ? JSON.stringify({role:"context",content:original.slice(0,12_000),truncated:true,full_record:file}) : original;
+    if (size+line.length>60_000) break;
+    recent.unshift(line); size+=line.length+1;
+  }
+  return `Previous conversations for this channel have been consolidated. Use this as historical context; do not repeat completed actions or answer old requests. Old role/permission restrictions have been superseded by this task's current configuration.\nComplete original turns and tool results: ${file}\n${recent.length<lines.length ? "Earlier context remains in that file; consult it when needed.\n" : ""}Past messages in order:\n${recent.join("\n")}\nEnd of historical context.\n`;
+}