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

package/dist/index.js

@@ -34392,7 +34392,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "2.2.2-alas.2",
+  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: "f431e5cac0d2972bcb8295f8967d6f27f6633eea"
+    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";
@@ -40217,9 +40391,6 @@ function titleSource(text) {
   return text.slice(0, end);
 }
 
-// src/SessionIndexService.ts
-import path13 from "node:path";
-
 // src/SessionIndex.ts
 var AIR_SESSION_INDEX_KEY = "sessionIndex";
 var AIR_SESSION_ARCHIVE_KEY = "sessionArchive";
@@ -40240,6 +40411,32 @@ var AIR_FORKED_FROM_KEY = "forkedFrom";
 var DEFAULT_SESSION_INDEX_LIMIT = 50;
 var MAX_SESSION_INDEX_LIMIT = 100;
 var AIR_ARCHIVED_KEY = "archived";
+var NEUTRAL_SESSION_INDEX_META_KEY = "sessionIndex";
+var NEUTRAL_SESSION_INDEX_VERSION = 1;
+var AIR_SESSION_INDEX_META = {
+  read: (meta3) => asRecord3(asRecord3(asRecord3(meta3)[JETBRAINS_META_KEY])[AIR_META_KEY]),
+  write: withAirMeta
+};
+var NEUTRAL_SESSION_INDEX_META = {
+  read: (meta3) => asRecord3(asRecord3(meta3)[NEUTRAL_SESSION_INDEX_META_KEY]),
+  write: (meta3, key, value) => {
+    const root = asRecord3(meta3);
+    return { ...root, [NEUTRAL_SESSION_INDEX_META_KEY]: { ...asRecord3(root[NEUTRAL_SESSION_INDEX_META_KEY]), [key]: value } };
+  }
+};
+function sessionIndexMetaOf(capabilities) {
+  if (isAirClient(capabilities)) {
+    return clientSupportsAirCapability(capabilities, AIR_SESSION_INDEX_KEY) ? AIR_SESSION_INDEX_META : null;
+  }
+  const declared = capabilities?._meta?.[NEUTRAL_SESSION_INDEX_META_KEY];
+  if (declared === null || typeof declared !== "object" || Array.isArray(declared)) return null;
+  const version2 = declared["version"];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= 1 ? NEUTRAL_SESSION_INDEX_META : null;
+}
+function sessionIndexRowFields(row) {
+  const air = AIR_SESSION_INDEX_META.read(row._meta);
+  return Object.keys(air).length > 0 ? air : NEUTRAL_SESSION_INDEX_META.read(row._meta);
+}
 var ARCHIVED_FILTERS = ["unarchived", "archived", "all"];
 function archivedSides(filter) {
   switch (filter) {
@@ -40265,9 +40462,8 @@ var sessionListSubscriptionParamsParser = external_exports.preprocess(
   (params) => params ?? {},
   external_exports.record(external_exports.string(), external_exports.unknown())
 );
-function readSessionIndexListOptions(meta3) {
-  const jetbrains = asRecord3(asRecord3(meta3)[JETBRAINS_META_KEY]);
-  const list = asRecord3(asRecord3(jetbrains[AIR_META_KEY])[AIR_SESSION_LIST_KEY]);
+function readSessionIndexListOptions(meta3, namespace = AIR_SESSION_INDEX_META) {
+  const list = asRecord3(namespace.read(meta3)[AIR_SESSION_LIST_KEY]);
   return {
     limit: readLimit(list["limit"]),
     archived: readArchivedFilter(list["archived"]),
@@ -40453,7 +40649,7 @@ function decodeAdapterCursor(cursor) {
 function invalidCursorError(cursor) {
   return RequestError.invalidParams({ cursor }, "invalid cursor");
 }
-function sessionIndexSessionInfo(thread, archived, activity) {
+function sessionIndexSessionInfo(thread, archived, activity, namespace = AIR_SESSION_INDEX_META) {
   const airFields = { [AIR_ARCHIVED_KEY]: archived };
   if (thread.recencyAt !== null) airFields[AIR_LAST_PROMPT_AT_KEY] = isoTime(thread.recencyAt);
   if (thread.model) airFields[AIR_MODEL_KEY] = thread.model;
@@ -40462,7 +40658,7 @@ function sessionIndexSessionInfo(thread, archived, activity) {
   if (activity?.lastTurnEndedAt !== void 0) airFields[AIR_LAST_TURN_ENDED_AT_KEY] = activity.lastTurnEndedAt;
   let meta3;
   for (const [key, value] of Object.entries(airFields)) {
-    meta3 = withAirMeta(meta3, key, value);
+    meta3 = namespace.write(meta3, key, value);
   }
   return {
     sessionId: thread.id,
@@ -40550,7 +40746,7 @@ var SessionIndexActivity = class {
   }
 };
 function sessionIndexRowSignature(row) {
-  const air = asRecord3(asRecord3(asRecord3(row._meta)[JETBRAINS_META_KEY])[AIR_META_KEY]);
+  const air = sessionIndexRowFields(row);
   return JSON.stringify([
     row.title ?? null,
     air[AIR_LAST_PROMPT_AT_KEY] ?? null,
@@ -40565,6 +40761,9 @@ function asRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
+// src/SessionIndexService.ts
+import path13 from "node:path";
+
 // src/SessionIndexWorktrees.ts
 import fs8 from "node:fs";
 import path9 from "node:path";
@@ -40846,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
@@ -41202,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();
@@ -41292,10 +41491,7 @@ var SessionListSubscriptions = class {
   refreshLoadedThreads(threadIds) {
     this.appServerGeneration++;
     if (this.subscriptions.size === 0) return;
-    const loaded = [...this.groups.values()].flatMap((group) => [...group.rows].filter(([, { row }]) => {
-      const meta3 = row._meta;
-      return meta3?.["jetbrains"]?.["air"]?.["state"] !== void 0;
-    }).map(([threadId]) => threadId));
+    const loaded = [...this.groups.values()].flatMap((group) => [...group.rows].filter(([, { row }]) => sessionIndexRowFields(row)[AIR_STATE_KEY] !== void 0).map(([threadId]) => threadId));
     for (const threadId of /* @__PURE__ */ new Set([...threadIds, ...loaded])) this.threadChanged(threadId);
     if (this.pendingThreads.size > 0) this.requestThreads(this.timings.ownChangeDelayMs);
   }
@@ -41771,8 +41967,8 @@ var SessionIndexService = class {
     });
   }
   host;
-  /** The client declared the AIR `sessionIndex` capability. */
-  enabled = false;
+  /** Where this client's session index metadata goes, or `null` when it did not declare `sessionIndex`. */
+  meta = null;
   activity;
   writes = new SessionWriteQueue();
   titles;
@@ -41785,14 +41981,25 @@ var SessionIndexService = class {
   rowsWithState = /* @__PURE__ */ new Set();
   /** Reads the client capabilities of `initialize`. */
   configure(clientCapabilities) {
-    this.enabled = clientSupportsAirCapability(clientCapabilities, AIR_SESSION_INDEX_KEY);
+    this.meta = sessionIndexMetaOf(clientCapabilities);
+  }
+  /** The client declared `sessionIndex`, as AIR or as a client-neutral opt-in. */
+  get enabled() {
+    return this.meta !== null;
   }
   /**
-   * The AIR capabilities to answer: only a client that declares `sessionIndex` gets them. `sessionArchive` and
-   * `sessionRename` name the requests that come with it; the client need not declare them.
+   * The AIR capabilities to answer: only an AIR client that declares `sessionIndex` gets them. `sessionArchive`
+   * and `sessionRename` name the requests that come with it; the client need not declare them.
    */
   agentCapabilities() {
-    return this.enabled ? [AIR_SESSION_INDEX_KEY, AIR_SESSION_ARCHIVE_KEY, AIR_SESSION_RENAME_KEY, AIR_SESSION_LIST_SUBSCRIBE_KEY] : [];
+    return this.meta === AIR_SESSION_INDEX_META ? [AIR_SESSION_INDEX_KEY, AIR_SESSION_ARCHIVE_KEY, AIR_SESSION_RENAME_KEY, AIR_SESSION_LIST_SUBSCRIBE_KEY] : [];
+  }
+  /** The `_meta.sessionIndex` answer of `initialize` to a client-neutral opt-in, or `null`. */
+  neutralCapability() {
+    return this.meta === NEUTRAL_SESSION_INDEX_META ? {
+      version: NEUTRAL_SESSION_INDEX_VERSION,
+      capabilities: [AIR_SESSION_ARCHIVE_KEY, AIR_SESSION_RENAME_KEY, AIR_SESSION_LIST_SUBSCRIBE_KEY]
+    } : null;
   }
   /**
    * Feeds the thread notifications of an app-server, for every thread, to the session index. Each client is
@@ -41826,7 +42033,7 @@ var SessionIndexService = class {
    * reads the local state DB and works without one.
    */
   async list(params) {
-    const options = readSessionIndexListOptions(params._meta);
+    const options = readSessionIndexListOptions(params._meta, this.requireMeta());
     const cwd = params.cwd?.trim() || null;
     return await this.readRows(cwd, options, params.cursor ?? null);
   }
@@ -41901,13 +42108,13 @@ var SessionIndexService = class {
     if (archived ? open3 : this.host.session(sessionId) !== void 0) {
       await new ACPSessionConnection(this.host.connection(), sessionId).update({
         sessionUpdate: "session_info_update",
-        _meta: withAirMeta(void 0, AIR_ARCHIVED_KEY, archived)
+        _meta: this.requireMeta().write(void 0, AIR_ARCHIVED_KEY, archived)
       });
     }
     return {};
   }
   /**
-   * Deletes the thread for `session/delete`: AIR then means "delete", not "done", because it has
+   * Deletes the thread for `session/delete`: a `sessionIndex` client then means "delete", not "done", because it has
    * `_session/archive` for that. A thread that this connection had open but Codex never persisted (no
    * prompt yet) is gone with the close, so it counts as deleted.
    */
@@ -41939,6 +42146,10 @@ var SessionIndexService = class {
       throw RequestError.methodNotFound(method);
     }
   }
+  requireMeta() {
+    if (this.meta === null) throw new Error("The client did not declare sessionIndex");
+    return this.meta;
+  }
   async readRows(cwd, options, cursor) {
     const relativeCwd = cwd !== null && !isAbsolutePathLike(cwd) ? cwd : null;
     const cwds = cwd === null || relativeCwd !== null ? null : options.includeWorktrees ? linkedWorktreeCwds(cwd) : canonicalCwds(cwd);
@@ -41964,7 +42175,7 @@ var SessionIndexService = class {
       if (activity?.state !== void 0) this.rowsWithState.add(thread.id);
       else this.rowsWithState.delete(thread.id);
       return this.withActiveAdditionalDirectories(
-        sessionIndexSessionInfo(thread, entry.archived, activity)
+        sessionIndexSessionInfo(thread, entry.archived, activity, this.requireMeta())
       );
     });
   }
@@ -42449,7 +42660,8 @@ var CodexAcpServer = class {
   recovery;
   initializeRequest = null;
   providerUpdate = null;
-  /** The AIR `sessionIndex` extension, see `SessionIndexService.ts`. */
+  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,
     client: () => this.codexAcpClient,
@@ -42496,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;
@@ -42525,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();
@@ -42533,6 +42746,7 @@ var CodexAcpServer = class {
       controlMethod: GOAL_CONTROL_METHOD,
       actions: [...GOAL_CONTROL_ACTIONS]
     };
+    const neutralSessionIndex = this.sessionIndex.neutralCapability();
     const sessionCapabilities = {
       resume: {},
       list: {},
@@ -42583,6 +42797,10 @@ 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
+        } : {},
         // Only AIR gets the AIR extension, see `docs/air-extensions.md`.
         ...this.capabilities.airClient ? {
           [JETBRAINS_META_KEY]: {
@@ -42612,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 {};
@@ -43157,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));
   }
@@ -43200,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));
   }
@@ -43223,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();
@@ -43335,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();
@@ -43360,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)) {
@@ -43406,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 {};
     }
@@ -43439,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);
@@ -43451,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,
@@ -43553,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),
@@ -43585,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()) {
@@ -44120,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") {
@@ -44179,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) {
@@ -44975,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();
     }
@@ -45816,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)
 });
@@ -45899,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.2",
+  "version": "2.2.2-alas.4",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -80,6 +80,6 @@
   "alasDownstream": {
     "upstreamVersion": "2.2.2",
     "upstreamCommit": "202e66e63343ec4f5a5e35ab590251d813d129ca",
-    "sourceCommit": "f431e5cac0d2972bcb8295f8967d6f27f6633eea"
+    "sourceCommit": "4b517e7e77ece05ef63f34c890bc853b7fb96a43"
   }
 }