@agentclientprotocol/codex-acp 1.0.1 → 1.0.2

package/dist/index.js

@@ -22544,15 +22544,24 @@ ${event.details}` : "";
     };
   }
   createThreadGoalUpdatedEvent(event) {
+    const goalSnapshot = this.createThreadGoalSnapshot(event);
+    if (this.sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
+      return null;
+    }
+    this.sessionState.currentGoal = goalSnapshot;
     const status = this.formatThreadGoalStatus(event.goal.status);
-    const objective = event.goal.objective.trim();
+    const objective = goalSnapshot.objective;
     const text = objective.includes("\n") ? `Goal updated (${status}):
 ${objective}` : `Goal updated (${status}): ${objective}`;
     return {
       sessionUpdate: "agent_message_chunk",
       content: {
         type: "text",
-        text
+        text: `
+
+${text}
+
+`
       }
     };
   }
@@ -22573,14 +22582,28 @@ ${objective}` : `Goal updated (${status}): ${objective}`;
     }
   }
   createThreadGoalClearedEvent(_event) {
+    if (this.sessionState.currentGoal === null) {
+      return null;
+    }
+    this.sessionState.currentGoal = null;
     return {
       sessionUpdate: "agent_message_chunk",
       content: {
         type: "text",
-        text: "Goal cleared."
+        text: "\n\nGoal cleared.\n\n"
       }
     };
   }
+  createThreadGoalSnapshot(event) {
+    return {
+      objective: event.goal.objective.trim(),
+      status: event.goal.status,
+      tokenBudget: event.goal.tokenBudget
+    };
+  }
+  sameThreadGoalSnapshot(left, right) {
+    return left !== null && left !== void 0 && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget;
+  }
   createReasoningDeltaEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent(event.delta);
@@ -24259,7 +24282,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.0.1",
+  version: "1.0.2",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -24318,7 +24341,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.0.0",
-    "@openai/codex": "^0.142.2",
+    "@openai/codex": "^0.142.4",
     diff: "^8.0.3",
     open: "^11.0.0",
     "vscode-jsonrpc": "^8.2.1",
@@ -24573,6 +24596,28 @@ var CodexAcpClient = class {
   async runCompact(sessionId) {
     await this.codexClient.runCompact({ threadId: sessionId });
   }
+  async setGoal(sessionId, objective, onTurnStarted) {
+    return await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      objective,
+      status: "active"
+    }, onTurnStarted);
+  }
+  async setGoalStatus(sessionId, status) {
+    await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      status
+    });
+  }
+  async resumeGoal(sessionId, onTurnStarted) {
+    return await this.codexClient.runGoalSet({
+      threadId: sessionId,
+      status: "active"
+    }, onTurnStarted);
+  }
+  async clearGoal(sessionId) {
+    await this.codexClient.runGoalClear({ threadId: sessionId });
+  }
   async awaitMcpServerStartup(serverNames, afterVersion) {
     return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
   }
@@ -25088,22 +25133,27 @@ var CodexCommands = class {
     this.runWithProcessCheck = runWithProcessCheck;
     this.onLogout = onLogout;
   }
-  async publish(sessionId) {
+  async publish(sessionState) {
     try {
-      const skillsResponse = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills());
+      const skillsResponse = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills(this.createSkillsListParams(sessionState)));
       const availableCommands = this.buildAvailableCommands(skillsResponse?.data ?? []);
       if (availableCommands.length === 0) {
         return;
       }
-      const session = new ACPSessionConnection(this.connection, sessionId);
+      const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
       await session.update({
         sessionUpdate: "available_commands_update",
         availableCommands
       });
     } catch (err) {
-      logger.error(`Failed to publish available commands for session ${sessionId}`, err);
+      logger.error(`Failed to publish available commands for session ${sessionState.sessionId}`, err);
     }
   }
+  createSkillsListParams(sessionState) {
+    return {
+      cwds: [sessionState.cwd, ...sessionState.additionalDirectories]
+    };
+  }
   buildAvailableCommands(skillsEntries) {
     const commands = /* @__PURE__ */ new Map();
     for (const builtin of this.getBuiltinCommands()) {
@@ -25163,6 +25213,11 @@ var CodexCommands = class {
         description: "Summarize conversation to avoid hitting the context limit.",
         input: null
       },
+      {
+        name: "goal",
+        description: "Set, pause, resume, or clear a task goal.",
+        input: { hint: "[<objective>|clear|pause|resume]" }
+      },
       {
         name: "logout",
         description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
@@ -25195,6 +25250,9 @@ var CodexCommands = class {
         await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
         return { handled: true };
       }
+      case "goal": {
+        return await this.runGoalCommand(sessionState, command.rest, options);
+      }
       case "review": {
         const target = this.buildReviewTarget(command.rest);
         const turnCompleted = await this.runReviewCommand(sessionState, target, options);
@@ -25243,7 +25301,7 @@ var CodexCommands = class {
         return { handled: true };
       }
       case "skills": {
-        const response = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills());
+        const response = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills(this.createSkillsListParams(sessionState)));
         const skills = (response?.data ?? []).flatMap((entry) => entry.skills);
         const lines = skills.map((skill) => {
           const description = skill.shortDescription ?? skill.description ?? "";
@@ -25280,18 +25338,74 @@ var CodexCommands = class {
     }
   }
   async runReviewCommand(sessionState, target, options) {
+    options.onTurnStartPending?.();
     return await this.runWithProcessCheck(() => this.codexAcpClient.runReview(
       sessionState.sessionId,
       target,
       (turnId, threadId) => {
-        if (options.onTurnStarted) {
-          options.onTurnStarted(turnId, threadId);
-        } else {
-          sessionState.currentTurnId = turnId;
-        }
+        this.handleCommandTurnStarted(sessionState, options, turnId, threadId);
       }
     ));
   }
+  async runGoalCommand(sessionState, rest, options) {
+    const sessionId = sessionState.sessionId;
+    const argument = rest.trim();
+    if (argument.length === 0) {
+      await this.sendCommandUsageMessage("goal", "[<objective>|clear|pause|resume]", sessionId);
+      return { handled: true };
+    }
+    switch (argument.toLowerCase()) {
+      case "pause":
+        await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionId, "paused"));
+        return { handled: true };
+      case "resume":
+        options.onTurnStartPending?.();
+        return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.resumeGoal(
+          sessionId,
+          (turnId) => {
+            this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
+          }
+        )));
+      case "clear":
+        await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionId));
+        return { handled: true };
+    }
+    if (argument.length > 4e3) {
+      const session = new ACPSessionConnection(this.connection, sessionId);
+      await session.update({
+        sessionUpdate: "agent_message_chunk",
+        content: {
+          type: "text",
+          text: 'Command "/goal" requires goal text of at most 4000 characters.'
+        }
+      });
+      return { handled: true };
+    }
+    options.onTurnStartPending?.();
+    return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.setGoal(
+      sessionId,
+      argument,
+      (turnId) => {
+        this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
+      }
+    )));
+  }
+  handleCommandTurnStarted(sessionState, options, turnId, threadId) {
+    if (options.onTurnStarted) {
+      options.onTurnStarted(turnId, threadId);
+    } else {
+      sessionState.currentTurnId = turnId;
+    }
+  }
+  createGoalCommandResult(turnCompleted) {
+    if (turnCompleted === null) {
+      return { handled: true };
+    }
+    return {
+      handled: true,
+      turnCompleted
+    };
+  }
   buildReviewTarget(instructions) {
     if (instructions.length === 0) {
       return { type: "uncommittedChanges" };
@@ -26734,7 +26848,7 @@ You have been logged out. Please try again.`);
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    this.publishAvailableCommandsAsync(sessionId);
+    this.publishAvailableCommandsAsync(sessionState);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return [sessionId, sessionModelState, sessionModeState];
@@ -27042,7 +27156,9 @@ You have been logged out. Please try again.`);
         createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort)
       );
     }
-    configOptions.push(createFastModeConfigOption(sessionState.fastModeEnabled));
+    if (sessionState.currentModelSupportsFast) {
+      configOptions.push(createFastModeConfigOption(sessionState.fastModeEnabled));
+    }
     return configOptions;
   }
   createSessionConfigOptionsResponse(sessionState) {
@@ -27056,8 +27172,8 @@ You have been logged out. Please try again.`);
   isSessionConfigEnabled() {
     return !isJetBrains2026_1Client(this.clientInfo);
   }
-  publishAvailableCommandsAsync(sessionId) {
-    void this.availableCommands.publish(sessionId);
+  publishAvailableCommandsAsync(sessionState) {
+    void this.availableCommands.publish(sessionState);
   }
   findCurrentModel(models, currentModelId) {
     const modelId = ModelId.fromString(currentModelId);
@@ -27148,7 +27264,7 @@ You have been logged out. Please try again.`);
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    await this.availableCommands.publish(sessionId);
+    await this.availableCommands.publish(sessionState);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return {
@@ -27563,6 +27679,13 @@ ${item.text}`
     sessionState.lastTokenUsage = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
     let pendingTurnStart = null;
+    const ensurePendingTurnStart = () => {
+      if (pendingTurnStart === null) {
+        pendingTurnStart = this.createPendingTurnStart();
+        this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      }
+      return pendingTurnStart;
+    };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     try {
       const eventHandler = new CodexEventHandler(this.connection, sessionState);
@@ -27581,6 +27704,9 @@ ${item.text}`
         return this.cancelledPromptResponse(sessionState);
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+        onTurnStartPending: () => {
+          ensurePendingTurnStart();
+        },
         onTurnStarted: (turnId, threadId) => {
           const turn = { threadId, turnId };
           activePrompt.currentTurn = turn;
@@ -27589,6 +27715,7 @@ ${item.text}`
             return;
           }
           sessionState.currentTurnId = turnId;
+          pendingTurnStart?.resolve(turnId);
         }
       });
       void commandPromise.catch((err) => {
@@ -27641,8 +27768,7 @@ ${item.text}`
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
       );
-      pendingTurnStart = this.createPendingTurnStart();
-      this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           params,
@@ -27699,10 +27825,11 @@ ${item.text}`
       logger.log("Prompt completed", { sessionId: params.sessionId });
       disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
-      if (pendingTurnStart !== null && this.pendingTurnStarts.get(params.sessionId) === pendingTurnStart) {
+      const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
+      if (registeredPendingTurnStart !== void 0) {
         this.pendingTurnStarts.delete(params.sessionId);
+        registeredPendingTurnStart.resolve(null);
       }
-      pendingTurnStart?.resolve(null);
       activePrompt.complete();
     }
   }
@@ -27834,6 +27961,7 @@ var CommandExecutionApprovalRequest = new import_node2.RequestType("item/command
 var FileChangeApprovalRequest = new import_node2.RequestType("item/fileChange/requestApproval");
 var PermissionsApprovalRequest = new import_node2.RequestType("item/permissions/requestApproval");
 var McpServerElicitationRequest = new import_node2.RequestType("mcpServer/elicitation/request");
+var GOAL_RUNTIME_EFFECTS_GRACE_MS = 1e3;
 var CodexAppServerClient = class {
   connection;
   approvalHandlers = /* @__PURE__ */ new Map();
@@ -27844,6 +27972,10 @@ var CodexAppServerClient = class {
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   pendingCompactionCompletionResolvers = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
+  turnRoutingCaptures = /* @__PURE__ */ new Map();
+  threadStatusCaptures = /* @__PURE__ */ new Map();
+  threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
+  threadGoalClearedCaptures = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
@@ -27864,15 +27996,21 @@ var CodexAppServerClient = class {
       if (isCompactionCompletedNotification(serverNotification)) {
         this.recordCompactionCompleted(serverNotification);
       }
+      if (isThreadStatusChangedNotification(serverNotification)) {
+        this.recordThreadStatusChanged(serverNotification.params);
+      }
+      if (isThreadGoalUpdatedNotification(serverNotification)) {
+        this.recordThreadGoalUpdated(serverNotification.params);
+      }
+      if (isThreadGoalClearedNotification(serverNotification)) {
+        this.recordThreadGoalCleared(serverNotification.params);
+      }
       const routing = extractTurnRouting(serverNotification);
-      const staleTurnNotification = this.isStaleTurn(routing.threadId, routing.turnId);
-      if (staleTurnNotification) {
-        if (isTurnCompletedNotification(serverNotification) && routing.threadId !== null && routing.turnId !== null) {
-          this.clearStaleTurn(routing.threadId, routing.turnId);
-        }
-        for (const callback of this.codexEventHandlers) {
-          callback({ eventType: "notification", ...serverNotification });
-        }
+      if (this.handleStaleTurnNotification(serverNotification, routing)) {
+        return;
+      }
+      this.recordTurnRouting(routing);
+      if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
       }
       this.notify(serverNotification);
@@ -27974,6 +28112,174 @@ var CodexAppServerClient = class {
       releaseCapture();
     }
   }
+  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS) {
+    let goalTurnId = null;
+    const capturedCompletions = [];
+    let resolveGoalTurnCompleted = () => {
+    };
+    const goalTurnCompleted = new Promise((resolve) => {
+      resolveGoalTurnCompleted = resolve;
+    });
+    const releaseCompletionCapture = this.captureTurnCompletions(params.threadId, (event) => {
+      capturedCompletions.push(event);
+      if (goalTurnId === event.turn.id) {
+        resolveGoalTurnCompleted(event);
+      }
+    });
+    let resolveGoalTurnStarted = () => {
+    };
+    const goalTurnStarted = new Promise((resolve) => {
+      resolveGoalTurnStarted = resolve;
+    });
+    let resolveGoalUpdateHandled = () => {
+    };
+    const matchingGoalUpdateHandled = new Promise((resolve) => {
+      resolveGoalUpdateHandled = () => resolve(null);
+    });
+    let goalUpdateHandled = false;
+    let expectedGoal = null;
+    const noGoalTurnStarted = this.createNoGoalTurnStartedPromise(runtimeEffectsGraceMs);
+    const capturedGoalUpdates = [];
+    const releaseRoutingCapture = this.captureTurnRoutings(params.threadId, (turnId) => {
+      if (!goalUpdateHandled || goalTurnId !== null) {
+        return;
+      }
+      goalTurnId = turnId;
+      onTurnStarted?.(turnId);
+      resolveGoalTurnStarted(turnId);
+    });
+    const releaseGoalUpdateCapture = this.captureThreadGoalUpdates(params.threadId, (event) => {
+      capturedGoalUpdates.push(event);
+      if (expectedGoal !== null && goalsMatch(event.goal, expectedGoal)) {
+        goalUpdateHandled = true;
+        resolveGoalUpdateHandled();
+        noGoalTurnStarted.goalUpdated();
+      }
+    });
+    const releaseStatusCapture = this.captureThreadStatuses(params.threadId, (status) => {
+      if (!goalUpdateHandled || goalTurnId !== null) {
+        return;
+      }
+      noGoalTurnStarted.threadStatusChanged(status);
+    });
+    try {
+      const goalSetResponse = await this.threadGoalSet(params);
+      expectedGoal = goalSetResponse.goal;
+      if (capturedGoalUpdates.some((event) => goalsMatch(event.goal, expectedGoal))) {
+        goalUpdateHandled = true;
+        resolveGoalUpdateHandled();
+        noGoalTurnStarted.goalUpdated();
+      }
+      if (expectedGoal.status !== "active") {
+        await matchingGoalUpdateHandled;
+        return null;
+      }
+      const turnId = goalTurnId ?? await Promise.race([goalTurnStarted, noGoalTurnStarted.promise]);
+      noGoalTurnStarted.release();
+      releaseRoutingCapture();
+      releaseStatusCapture();
+      releaseGoalUpdateCapture();
+      if (turnId === null) {
+        return null;
+      }
+      const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnId);
+      if (earlyCompletion) {
+        return earlyCompletion;
+      }
+      return await goalTurnCompleted;
+    } finally {
+      noGoalTurnStarted.release();
+      releaseCompletionCapture();
+      releaseRoutingCapture();
+      releaseStatusCapture();
+      releaseGoalUpdateCapture();
+    }
+  }
+  async runGoalClear(params) {
+    let goalClearedHandled = false;
+    let resolveGoalClearedHandled = () => {
+    };
+    const matchingGoalClearedHandled = new Promise((resolve) => {
+      resolveGoalClearedHandled = () => resolve();
+    });
+    const releaseGoalClearedCapture = this.captureThreadGoalClears(params.threadId, () => {
+      goalClearedHandled = true;
+      resolveGoalClearedHandled();
+    });
+    try {
+      const response = await this.threadGoalClear(params);
+      if (!response.cleared || goalClearedHandled) {
+        return;
+      }
+      await matchingGoalClearedHandled;
+    } finally {
+      releaseGoalClearedCapture();
+    }
+  }
+  createNoGoalTurnStartedPromise(runtimeEffectsGraceMs) {
+    let released = false;
+    let resolved = false;
+    let goalUpdated = false;
+    let activeAfterGoalUpdate = false;
+    let timeout = null;
+    let resolveNoGoalTurnStarted = () => {
+    };
+    const clearTimer = () => {
+      if (timeout !== null) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+    const resolveNoTurn = () => {
+      if (released || resolved) {
+        return;
+      }
+      resolved = true;
+      clearTimer();
+      resolveNoGoalTurnStarted();
+    };
+    const scheduleNoTurnTimer = () => {
+      if (released || resolved || !goalUpdated || activeAfterGoalUpdate || timeout !== null) {
+        return;
+      }
+      timeout = setTimeout(resolveNoTurn, runtimeEffectsGraceMs);
+    };
+    const release = () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      clearTimer();
+    };
+    const promise2 = new Promise((resolve) => {
+      resolveNoGoalTurnStarted = () => {
+        resolve(null);
+      };
+    });
+    const handleGoalUpdated = () => {
+      goalUpdated = true;
+      scheduleNoTurnTimer();
+    };
+    const handleThreadStatusChanged = (status) => {
+      if (!goalUpdated || released || resolved) {
+        return;
+      }
+      if (status.type === "active") {
+        activeAfterGoalUpdate = true;
+        clearTimer();
+        return;
+      }
+      if (activeAfterGoalUpdate) {
+        resolveNoTurn();
+      }
+    };
+    return {
+      promise: promise2,
+      release,
+      goalUpdated: handleGoalUpdated,
+      threadStatusChanged: handleThreadStatusChanged
+    };
+  }
   async runCompact(params) {
     const compactionCompleted = this.awaitCompactionCompleted(params.threadId);
     await this.threadCompactStart(params);
@@ -28014,6 +28320,12 @@ var CodexAppServerClient = class {
   async threadCompactStart(params) {
     return await this.sendRequest({ method: "thread/compact/start", params });
   }
+  async threadGoalSet(params) {
+    return await this.sendRequest({ method: "thread/goal/set", params });
+  }
+  async threadGoalClear(params) {
+    return await this.sendRequest({ method: "thread/goal/clear", params });
+  }
   async listMcpServerStatus(params) {
     return await this.sendRequest({ method: "mcpServerStatus/list", params });
   }
@@ -28145,6 +28457,57 @@ var CodexAppServerClient = class {
       resolve(event);
     }
   }
+  recordThreadStatusChanged(event) {
+    const captures = this.threadStatusCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(event.status);
+    }
+  }
+  recordThreadGoalUpdated(event) {
+    const captures = this.threadGoalUpdateCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(event);
+    }
+  }
+  recordThreadGoalCleared(event) {
+    const captures = this.threadGoalClearedCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture();
+    }
+  }
+  recordTurnRouting(routing) {
+    if (routing.threadId === null || routing.turnId === null) {
+      return;
+    }
+    const captures = this.turnRoutingCaptures.get(routing.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(routing.turnId);
+    }
+  }
+  handleStaleTurnNotification(notification, routing) {
+    if (!this.isStaleTurn(routing.threadId, routing.turnId)) {
+      return false;
+    }
+    if (isTurnCompletedNotification(notification) && routing.threadId !== null && routing.turnId !== null) {
+      this.clearStaleTurn(routing.threadId, routing.turnId);
+    }
+    for (const callback of this.codexEventHandlers) {
+      callback({ eventType: "notification", ...notification });
+    }
+    return true;
+  }
   isStaleTurn(threadId, turnId) {
     if (threadId === null || turnId === null) {
       return false;
@@ -28186,6 +28549,70 @@ var CodexAppServerClient = class {
       }
     };
   }
+  captureTurnRoutings(threadId, capture) {
+    const captures = this.turnRoutingCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.turnRoutingCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.turnRoutingCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadStatuses(threadId, capture) {
+    const captures = this.threadStatusCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadStatusCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadStatusCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadGoalUpdates(threadId, capture) {
+    const captures = this.threadGoalUpdateCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadGoalUpdateCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadGoalUpdateCaptures.delete(threadId);
+      }
+    };
+  }
+  captureThreadGoalClears(threadId, capture) {
+    const captures = this.threadGoalClearedCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.threadGoalClearedCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.threadGoalClearedCaptures.delete(threadId);
+      }
+    };
+  }
   resolveMcpServerStartupResolvers() {
     const pendingResolvers = [];
     for (const resolver of this.mcpServerStartupResolvers) {
@@ -28248,12 +28675,24 @@ function isMcpServerStatusUpdatedNotification(notification) {
 function isTurnCompletedNotification(notification) {
   return notification.method === "turn/completed";
 }
+function isThreadStatusChangedNotification(notification) {
+  return notification.method === "thread/status/changed";
+}
+function isThreadGoalUpdatedNotification(notification) {
+  return notification.method === "thread/goal/updated";
+}
+function isThreadGoalClearedNotification(notification) {
+  return notification.method === "thread/goal/cleared";
+}
 function isCompactionCompletedNotification(notification) {
   if (notification.method === "thread/compacted") {
     return true;
   }
   return notification.method === "item/completed" && notification.params.item.type === "contextCompaction";
 }
+function goalsMatch(left, right) {
+  return left.threadId === right.threadId && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.updatedAt === right.updatedAt;
+}
 function extractThreadId(notification) {
   const params = notification.params;
   if (params && typeof params.threadId === "string") {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.0.0",
-    "@openai/codex": "^0.142.2",
+    "@openai/codex": "^0.142.4",
     "diff": "^8.0.3",
     "open": "^11.0.0",
     "vscode-jsonrpc": "^8.2.1",