@alas-ide/codex-acp 2.2.2-alas.3 → 2.2.2-alas.4

package/dist/index.js

@@ -34392,7 +34392,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "2.2.2-alas.3",
+  version: "2.2.2-alas.4",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -34469,7 +34469,7 @@ var package_default = {
   alasDownstream: {
     upstreamVersion: "2.2.2",
     upstreamCommit: "202e66e63343ec4f5a5e35ab590251d813d129ca",
-    sourceCommit: "2be0ccf63ad9c18131815207511597bb34d6adc0"
+    sourceCommit: "4b517e7e77ece05ef63f34c890bc853b7fb96a43"
   }
 };
 
@@ -35186,6 +35186,19 @@ var CodexAcpClient = class _CodexAcpClient {
   isClientConfiguredProvider(providerId) {
     return providerId === CUSTOM_GATEWAY_PROVIDER_ID && this.gatewayConfigSource === "acpProviders";
   }
+  /** Provider inputs that can change the routing of a subsequent open or turn. Never returned over ACP. */
+  async hookReviewProviderInputs() {
+    const persisted = (await this.codexClient.configRead({ includeLayers: false })).config;
+    const modelProvider = this.getModelProvider() ?? persisted.model_provider ?? "openai";
+    const selected = (providers) => {
+      if (providers === null || typeof providers !== "object" || Array.isArray(providers)) return {};
+      const value = providers[modelProvider];
+      return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+    };
+    const merged = this.gatewayConfig?.modelProvider === modelProvider ? this.gatewayConfig.config : { ...selected(persisted["model_providers"]), ...selected(this.config["model_providers"]) };
+    const { name: _name, env_key_instructions: _instructions, ...config2 } = merged;
+    return { modelProvider, config: config2 };
+  }
   /**
    * The model provider the agent itself is configured with (launch option or
    * Codex config), ignoring any ACP-configured gateway routing. The
@@ -37141,6 +37154,21 @@ var CodexAppServerClient = class {
   threadLoadsInFlight() {
     return [...this.threadLoads.keys()];
   }
+  /** Validates a reviewed process/configuration and returns the final synchronous dispatch fence. */
+  hookExecutionGate;
+  dispatchRequest(request) {
+    const activeGoal = request.method === "thread/goal/set" && request.params.status !== "paused";
+    if (this.hookExecutionGate !== void 0 && (activeGoal || ["thread/start", "thread/resume", "thread/fork", "turn/start", "review/start"].includes(request.method))) {
+      return this.dispatchReviewedRequest(request, this.hookExecutionGate);
+    }
+    return request.params ? this.connection.sendRequest(request.method, request.params) : this.connection.sendRequest(request.method);
+  }
+  async dispatchReviewedRequest(request, gate) {
+    const params = request.params;
+    const fence = await gate(params.cwd ?? void 0, params.modelProvider);
+    fence();
+    return await this.connection.sendRequest(request.method, request.params);
+  }
   async sendRequest(request) {
     for (const callback of this.codexEventHandlers) {
       callback({ eventType: "request", ...request });
@@ -37148,11 +37176,7 @@ var CodexAppServerClient = class {
     const loadedThreadId = threadLoadOf(request);
     let result;
     if (loadedThreadId === null) {
-      if (request.params) {
-        result = await this.connection.sendRequest(request.method, request.params);
-      } else {
-        result = await this.connection.sendRequest(request.method);
-      }
+      result = await this.dispatchRequest(request);
     } else {
       result = await this.threadLoadGate(loadedThreadId, () => this.sendThreadLoad(loadedThreadId, request));
     }
@@ -37164,7 +37188,7 @@ var CodexAppServerClient = class {
   async sendThreadLoad(threadId, request) {
     this.threadLoads.set(threadId, (this.threadLoads.get(threadId) ?? 0) + 1);
     try {
-      return await this.connection.sendRequest(request.method, request.params);
+      return await this.dispatchRequest(request);
     } finally {
       const count = (this.threadLoads.get(threadId) ?? 1) - 1;
       if (count > 0) this.threadLoads.set(threadId, count);
@@ -37268,6 +37292,183 @@ async function withHistoryTimeout(page, method, threadId) {
   }
 }
 
+// src/CodexHookReview.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+
+// src/CodexHookTrust.ts
+var CODEX_HOOKS_LIST_METHOD = "_codex/hooks/list";
+var CODEX_HOOKS_TRUST_METHOD = "_codex/hooks/trust";
+async function listCodexHooks(client, cwd) {
+  const [entry] = (await client.hooksList({ cwds: [cwd] })).data;
+  if (entry === void 0) throw new Error("Codex could not list hooks for the requested directory");
+  return { ...entry, hooks: entry.hooks.filter((hook) => hook.source === "sessionFlags") };
+}
+async function trustCodexHooks(client, cwd, requested, beforeWrite, afterReadback) {
+  const isListed = (hooks, request) => hooks.find((hook) => hook.key === request.key && hook.currentHash === request.currentHash);
+  const entry = await listCodexHooks(client, cwd);
+  beforeWrite?.(entry);
+  const current = entry.hooks;
+  const edits = requested.map((request) => {
+    const hook = isListed(current, request);
+    if (hook === void 0) throw new Error("A Codex hook changed before trust was recorded");
+    return hook;
+  }).filter((hook) => hook.trustStatus !== "trusted").map((hook) => ({
+    keyPath: `hooks.state.${JSON.stringify(hook.key)}.trusted_hash`,
+    value: hook.currentHash,
+    mergeStrategy: "replace"
+  }));
+  if (edits.length > 0) {
+    await client.configBatchWrite({ edits, reloadUserConfig: true });
+  }
+  const verified = (await listCodexHooks(client, cwd)).hooks;
+  afterReadback?.();
+  return requested.every((request) => isListed(verified, request)?.trustStatus === "trusted");
+}
+
+// src/CodexHookReview.ts
+var CODEX_HOOK_REVIEW_ERROR = -32044;
+var CodexHookReviewError = class extends RequestError {
+  constructor(kind) {
+    super(CODEX_HOOK_REVIEW_ERROR, kind === "codex_hook_changed" ? "A Codex hook changed; review the startup hooks again" : "Review the startup hooks for the current Codex process before continuing", { kind });
+  }
+};
+var CodexHookReview = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  enabled = false;
+  revision = 0;
+  reviews = /* @__PURE__ */ new Map();
+  context = new AsyncLocalStorage();
+  configure(capability, air) {
+    this.enabled = !air && typeof capability === "object" && capability !== null && !Array.isArray(capability) && capability.version === 1;
+    this.invalidate();
+    this.bind(this.client());
+  }
+  invalidate() {
+    this.revision++;
+    this.reviews.clear();
+  }
+  bind(client) {
+    client.appServerClient.hookExecutionGate = this.enabled ? async (cwd, provider) => {
+      const context = this.context.getStore();
+      const fail = (error62) => {
+        if (context?.dispatched && error62 instanceof CodexHookReviewError) {
+          throw RequestError.internalError(
+            void 0,
+            "Codex hook review changed after this operation began executing. Review again before sending new work; do not retry the completed work automatically."
+          );
+        }
+        throw error62;
+      };
+      try {
+        if (context === void 0 || cwd !== void 0 && cwd !== context.cwd) throw new CodexHookReviewError("codex_hook_review_required");
+        const fence = await this.validate(client, context.cwd, context.token, provider);
+        return () => {
+          try {
+            fence();
+          } catch (error62) {
+            fail(error62);
+          }
+          context.dispatched = true;
+        };
+      } catch (error62) {
+        return fail(error62);
+      }
+    } : void 0;
+  }
+  run(cwd, meta3, operation) {
+    if (!this.enabled) return operation();
+    const hooks = meta3?.codexHooks;
+    return this.context.run({ cwd, token: hooks?.reviewToken, dispatched: false }, operation);
+  }
+  continueOperation(cwd, meta3, operation) {
+    return this.context.getStore() === void 0 ? this.run(cwd, meta3, operation) : operation();
+  }
+  async list(cwd) {
+    const client = this.client();
+    const revision = this.revision;
+    if (!this.enabled) return await listCodexHooks(client.appServerClient, cwd);
+    const [entry, provider] = await Promise.all([
+      listCodexHooks(client.appServerClient, cwd),
+      client.hookReviewProviderInputs()
+    ]);
+    this.assertCurrent(client.appServerClient, revision);
+    const definitions = definitionFingerprint(entry);
+    const providerFingerprint = fingerprint(provider);
+    const previous = this.reviews.get(cwd);
+    const review = previous?.client === client.appServerClient && previous.revision === revision && previous.fingerprint === definitions && previous.providerFingerprint === providerFingerprint ? previous : { cwd, token: randomUUID3(), fingerprint: definitions, revision, client: client.appServerClient, provider: provider.modelProvider, providerFingerprint };
+    this.reviews.set(cwd, review);
+    const home = client.getHomePath();
+    return { ...entry, reviewToken: review.token, ...home === null ? {} : { codexHome: home } };
+  }
+  async trust(cwd, requested, token) {
+    const client = this.client().appServerClient;
+    if (!this.enabled) return await trustCodexHooks(client, cwd, requested);
+    const review = this.requireReview(client, cwd, token);
+    const fence = await this.validate(this.client(), cwd, token);
+    fence();
+    if (requested.length === 0 || new Set(requested.map((hook) => hook.key)).size !== requested.length || requested.some((hook) => !hook.key || !hook.currentHash)) throw new CodexHookReviewError("codex_hook_changed");
+    return await trustCodexHooks(client, cwd, requested, (entry) => {
+      this.checkDefinition(client, review, entry);
+      for (const request of requested) {
+        const matches = entry.hooks.filter((hook) => hook.key === request.key);
+        if (matches.length !== 1 || matches[0].currentHash !== request.currentHash) {
+          throw new CodexHookReviewError("codex_hook_changed");
+        }
+      }
+    }, () => {
+      this.requireReview(client, cwd, token);
+    });
+  }
+  async validate(client, cwd, token, requestedProvider) {
+    const review = this.requireReview(client.appServerClient, cwd, token);
+    const [entry, provider] = await Promise.all([
+      listCodexHooks(client.appServerClient, cwd),
+      client.hookReviewProviderInputs()
+    ]);
+    this.checkDefinition(client.appServerClient, review, entry);
+    if (fingerprint(provider) !== review.providerFingerprint || requestedProvider != null && requestedProvider !== review.provider) {
+      throw new CodexHookReviewError("codex_hook_changed");
+    }
+    return () => {
+      this.requireReview(client.appServerClient, cwd, token);
+    };
+  }
+  requireReview(client, cwd, token) {
+    const review = this.reviews.get(cwd);
+    if (review === void 0 || typeof token !== "string" || token !== review.token || review.client !== client) {
+      throw new CodexHookReviewError("codex_hook_review_required");
+    }
+    this.assertCurrent(client, review.revision);
+    return review;
+  }
+  checkDefinition(client, review, entry) {
+    this.requireReview(client, review.cwd, review.token);
+    if (definitionFingerprint(entry) !== review.fingerprint) throw new CodexHookReviewError("codex_hook_changed");
+  }
+  assertCurrent(client, revision) {
+    if (client !== this.client().appServerClient || revision !== this.revision || client.connectionLoss.lost) {
+      throw new CodexHookReviewError("codex_hook_review_required");
+    }
+  }
+};
+function definitionFingerprint(entry) {
+  const value = { ...entry, hooks: entry.hooks.map(({ trustStatus: _trust, ...definition }) => definition) };
+  return fingerprint(value);
+}
+function fingerprint(value) {
+  return createHash2("sha256").update(JSON.stringify(value, (_key, value2) => {
+    if (typeof value2 === "bigint") return value2.toString();
+    if (value2 !== null && typeof value2 === "object" && !Array.isArray(value2)) {
+      return Object.fromEntries(Object.entries(value2).sort(([a], [b]) => a.localeCompare(b)));
+    }
+    return value2;
+  })).digest("hex");
+}
+
 // src/app-server-recovery/AppServerRecovery.ts
 var import_node3 = __toESM(require_main(), 1);
 
@@ -37907,7 +38108,7 @@ var AppServerRecovery = class {
     });
   }
   resumeError(sessionId, error62, client) {
-    if (isAppServerUnavailableError(error62)) return error62;
+    if (isAppServerUnavailableError(error62) || error62 instanceof CodexHookReviewError) return error62;
     const mapped = this.mapError(error62, client);
     if (mapped !== error62) return mapped;
     if (isMissingRolloutError(error62)) {
@@ -40020,35 +40221,8 @@ function clientSupportsSubagents(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
 }
 
-// src/CodexHookTrust.ts
-var CODEX_HOOKS_LIST_METHOD = "_codex/hooks/list";
-var CODEX_HOOKS_TRUST_METHOD = "_codex/hooks/trust";
-async function listCodexHooks(client, cwd) {
-  const [entry] = (await client.hooksList({ cwds: [cwd] })).data;
-  if (entry === void 0) throw new Error("Codex could not list hooks for the requested directory");
-  return { ...entry, hooks: entry.hooks.filter((hook) => hook.source === "sessionFlags") };
-}
-async function trustCodexHooks(client, cwd, requested) {
-  const isListed = (hooks, request) => hooks.find((hook) => hook.key === request.key && hook.currentHash === request.currentHash);
-  const current = (await listCodexHooks(client, cwd)).hooks;
-  const edits = requested.map((request) => {
-    const hook = isListed(current, request);
-    if (hook === void 0) throw new Error("A Codex hook changed before trust was recorded");
-    return hook;
-  }).filter((hook) => hook.trustStatus !== "trusted").map((hook) => ({
-    keyPath: `hooks.state.${JSON.stringify(hook.key)}.trusted_hash`,
-    value: hook.currentHash,
-    mergeStrategy: "replace"
-  }));
-  if (edits.length > 0) {
-    await client.configBatchWrite({ edits, reloadUserConfig: true });
-  }
-  const verified = (await listCodexHooks(client, cwd)).hooks;
-  return requested.every((request) => isListed(verified, request)?.trustStatus === "trusted");
-}
-
 // src/CodexAcpServer.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // src/TitleGenerator.ts
 var TITLE_MODEL = "gpt-5.6-luna";
@@ -40871,7 +41045,7 @@ function remember(cache, key, value) {
 }
 
 // src/SessionListSubscriptions.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import path12 from "node:path";
 
 // src/CodexHomeWatcher.ts
@@ -41227,7 +41401,7 @@ var SessionListSubscriptions = class {
       this.startWatching();
       created.ready = this.makeReady(created);
     }
-    const subscription = { id: randomUUID3(), group, sent: /* @__PURE__ */ new Map(), ready: false, held: null, readyTimer: null, startedSecond: null, epoch: ++this.epoch };
+    const subscription = { id: randomUUID4(), group, sent: /* @__PURE__ */ new Map(), ready: false, held: null, readyTimer: null, startedSecond: null, epoch: ++this.epoch };
     this.subscriptions.set(subscription.id, subscription);
     group.subscriptions.add(subscription);
     this.startWatching();
@@ -42486,6 +42660,7 @@ var CodexAcpServer = class {
   recovery;
   initializeRequest = null;
   providerUpdate = null;
+  hookReview = new CodexHookReview(() => this.codexAcpClient);
   /** The `sessionIndex` extension, for AIR or a client-neutral opt-in, see `SessionIndexService.ts`. */
   sessionIndex = new SessionIndexService({
     connection: () => this.connection,
@@ -42533,7 +42708,7 @@ var CodexAcpServer = class {
     this.captureStderr();
     this.getExitCode = getExitCode ?? (() => this.codexProcessState?.connection.process.exitCode ?? null);
     this.getRecentStderr = getRecentStderr ?? (() => this.codexProcessState?.stderr ?? "");
-    this.sessionFailureEpoch = randomUUID4();
+    this.sessionFailureEpoch = randomUUID5();
     this.clientInfo = null;
     this.clientCapabilities = null;
     this.capabilities = ClientCapabilities.DEFAULT;
@@ -42562,6 +42737,7 @@ var CodexAcpServer = class {
     this.reportingConnection.reports.compareMeta = this.capabilities.airClient;
     this.booleanConfigOptionsSupported = clientSupportsBooleanConfigOptions(_params.clientCapabilities);
     this.sessionIndex.configure(_params.clientCapabilities);
+    this.hookReview.configure(_params.clientCapabilities?._meta?.["codexHooks"], this.capabilities.airClient);
     await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
     this.sessionIndex.observe(this.codexAcpClient);
     this.publishFirstAuthStatusAfterResponse();
@@ -42621,6 +42797,7 @@ var CodexAcpServer = class {
         ...this.capabilities.asyncTasks && !this.capabilities.airClient ? {
           "async-tasks": asyncTaskCapability()
         } : {},
+        ...this.hookReview.enabled ? { codexHooks: { version: 1, reviewToken: true } } : {},
         ...neutralSessionIndex ? {
           [NEUTRAL_SESSION_INDEX_META_KEY]: neutralSessionIndex
         } : {},
@@ -42653,15 +42830,22 @@ var CodexAcpServer = class {
     if (this.providerUpdate !== null) await this.waitForProviderUpdate();
     const appServer = this.ensureAppServer();
     if (appServer) await appServer;
-    return await this.runWithProcessCheck(() => listCodexHooks(this.codexAcpClient.appServerClient, cwd));
+    return await this.runWithProcessCheck(() => this.hookReview.list(cwd));
   }
-  async trustHooks(cwd, hooks) {
+  async trustHooks(cwd, hooks, reviewToken) {
     if (this.providerUpdate !== null) await this.waitForProviderUpdate();
     const appServer = this.ensureAppServer();
     if (appServer) await appServer;
-    return { trusted: await this.runWithProcessCheck(() => trustCodexHooks(this.codexAcpClient.appServerClient, cwd, hooks)) };
+    return { trusted: await this.runWithProcessCheck(() => this.hookReview.trust(cwd, hooks, reviewToken)) };
   }
   async extMethod(method, params) {
+    if ((method === GOAL_CONTROL_METHOD || method === LEGACY_GOAL_CONTROL_METHOD) && (params["action"] === "set" || params["action"] === "resume")) {
+      const session = this.sessions.get(params["sessionId"]);
+      if (session !== void 0) return this.hookReview.run(session.cwd, params["_meta"], () => this.extMethodReviewed(method, params));
+    }
+    return this.extMethodReviewed(method, params);
+  }
+  async extMethodReviewed(method, params) {
     const methodRequest = { method, params };
     if (!isExtMethodRequest(methodRequest)) {
       return {};
@@ -43198,6 +43382,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
     return null;
   }
   async loadSession(params) {
+    return this.hookReview.run(params.cwd, params._meta, () => this.loadSessionReviewed(params));
+  }
+  async loadSessionReviewed(params) {
     readSessionInstructionAppend(params._meta);
     return this.recovery === null ? await this.loadSessionOnce(params) : await this.recovery.trackOpen(params.sessionId, () => this.loadSessionOnce(params));
   }
@@ -43241,6 +43428,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
     };
   }
   async resumeSession(params) {
+    return this.hookReview.run(params.cwd, params._meta, () => this.resumeSessionReviewed(params));
+  }
+  async resumeSessionReviewed(params) {
     readSessionInstructionAppend(params._meta);
     return this.recovery === null ? await this.resumeSessionOnce(params) : await this.recovery.trackOpen(params.sessionId, () => this.resumeSessionOnce(params));
   }
@@ -43264,6 +43454,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
     };
   }
   async forkSession(params) {
+    return this.hookReview.run(params.cwd, params._meta, () => this.forkSessionReviewed(params));
+  }
+  async forkSessionReviewed(params) {
     readSessionInstructionAppend(params._meta);
     if (this.providerUpdate !== null) {
       await this.waitForProviderUpdate();
@@ -43376,6 +43569,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
     return this.sessionOpenGenerations.get(sessionId) === this.getSessionGeneration(sessionId);
   }
   async newSession(params) {
+    return this.hookReview.run(params.cwd, params._meta, () => this.newSessionReviewed(params));
+  }
+  async newSessionReviewed(params) {
     readSessionInstructionAppend(params._meta);
     if (this.providerUpdate !== null) {
       await this.waitForProviderUpdate();
@@ -43401,14 +43597,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const appServer = this.ensureAppServer();
     if (appServer) await appServer;
     const elicitationRequester = this.createUrlElicitationRequester(requestId);
-    const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(_params, elicitationRequester));
-    if (!isAuthenticated) {
-      logger.log("Authenticate request failed");
-      throw RequestError.authRequired({ methodId: _params.methodId }, "Sign-in did not complete");
+    this.hookReview.invalidate();
+    try {
+      const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(_params, elicitationRequester));
+      if (!isAuthenticated) {
+        logger.log("Authenticate request failed");
+        throw RequestError.authRequired({ methodId: _params.methodId }, "Sign-in did not complete");
+      }
+      await this.refreshAuthState(this.getAuthProviderForAuthenticateRequest(_params));
+      logger.log("Authenticate request completed");
+      return {};
+    } finally {
+      this.hookReview.invalidate();
     }
-    await this.refreshAuthState(this.getAuthProviderForAuthenticateRequest(_params));
-    logger.log("Authenticate request completed");
-    return {};
   }
   createUrlElicitationRequester(requestId) {
     if (requestId == null || !clientSupportsUrlElicitation(this.clientCapabilities)) {
@@ -43447,11 +43648,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   async setProvider(params) {
     this.codexAcpClient.setProvider(params);
+    this.hookReview.invalidate();
     await this.enqueueProviderUpdate((client) => client.setProvider(params));
     return {};
   }
   async disableProvider(params) {
     this.codexAcpClient.disableProvider(params);
+    if (params.providerId === OPENAI_PROVIDER_ID) this.hookReview.invalidate();
     if (params.providerId !== OPENAI_PROVIDER_ID) {
       return {};
     }
@@ -43480,6 +43683,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw new Error("Cannot restart Codex app-server before ACP initialization");
       }
       await replacement.initialize(this.initializeRequest);
+      this.hookReview.bind(replacement);
       this.codexAcpClient = replacement;
       this.sessionIndex.observe(replacement);
       this.availableCommands = this.createAvailableCommands(replacement);
@@ -43492,6 +43696,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         if (replacement.appServerClient.connectionLoss.lost) {
           break;
         }
+        if (this.hookReview.enabled) continue;
         try {
           const request = {
             sessionId: session.sessionId,
@@ -43594,7 +43799,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
       currentClient: () => this.codexAcpClient,
       createClient: (connection) => {
         this.captureStderr();
-        return this.codexAcpClient.withAppServer(new CodexAppServerClient(connection.connection));
+        const client = this.codexAcpClient.withAppServer(new CodexAppServerClient(connection.connection));
+        this.hookReview.bind(client);
+        return client;
       },
       handshake: (client) => this.initializeRequest !== null && this.codexAcpClient.initialized ? client.initialize(this.initializeRequest) : null,
       install: (client) => this.installCodexClient(client),
@@ -43626,6 +43833,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
   installCodexClient(client) {
     client.adoptRoutingFrom(this.codexAcpClient);
     this.codexAcpClient = client;
+    this.hookReview.bind(client);
     this.sessionIndex.observe(client);
     this.availableCommands = this.createAvailableCommands(client);
     for (const session of this.sessions.values()) {
@@ -44161,11 +44369,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     return await new Promise((resolve, reject) => {
       let turnStarted = false;
-      const promptDone = this.prompt(params, void 0, () => {
-        turnStarted = true;
-        logger.log(`${source} started a new turn`, { sessionId: params.sessionId });
-        resolve(true);
-      });
+      const promptDone = this.hookReview.continueOperation(
+        this.getSessionState(params.sessionId).cwd,
+        params._meta,
+        () => this.promptReviewed(params, void 0, () => {
+          turnStarted = true;
+          logger.log(`${source} started a new turn`, { sessionId: params.sessionId });
+          resolve(true);
+        })
+      );
       promptDone.then(
         (response) => {
           if (!turnStarted && response.stopReason === "cancelled") {
@@ -44220,7 +44432,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     return {
       sessionId,
-      prompt
+      prompt,
+      ...params["_meta"] === void 0 ? {} : { _meta: params["_meta"] }
     };
   }
   createSessionConfigOptions(sessionState) {
@@ -45016,6 +45229,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
     return turnId;
   }
   async prompt(params, signal, onTurnStarted) {
+    return this.hookReview.run(
+      this.getSessionState(params.sessionId).cwd,
+      params._meta,
+      () => this.promptReviewed(params, signal, onTurnStarted)
+    );
+  }
+  async promptReviewed(params, signal, onTurnStarted) {
     if (this.providerUpdate !== null) {
       await this.waitForProviderUpdate();
     }
@@ -45857,6 +46077,7 @@ var asyncTaskStopParamsParser = external_exports.object({
 }).passthrough();
 var hooksListParamsParser = external_exports.object({ cwd: external_exports.string().trim().min(1) });
 var hooksTrustParamsParser = external_exports.object({
+  reviewToken: external_exports.string().min(1).optional(),
   cwd: external_exports.string().trim().min(1),
   hooks: external_exports.array(external_exports.object({ key: external_exports.string().min(1), currentHash: external_exports.string().min(1) })).min(1)
 });
@@ -45940,5 +46161,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(ASYNC_TASK_STOP_METHOD, asyncTaskStopParamsParser, (ctx) => getAgent().extMethod(ASYNC_TASK_STOP_METHOD, ctx.params)).onRequest(CODEX_HOOKS_LIST_METHOD, hooksListParamsParser, (ctx) => getAgent().listHooks(ctx.params.cwd)).onRequest(CODEX_HOOKS_TRUST_METHOD, hooksTrustParamsParser, (ctx) => getAgent().trustHooks(ctx.params.cwd, ctx.params.hooks)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).onRequest(SESSION_RENAME_METHOD, sessionRenameParamsParser, (ctx) => getAgent().sessionIndex.rename(ctx.params)).onRequest(SESSION_ARCHIVE_METHOD, sessionArchiveParamsParser, (ctx) => getAgent().sessionIndex.setArchived(ctx.params, true)).onRequest(SESSION_UNARCHIVE_METHOD, sessionArchiveParamsParser, (ctx) => getAgent().sessionIndex.setArchived(ctx.params, false)).onRequest(SESSION_LIST_SUBSCRIBE_METHOD, sessionListSubscriptionParamsParser, (ctx) => getAgent().sessionIndex.subscribeList(ctx.params)).onRequest(SESSION_LIST_UNSUBSCRIBE_METHOD, sessionListSubscriptionParamsParser, (ctx) => getAgent().sessionIndex.unsubscribeList(ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(ASYNC_TASK_STOP_METHOD, asyncTaskStopParamsParser, (ctx) => getAgent().extMethod(ASYNC_TASK_STOP_METHOD, ctx.params)).onRequest(CODEX_HOOKS_LIST_METHOD, hooksListParamsParser, (ctx) => getAgent().listHooks(ctx.params.cwd)).onRequest(CODEX_HOOKS_TRUST_METHOD, hooksTrustParamsParser, (ctx) => getAgent().trustHooks(ctx.params.cwd, ctx.params.hooks, ctx.params.reviewToken)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).onRequest(SESSION_RENAME_METHOD, sessionRenameParamsParser, (ctx) => getAgent().sessionIndex.rename(ctx.params)).onRequest(SESSION_ARCHIVE_METHOD, sessionArchiveParamsParser, (ctx) => getAgent().sessionIndex.setArchived(ctx.params, true)).onRequest(SESSION_UNARCHIVE_METHOD, sessionArchiveParamsParser, (ctx) => getAgent().sessionIndex.setArchived(ctx.params, false)).onRequest(SESSION_LIST_SUBSCRIBE_METHOD, sessionListSubscriptionParamsParser, (ctx) => getAgent().sessionIndex.subscribeList(ctx.params)).onRequest(SESSION_LIST_UNSUBSCRIBE_METHOD, sessionListSubscriptionParamsParser, (ctx) => getAgent().sessionIndex.unsubscribeList(ctx.params)).connect(acpJsonStream);
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.2.2-alas.3",
+  "version": "2.2.2-alas.4",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -80,6 +80,6 @@
   "alasDownstream": {
     "upstreamVersion": "2.2.2",
     "upstreamCommit": "202e66e63343ec4f5a5e35ab590251d813d129ca",
-    "sourceCommit": "2be0ccf63ad9c18131815207511597bb34d6adc0"
+    "sourceCommit": "4b517e7e77ece05ef63f34c890bc853b7fb96a43"
   }
 }