lody 0.92.1 → 0.93.2

package/dist/chunks/{index-Cy4lnlSp.js → index-Bxge7nr7.js}

@@ -5,7 +5,7 @@ import { Writable, Readable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import fs__default from "node:fs";
 import path__default from "node:path";
-import Xt__default, { constants, readFile } from "node:fs/promises";
+import Xt__default, { constants, readFile, realpath } from "node:fs/promises";
 import { randomUUID, createHash } from "node:crypto";
 import process$1 from "node:process";
 import { fileURLToPath } from "node:url";
@@ -3418,7 +3418,7 @@ var require_main = __commonJS({
     exports$1.createMessageConnection = createMessageConnection2;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path9 = __importStar(__require("path"));
+    var path10 = __importStar(__require("path"));
     var os2 = __importStar(__require("os"));
     var fs8 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
@@ -3570,7 +3570,7 @@ var require_main = __commonJS({
         throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
       }
       const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-      return path9.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path10.join(tmpDir, `lsp-${randomSuffix}.sock`);
     }
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
@@ -4461,10 +4461,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4847,11 +4847,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -5032,7 +5032,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path9 = []) => {
+  const processError = (error49, path10 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5042,7 +5042,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5074,8 +5074,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16910,13 +16910,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -21033,7 +21033,32 @@ var LODY_EXTENSION_METHODS = {
 var LODY_TOOL_NAMES = {
   imageGeneration: "ImageGeneration"
 };
+var LODY_PLAN_MODE_CONFIG_ID = "plan_mode";
+function createPlanModeConfigOption(currentValue) {
+  return {
+    id: LODY_PLAN_MODE_CONFIG_ID,
+    name: "Plan",
+    description: "Plan before implementing; permissions are controlled separately.",
+    type: "boolean",
+    currentValue
+  };
+}
+var GOAL_EXTENSION_VERSION = 1;
 var GOAL_CONTROL_METHOD = LODY_EXTENSION_METHODS.sessionGoal;
+function parseGoalPromptControl(meta3) {
+  if (typeof meta3 !== "object" || meta3 === null) return null;
+  const lody = meta3["lody"];
+  if (typeof lody !== "object" || lody === null) return null;
+  const control = lody["goalControl"];
+  if (typeof control !== "object" || control === null) return null;
+  const { version: version2, action, objective } = control;
+  if (version2 !== GOAL_EXTENSION_VERSION) return null;
+  if (action === "pause" || action === "resume" || action === "clear") {
+    return { version: GOAL_EXTENSION_VERSION, action };
+  }
+  if (action !== "set") return null;
+  return typeof objective === "string" && objective.trim().length > 0 ? { version: GOAL_EXTENSION_VERSION, action: "set", objective } : null;
+}
 var ASYNC_TASK_STOP_METHOD = "_session/async_task/stop";
 var AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
 var AUTH_STATUS_META_KEY = "authStatus";
@@ -21185,9 +21210,17 @@ var CODEX_LODY_CAPABILITIES = {
   },
   tasks: { version: 1, background: true },
   subagents: { version: 1, lifecycle: true },
-  goal: { version: 1, actions: ["set", "pause", "resume", "clear"] },
+  goal: {
+    version: 1,
+    actions: ["set", "pause", "resume", "clear"],
+    // Status-only actions are safe mid-prompt; anything that starts work
+    // needs the client's prompt to own the turns it produces.
+    controlActions: ["pause", "clear"],
+    promptActions: ["set", "pause", "resume", "clear"]
+  },
   compaction: { version: 1 },
-  sessionHistory: { version: 1 }
+  sessionHistory: { version: 1 },
+  worktreeProject: { version: 1 }
 };
 function getLodyForkTurnId(meta3) {
   if (typeof meta3 !== "object" || meta3 === null) return null;
@@ -22342,13 +22375,13 @@ function createTerminalCommandEvent(event, terminalId, cwd) {
     }
   };
 }
-function createSearchTitle(query, path9) {
-  if (query && path9) {
-    return `Search for '${query}' in ${path9}`;
+function createSearchTitle(query, path10) {
+  if (query && path10) {
+    return `Search for '${query}' in ${path10}`;
   } else if (query) {
     return `Search for '${query}'`;
-  } else if (path9) {
-    return `Search in '${path9}'`;
+  } else if (path10) {
+    return `Search in '${path10}'`;
   }
   return "Search";
 }
@@ -22576,12 +22609,12 @@ function revertPatch(unifiedDiff) {
   if (!patch) return null;
   return reversePatch(patch);
 }
-function createUpdateDiffContent(path9, oldText, newText) {
+function createUpdateDiffContent(path10, oldText, newText) {
   return {
     type: "diff",
     oldText,
     newText,
-    path: path9,
+    path: path10,
     _meta: {
       kind: "update"
     }
@@ -22798,16 +22831,16 @@ function clientSupportsAirCapability(capabilities, capability) {
   const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
   return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
 }
-function normalizeAgentPath(path9) {
-  const normalized = path9.trim().replace(/\/+$/, "");
+function normalizeAgentPath(path10) {
+  const normalized = path10.trim().replace(/\/+$/, "");
   return normalized || "/root";
 }
-function isRootAgentPath(path9) {
-  const normalized = normalizeAgentPath(path9);
+function isRootAgentPath(path10) {
+  const normalized = normalizeAgentPath(path10);
   return normalized === "/root" || normalized === "root";
 }
-function nameFromAgentPath(path9, fallback) {
-  const normalized = normalizeAgentPath(path9);
+function nameFromAgentPath(path10, fallback) {
+  const normalized = normalizeAgentPath(path10);
   const name = normalized.slice(normalized.lastIndexOf("/") + 1).trim();
   if (!name) return fallback;
   const words = name.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
@@ -23040,11 +23073,11 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
     const child = this.children.get(threadId);
     return child && child.terminalState === void 0 ? [{ threadId, sessionId: child.sessionId }] : [];
   }
-  async materialize(childSessionId, path9) {
+  async materialize(childSessionId, path10) {
     if (this.children.has(childSessionId)) return;
     const pending = this.pendingSpawns.get(childSessionId);
-    const name = nameFromAgentPath(path9, fallbackName(childSessionId));
-    const inferredParent = this.parentForPath(path9);
+    const name = nameFromAgentPath(path10, fallbackName(childSessionId));
+    const inferredParent = this.parentForPath(path10);
     const parentThreadId = pending?.parentThreadId ?? inferredParent.threadId;
     const parentSessionId = pending?.parentSessionId ?? inferredParent.sessionId;
     const task = pending?.task ?? `Delegated task for ${name}`;
@@ -23061,7 +23094,7 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
       sessionId: childSessionId,
       name,
       task,
-      path: normalizeAgentPath(path9),
+      path: normalizeAgentPath(path10),
       generation: 1
     });
     this.pendingSpawns.delete(childSessionId);
@@ -23152,8 +23185,8 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
     for (const waiter of this.waiters) waiter();
     this.waiters.clear();
   }
-  parentForPath(path9) {
-    const normalized = normalizeAgentPath(path9);
+  parentForPath(path10) {
+    const normalized = normalizeAgentPath(path10);
     const separator = normalized.lastIndexOf("/");
     if (separator <= 0) return { threadId: this.rootSessionId, sessionId: this.rootSessionId };
     const parentPath = normalized.slice(0, separator);
@@ -24866,7 +24899,7 @@ function permissionProfileContent(permissions) {
   return lines.length > 0 ? [textContent(lines.join("\n"))] : [];
 }
 function locationsField(paths) {
-  return paths.length > 0 ? { locations: paths.map((path9) => ({ path: path9 })) } : {};
+  return paths.length > 0 ? { locations: paths.map((path10) => ({ path: path10 })) } : {};
 }
 function textContent(text) {
   return { type: "content", content: { type: "text", text } };
@@ -25709,6 +25742,78 @@ function getCodexAuthMethods(clientCapabilities, env = process.env) {
 function isCodexAuthRequest(request) {
   return request.methodId === "api-key" || request.methodId === "chat-gpt" || request.methodId === "chat-gpt-device-code" || request.methodId === "gateway";
 }
+function readWorktreeProject(meta3) {
+  if (typeof meta3 !== "object" || meta3 === null) return void 0;
+  const lody = meta3["lody"];
+  if (typeof lody !== "object" || lody === null) return void 0;
+  const value = lody["worktreeProject"];
+  if (value === void 0) return void 0;
+  if (typeof value === "object" && value !== null) {
+    const project = value;
+    if (project["version"] === 1 && typeof project["originProjectPath"] === "string" && path__default.isAbsolute(project["originProjectPath"]) && !project["originProjectPath"].includes("\0")) {
+      return { version: 1, originProjectPath: project["originProjectPath"] };
+    }
+  }
+  throw RequestError.invalidParams(void 0, "worktreeProject requires version 1 and an absolute originProjectPath");
+}
+var WorktreeProjects = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async resolve(project) {
+    if (!project) return void 0;
+    const originProjectPath = await realpath(project.originProjectPath);
+    const key = projectRootKey(originProjectPath);
+    return this.findOrCreate(originProjectPath, key);
+  }
+  async assign(thread, project, preserveExisting) {
+    if (!project || preserveExisting && thread.projectId) return;
+    const projectId = await this.resolve(project);
+    if (projectId && projectId !== thread.projectId) {
+      await this.client.threadProjectUpdate({ threadId: thread.id, projectId });
+    }
+  }
+  async findOrCreate(originProjectPath, key) {
+    let cursor;
+    const matches = /* @__PURE__ */ new Set();
+    do {
+      const page = await this.client.projectList({ limit: 100, ...cursor ? { cursor } : {} });
+      for (const project of page.data) {
+        for (const root of project.roots) {
+          if (projectRootKey(root.path) === key || await this.matchesRoot(root.path, key)) {
+            matches.add(project.id);
+            break;
+          }
+        }
+      }
+      cursor = page.nextCursor ?? void 0;
+    } while (cursor);
+    if (matches.size > 1) {
+      throw RequestError.invalidParams(void 0, "Multiple Codex projects use this root; consolidate the project assignments first");
+    }
+    const match = matches.values().next().value;
+    if (match) return match;
+    const idempotencyKey = `acp-project-v1:${createHash("sha256").update(key).digest("hex")}`;
+    const response = await this.client.projectCreate({
+      idempotencyKey,
+      name: path__default.basename(originProjectPath) || originProjectPath,
+      roots: [{ path: originProjectPath }]
+    });
+    return response.project.id;
+  }
+  async matchesRoot(storedPath, key) {
+    try {
+      return projectRootKey(await realpath(storedPath)) === key;
+    } catch {
+      return false;
+    }
+  }
+};
+function projectRootKey(originProjectPath) {
+  const normalized = path__default.resolve(originProjectPath);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
 var isDockerCached;
 function hasDockerEnv() {
   try {
@@ -25864,16 +25969,16 @@ var wslDefaultBrowser = async () => {
   });
   return stdout.trim();
 };
-var isUrl = (path9) => /^[a-z]+:\/\//i.test(path9);
+var isUrl = (path10) => /^[a-z]+:\/\//i.test(path10);
 var convertWslPathToWindows = async (paths) => {
   const isBatch = Array.isArray(paths);
   const pathArray = isBatch ? paths : [paths];
   const indicesToConvert = [];
   const pathsToConvert = [];
-  for (const [index, path9] of pathArray.entries()) {
-    if (!isUrl(path9)) {
+  for (const [index, path10] of pathArray.entries()) {
+    if (!isUrl(path10)) {
       indicesToConvert.push(index);
-      pathsToConvert.push(path9);
+      pathsToConvert.push(path10);
     }
   }
   const results = [...pathArray];
@@ -26476,7 +26581,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.10.0",
+  version: "1.10.1",
   description: "An ACP-compatible coding agent powered by Codex",
   main: "dist/index.js",
   bin: {
@@ -26546,29 +26651,17 @@ var package_default = {
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
     "@openai/codex": "^0.153.4",
-    "acp-extension-core": "0.1.0",
+    "acp-extension-core": "0.1.4",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
     zod: "^4.0.0"
   }
 };
-var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
 var DEFAULT_COLLABORATION_MODE = "default";
 var PLAN_COLLABORATION_MODE = "plan";
 function createCollaborationModeConfigOption(currentValue) {
-  return {
-    id: COLLABORATION_MODE_CONFIG_ID,
-    name: "Collaboration mode",
-    description: "How Codex collaborates for subsequent turns",
-    category: "collaboration_mode",
-    type: "select",
-    currentValue,
-    options: [
-      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
-      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
-    ]
-  };
+  return createPlanModeConfigOption(currentValue === PLAN_COLLABORATION_MODE);
 }
 function parseCollaborationMode(value) {
   if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
@@ -27034,6 +27127,7 @@ var CodexSubagentSubscriptions = class {
   }
 };
 async function forkSession(request, additionalDirectories, dependencies) {
+  const project = readWorktreeProject(request._meta);
   await dependencies.refreshSkills(request.cwd, additionalDirectories);
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
   const response = await dependencies.codexClient.threadFork({
@@ -27047,7 +27141,12 @@ async function forkSession(request, additionalDirectories, dependencies) {
     modelProvider: await dependencies.getResumeModelProvider(),
     threadId: request.sessionId
   });
-  await dependencies.codexClient.threadUnsubscribe({ threadId: response.thread.id });
+  try {
+    await dependencies.assignProject(response.thread, project);
+  } catch (error48) {
+    await dependencies.codexClient.threadUnsubscribe({ threadId: response.thread.id });
+    throw error48;
+  }
   const models = await dependencies.fetchAvailableModels();
   return {
     sessionId: response.thread.id,
@@ -27139,10 +27238,12 @@ var CodexAcpClient = class {
   pendingAccountUpdated = null;
   sessionNotificationQueues = /* @__PURE__ */ new Map();
   subagents;
+  worktreeProjects;
   skillExtraRoots = [];
   configPath = null;
   constructor(codexClient, codexConfig, modelProvider) {
     this.codexClient = codexClient;
+    this.worktreeProjects = new WorktreeProjects(codexClient);
     this.config = codexConfig ?? {};
     this.modelProvider = modelProvider ?? null;
     this.gatewayConfig = null;
@@ -27493,6 +27594,7 @@ var CodexAcpClient = class {
     return settingsModelProvider?.config?.model_provider ?? null;
   }
   async resumeSession(request, onSubscribed) {
+    const project = readWorktreeProject(request._meta);
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
@@ -27502,6 +27604,7 @@ var CodexAcpClient = class {
       threadId: request.sessionId
     });
     onSubscribed?.(request.sessionId);
+    await this.worktreeProjects.assign(response.thread, project, true);
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -27518,6 +27621,7 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     return await forkSession(request, additionalDirectories, {
       codexClient: this.codexClient,
+      assignProject: (thread, project) => this.worktreeProjects.assign(thread, project, false),
       refreshSkills: (cwd, directories) => this.refreshSkills(cwd, directories),
       createSessionConfig: (cwd, directories, mcpServers) => this.createSessionConfig(cwd, directories, mcpServers),
       getResumeModelProvider: () => this.getResumeModelProvider(),
@@ -27527,6 +27631,7 @@ var CodexAcpClient = class {
     });
   }
   async loadSession(request, onSubscribed) {
+    const project = readWorktreeProject(request._meta);
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
@@ -27536,6 +27641,7 @@ var CodexAcpClient = class {
       threadId: request.sessionId
     });
     onSubscribed?.();
+    await this.worktreeProjects.assign(response.thread, project, true);
     const historyResponse = await this.codexClient.threadRead({
       threadId: response.thread.id,
       includeTurns: true
@@ -27557,9 +27663,12 @@ var CodexAcpClient = class {
     return await this.readSessionHistory(sessionId);
   }
   async newSession(request, onSubscribed) {
+    const project = readWorktreeProject(request._meta);
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const projectId = await this.worktreeProjects.resolve(project);
     const response = await this.codexClient.threadStart({
+      ...projectId ? { projectId } : {},
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers),
       modelProvider: this.getModelProvider(),
       cwd: request.cwd
@@ -27789,6 +27898,14 @@ var CodexAcpClient = class {
       await queue;
     }
   }
+  onConnectionClosed(callback) {
+    const close = this.codexClient.connection.onClose(callback);
+    const dispose = this.codexClient.connection.onDispose(callback);
+    return () => {
+      close.dispose();
+      dispose.dispose();
+    };
+  }
   enqueueSessionNotification(sessionId, operation) {
     const run = async () => {
       try {
@@ -28192,8 +28309,8 @@ function formatUriAsLink(name, uri) {
     return `[@${name}](${uri})`;
   }
   if (uri.startsWith("file://")) {
-    const path9 = uri.replace("file://", "");
-    const fileName = path9.split("/").pop() ?? path9;
+    const path10 = uri.replace("file://", "");
+    const fileName = path10.split("/").pop() ?? path10;
     return `[@${fileName}](${uri})`;
   }
   return uri;
@@ -28655,6 +28772,15 @@ var CodexAppServerClient = class {
     threadStaleTurns.add(turnId);
     this.staleTurnIds.set(threadId, threadStaleTurns);
   }
+  async projectList(params) {
+    return await this.sendRequest({ method: "project/list", params });
+  }
+  async projectCreate(params) {
+    return await this.sendRequest({ method: "project/create", params });
+  }
+  async threadProjectUpdate(params) {
+    await this.sendRequest({ method: "thread/metadata/update", params });
+  }
   async threadStart(params) {
     return await this.sendRequest({ method: "thread/start", params });
   }
@@ -29193,12 +29319,13 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
     }))
   };
 }
+var GOAL_OBJECTIVE_MAX_LENGTH = 4e3;
 var GOAL_CONTINUATION_PROMPT = [{
   type: "text",
   text: "Continue working toward the active goal."
 }];
 function resolveGoalCommandHandleResult(turnCompleted) {
-  if (turnCompleted?.turn.status === "interrupted") {
+  if (turnCompleted !== null) {
     return { handled: true, turnCompleted };
   }
   return { handled: false, prompt: GOAL_CONTINUATION_PROMPT };
@@ -29281,9 +29408,9 @@ var CodexCommands = class {
         _meta: {
           commandAction: {
             kind: "setConfigOption",
-            configId: COLLABORATION_MODE_CONFIG_ID,
-            value: PLAN_COLLABORATION_MODE,
-            resetValue: DEFAULT_COLLABORATION_MODE,
+            configId: LODY_PLAN_MODE_CONFIG_ID,
+            value: true,
+            resetValue: false,
             presentation: "state"
           }
         }
@@ -29372,8 +29499,8 @@ var CodexCommands = class {
           await this.sendCommandUsageMessage(commandName, "no arguments", sessionId);
           return { handled: true };
         }
-        const mode = sessionState.collaborationMode === PLAN_COLLABORATION_MODE ? DEFAULT_COLLABORATION_MODE : PLAN_COLLABORATION_MODE;
-        await options.setConfigOption?.(COLLABORATION_MODE_CONFIG_ID, mode);
+        const mode = sessionState.collaborationMode !== PLAN_COLLABORATION_MODE;
+        await options.setConfigOption?.(LODY_PLAN_MODE_CONFIG_ID, mode);
         return { handled: options.setConfigOption !== void 0 };
       }
       case "compact": {
@@ -29476,35 +29603,56 @@ var CodexCommands = class {
       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 };
+    const named = argument.toLowerCase();
+    if (named === "pause" || named === "resume" || named === "clear") {
+      return await this.runGoalPromptControl(
+        sessionState,
+        { version: GOAL_EXTENSION_VERSION, action: named },
+        options
+      );
     }
-    if (argument.length > 4e3) {
+    if (argument.length > GOAL_OBJECTIVE_MAX_LENGTH) {
       const session = new ACPSessionConnection(this.connection, sessionId);
-      await session.update(createAgentTextMessageChunk('Command "/goal" requires goal text of at most 4000 characters.'));
+      await session.update(createAgentTextMessageChunk(
+        `Command "/goal" requires goal text of at most ${GOAL_OBJECTIVE_MAX_LENGTH} characters.`
+      ));
       return { handled: true };
     }
+    return await this.runGoalPromptControl(
+      sessionState,
+      { version: GOAL_EXTENSION_VERSION, action: "set", objective: argument },
+      options
+    );
+  }
+  /**
+   * Run a goal action inside whatever prompt is already executing. `/goal …`
+   * and a prompt carrying `_meta.lody.goalControl` are the same operation
+   * reaching the same place: the caller's prompt owns any turn the action
+   * starts, so neither has to start one behind the client's back.
+   */
+  async runGoalPromptControl(sessionState, control, options = {}) {
+    const sessionId = sessionState.sessionId;
+    if (control.action === "pause") {
+      await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionId, "paused"));
+      return { handled: true };
+    }
+    if (control.action === "clear") {
+      await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionId));
+      return { handled: true };
+    }
+    if (control.action === "set" && control.objective.trim().length > GOAL_OBJECTIVE_MAX_LENGTH) {
+      throw RequestError.invalidParams(
+        void 0,
+        `A goal objective may be at most ${GOAL_OBJECTIVE_MAX_LENGTH} characters`
+      );
+    }
     options.onTurnStartPending?.();
-    return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.setGoal(
-      sessionId,
-      argument,
-      (turnId) => {
-        this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
-      }
-    )));
+    const onTurnStarted = (turnId) => {
+      this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
+    };
+    return this.createGoalCommandResult(await this.runWithProcessCheck(
+      () => control.action === "set" ? this.codexAcpClient.setGoal(sessionId, control.objective.trim(), onTurnStarted) : this.codexAcpClient.resumeGoal(sessionId, onTurnStarted)
+    ));
   }
   handleCommandTurnStarted(sessionState, options, turnId, threadId) {
     if (options.onTurnStarted) {
@@ -29697,6 +29845,77 @@ var CodexCommands = class {
     return count.toString();
   }
 };
+var GoalPromptLifecycle = class {
+  constructor(sessionId, goalActive) {
+    this.sessionId = sessionId;
+    this.goalActive = goalActive;
+  }
+  sessionId;
+  goalActive;
+  currentTurnId = null;
+  completed = null;
+  failure = null;
+  waiter = null;
+  cancelled = false;
+  startTurn(turnId) {
+    if (this.currentTurnId === turnId) return;
+    this.currentTurnId = turnId;
+    this.completed = null;
+  }
+  prepareTurn() {
+    this.currentTurnId = null;
+    this.completed = null;
+  }
+  /** A delayed turn/start response must not overwrite already-observed native work. */
+  startSubmittedTurn(turnId) {
+    if (this.currentTurnId !== null || this.completed !== null) return false;
+    this.startTurn(turnId);
+    return true;
+  }
+  observe(event) {
+    if (event.method === "thread/goal/updated" && event.params.threadId === this.sessionId) {
+      this.goalActive = event.params.goal.status === "active";
+    } else if (event.method === "thread/goal/cleared" && event.params.threadId === this.sessionId) {
+      this.goalActive = false;
+    } else if (event.method === "turn/started" && event.params.threadId === this.sessionId) {
+      this.startTurn(event.params.turn.id);
+    } else if (event.method === "turn/completed" && event.params.threadId === this.sessionId) {
+      this.recordCompletion(event.params);
+    } else {
+      return;
+    }
+    this.waiter?.();
+  }
+  recordCompletion(event) {
+    this.completed = event;
+    if (this.currentTurnId === event.turn.id) this.currentTurnId = null;
+  }
+  cancel() {
+    this.cancelled = true;
+    this.waiter?.();
+  }
+  fail(error48) {
+    this.failure = error48;
+    this.waiter?.();
+  }
+  async waitForCompletion(first) {
+    if (first.threadId !== this.sessionId) return first;
+    if (this.completed === null) this.recordCompletion(first);
+    const result = await new Promise((resolve, reject) => {
+      this.waiter = () => {
+        if (this.failure) reject(this.failure);
+        else if (this.cancelled && this.currentTurnId === null) resolve(null);
+        else if (this.completed && this.currentTurnId === null && (!this.goalActive || this.completed.turn.status !== "completed")) {
+          resolve(this.completed);
+        }
+      };
+      this.waiter();
+    }).finally(() => {
+      this.waiter = null;
+    });
+    return result;
+  }
+};
 var SteeringQueue = class {
   constructor(handle) {
     this.handle = handle;
@@ -29978,8 +30197,8 @@ function imageBlocks(images) {
       return [{ type: "text", text: `[@image](${image})` }];
     }
     const record2 = asRecord2(image);
-    const path9 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
-    return path9 ? [{ type: "text", text: `[@image](${path9})` }] : [];
+    const path10 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
+    return path10 ? [{ type: "text", text: `[@image](${path10})` }] : [];
   });
 }
 function contentBlocksFromResponseContent(content) {
@@ -32247,8 +32466,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
       case MODE_CONFIG_ID:
         this.applyModeChange(sessionState, this.stringConfigValue(params));
         break;
-      case COLLABORATION_MODE_CONFIG_ID:
-        await this.applyCollaborationModeChange(sessionState, this.stringConfigValue(params));
+      case LODY_PLAN_MODE_CONFIG_ID:
+        if (typeof params.value !== "boolean") throw RequestError.invalidParams();
+        await this.applyCollaborationModeChange(sessionState, params.value ? PLAN_COLLABORATION_MODE : DEFAULT_COLLABORATION_MODE);
         break;
       case MODEL_CONFIG_ID:
         this.applyModelChange(sessionState, this.stringConfigValue(params));
@@ -33147,8 +33367,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("file://")) {
-      const path9 = uri.replace("file://", "");
-      const fileName = path9.split("/").pop() ?? path9;
+      const path10 = uri.replace("file://", "");
+      const fileName = path10.split("/").pop() ?? path10;
       return `[@${fileName}](${uri})`;
     }
     return uri;
@@ -33294,6 +33514,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       cancelSignal,
       signal: abortController.signal,
       currentTurn: null,
+      hasCompletedTurn: false,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -33488,12 +33709,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
     });
     const sessionState = this.getSessionState(params.sessionId);
     const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
+    const goalPromptControl = parseGoalPromptControl(params._meta);
     let agentFileChangeReportTurnId = null;
     let agentFileChangeReportUnavailableReason = "providerError";
     let promptWasCancelled = false;
     let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
+    const goalLifecycle = new GoalPromptLifecycle(params.sessionId, sessionState.currentGoal?.status === "active");
+    const cancelGoalLifecycle = () => goalLifecycle.cancel();
+    activePrompt.signal.addEventListener("abort", cancelGoalLifecycle);
+    const disposeGoalConnection = this.codexAcpClient.onConnectionClosed(() => {
+      goalLifecycle.fail(new Error("Codex connection closed during goal continuation"));
+    });
     let pendingTurnStart = null;
     const ensurePendingTurnStart = () => {
       if (pendingTurnStart === null) {
@@ -33549,6 +33777,23 @@ Check ${configPath} and project .codex directories, especially their config.toml
       await this.codexAcpClient.subscribeToSessionEvents(
         params.sessionId,
         async (event) => {
+          if (this.activePrompts.get(params.sessionId) === activePrompt) {
+            goalLifecycle.observe(event);
+            if (event.method === "turn/started" && event.params.threadId === params.sessionId) {
+              const turn = { threadId: params.sessionId, turnId: event.params.turn.id };
+              activePrompt.currentTurn = turn;
+              if (this.promptShouldStop(params.sessionId, activePrompt)) {
+                this.interruptLateStartedTurn(turn);
+                return;
+              }
+              recoverableSessionFailure = sessionState.sessionFailure;
+              promptNotificationsActive = true;
+            }
+            if (event.method === "turn/completed" && event.params.threadId === params.sessionId && activePrompt.currentTurn?.turnId === event.params.turn.id) {
+              activePrompt.currentTurn = null;
+              activePrompt.hasCompletedTurn = true;
+            }
+          }
           await this.handleSteerAppliedNotification(params.sessionId, event, activePrompt);
           await observeInteraction(event);
           if (!promptNotificationsActive) {
@@ -33570,13 +33815,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       if (activePrompt.signal.aborted) {
         return cancelledPromptResponse();
       }
-      const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+      const commandOptions = {
         onTurnStartPending: () => {
           sessionState.lastTokenUsage = null;
           ensurePendingTurnStart();
         },
         onTurnStarted: (turnId, threadId) => {
           const turn = { threadId, turnId };
+          if (threadId === params.sessionId) goalLifecycle.startTurn(turnId);
           activePrompt.currentTurn = turn;
           if (this.promptShouldStop(params.sessionId, activePrompt)) {
             this.interruptLateStartedTurn(turn);
@@ -33590,7 +33836,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           await this.applySessionConfigOption(sessionState, {
             sessionId: sessionState.sessionId,
             configId,
-            value
+            ...typeof value === "boolean" ? { type: "boolean", value } : { value }
           });
           const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
           await session.update({
@@ -33598,13 +33844,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
             configOptions: this.createSessionConfigOptions(sessionState)
           });
         }
-      });
+      };
+      const commandPromise = goalPromptControl === null ? this.availableCommands.tryHandleCommand(params.prompt, sessionState, commandOptions) : this.availableCommands.runGoalPromptControl(sessionState, goalPromptControl, commandOptions);
       void commandPromise.catch((err) => {
         if (this.activePrompts.get(params.sessionId) !== activePrompt) {
           logger.error(`Command for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
         }
       });
-      const commandResult = await Promise.race([
+      let commandResult = await Promise.race([
         commandPromise,
         activePrompt.closeSignal,
         this.cancelBeforeTurnStarted(activePrompt)
@@ -33613,6 +33860,16 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return cancelledPromptResponse();
       }
       if (commandResult.handled) {
+        if (commandResult.turnCompleted) {
+          await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          const firstCommandTurn = commandResult.turnCompleted;
+          const completed = await this.runWithProcessCheck(() => Promise.race([
+            goalLifecycle.waitForCompletion(firstCommandTurn),
+            activePrompt.closeSignal
+          ]));
+          if (completed === null) return cancelledPromptResponse();
+          commandResult = { ...commandResult, turnCompleted: completed };
+        }
         promptNotificationsActive = false;
         logger.log("Prompt handled by a command");
         await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
@@ -33671,6 +33928,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       );
       sessionState.lastTokenUsage = null;
       ensurePendingTurnStart();
+      goalLifecycle.prepareTurn();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           effectiveParams,
@@ -33682,6 +33940,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
           sessionState.additionalDirectories,
           (turnId) => {
             const turn = { threadId: params.sessionId, turnId };
+            if (!goalLifecycle.startSubmittedTurn(turnId)) {
+              pendingTurnStart?.resolve(turnId);
+              onTurnStarted?.();
+              return;
+            }
             activePrompt.currentTurn = turn;
             if (this.promptShouldStop(params.sessionId, activePrompt)) {
               this.interruptLateStartedTurn(turn);
@@ -33708,6 +33971,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return cancelledPromptResponse();
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      const firstPromptTurn = turnCompleted;
+      turnCompleted = await this.runWithProcessCheck(() => Promise.race([
+        goalLifecycle.waitForCompletion(firstPromptTurn),
+        activePrompt.closeSignal
+      ]));
+      if (turnCompleted === null) return cancelledPromptResponse();
+      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "completed") {
         await eventHandler.waitForNativeSubagents(activePrompt.signal);
         if (activePrompt.signal.aborted) return cancelledPromptResponse();
@@ -33760,6 +34030,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           };
           activePrompt.currentTurn = null;
           sessionState.currentTurnId = null;
+          goalLifecycle.prepareTurn();
           const implementationPromise = this.runWithProcessCheck(
             () => this.codexAcpClient.sendPrompt(
               implementationRequest,
@@ -33771,6 +34042,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               sessionState.additionalDirectories,
               (turnId) => {
                 const turn = { threadId: params.sessionId, turnId };
+                if (!goalLifecycle.startSubmittedTurn(turnId)) return;
                 activePrompt.currentTurn = turn;
                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
                   this.interruptLateStartedTurn(turn);
@@ -33797,6 +34069,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
             return cancelledPromptResponse();
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          const firstImplementationTurn = turnCompleted;
+          turnCompleted = await this.runWithProcessCheck(() => Promise.race([
+            goalLifecycle.waitForCompletion(firstImplementationTurn),
+            activePrompt.closeSignal
+          ]));
+          if (turnCompleted === null) return cancelledPromptResponse();
+          await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
           if (turnCompleted.turn.status === "completed") {
             await eventHandler.waitForNativeSubagents(activePrompt.signal);
             if (activePrompt.signal.aborted) return cancelledPromptResponse();
@@ -33870,6 +34149,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       throw err;
     } finally {
+      if ((promptWasCancelled || activePrompt.signal.aborted) && sessionState.currentGoal?.status === "active") {
+        try {
+          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(params.sessionId, "paused"));
+          await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
+        } catch (error48) {
+          logger.error("Failed to pause goal after prompt cancellation", error48);
+        }
+      }
       promptNotificationsActive = false;
       try {
         await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
@@ -33890,6 +34177,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       logger.log("Prompt completed", { sessionId: params.sessionId });
       await eventHandler?.dispose();
+      disposeGoalConnection();
+      goalLifecycle.fail(new Error("ACP prompt closed"));
+      activePrompt.signal.removeEventListener("abort", cancelGoalLifecycle);
       disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
       const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
@@ -33996,6 +34286,12 @@ ${stderr}` : "";
       logger.log("Cancel request rejected: session not found", { sessionId: params.sessionId });
       return;
     }
+    const activePrompt = this.activePrompts.get(params.sessionId);
+    if (activePrompt?.hasCompletedTurn && activePrompt.currentTurn === null) {
+      activePrompt.requestCancel();
+      return;
+    }
+    if (activePrompt?.currentTurn) activePrompt.requestCancel();
     await this.interruptSessionTurn(sessionState, "Cancel", false);
   }
 };