feat(workspace): reuse opens within ChatGPT sessions

Author: Waishnav

docs/chatgpt-coding-workflow.md

@@ -17,6 +17,14 @@ ChatGPT should call `open_workspace` once for a project folder:
 The result includes a `workspaceId`. All later file, search, edit, show-changes,
 and shell calls should reuse that same `workspaceId`.
 
+ChatGPT sends an anonymized conversation identifier in
+`_meta["openai/session"]`. DevSpace uses that value only as a correlation scope:
+if `open_workspace` is called again for the same path, mode, and base ref in the
+same ChatGPT conversation, DevSpace returns the existing `workspaceId` and omits
+the project instructions, skills, subagent metadata, and diagnostics already
+returned by the first call. Pass `reopen: true` only when the user explicitly
+asks for a fresh workspace or another managed worktree.
+
 Do not reopen the same folder unless:
 
 - the `workspaceId` is rejected as unknown

package.json

@@ -28,7 +28,7 @@
     "dev": "node scripts/dev-server.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/skills.test.ts && tsx src/workspaces.test.ts && tsx src/review-checkpoints.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/skills.test.ts && tsx src/workspaces.test.ts && tsx src/review-checkpoints.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "keywords": [],

src/request-meta.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import { openAiConversationScope } from "./request-meta.js";
+
+assert.equal(openAiConversationScope(undefined), undefined);
+assert.equal(openAiConversationScope({}), undefined);
+assert.equal(openAiConversationScope({ "openai/session": "" }), undefined);
+
+assert.equal(
+  openAiConversationScope({ "openai/session": "chat-1" }),
+  JSON.stringify(["openai", null, null, "chat-1"]),
+);
+
+assert.equal(
+  openAiConversationScope({
+    "openai/session": "chat-1",
+    "openai/subject": "user-1",
+    "openai/organization": "org-1",
+  }),
+  JSON.stringify(["openai", "org-1", "user-1", "chat-1"]),
+);

src/request-meta.ts

@@ -0,0 +1,21 @@
+function metadataString(
+  meta: Record<string, unknown> | undefined,
+  key: string,
+): string | undefined {
+  const value = meta?.[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export function openAiConversationScope(
+  meta: Record<string, unknown> | undefined,
+): string | undefined {
+  const session = metadataString(meta, "openai/session");
+  if (!session) return undefined;
+
+  return JSON.stringify([
+    "openai",
+    metadataString(meta, "openai/organization") ?? null,
+    metadataString(meta, "openai/subject") ?? null,
+    session,
+  ]);
+}

src/server.ts

@@ -50,6 +50,7 @@ import {
 } from "./mcp-sessions.js";
 import { ProcessSessionManager, type ProcessSnapshot } from "./process-sessions.js";
 import { createReviewCheckpointManager } from "./review-checkpoints.js";
+import { openAiConversationScope } from "./request-meta.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
 import { formatPathForPrompt } from "./skills.js";
 import { createWorkspaceStore } from "./workspace-store.js";
@@ -751,7 +752,7 @@ function createMcpServer(
     {
       title: "Open workspace",
       description:
-        "Open a local project directory as a coding workspace. Call this once per project folder or worktree before reading, editing, searching, writing, showing changes, or running commands. Reuse the returned workspaceId for later calls in the same folder; do not call open_workspace again unless switching folders/worktrees, changing checkout/worktree mode, the workspaceId is rejected as unknown, or the user explicitly asks to reopen. By default this opens the actual checkout; set mode=\"worktree\" when the user asks for an isolated or parallel coding session. Returns a workspaceId, loaded root project instructions, and nested instruction file paths the model should read before working in those directories.",
+        "Open a local project directory as a coding workspace. Call this once per project folder or worktree before reading, editing, searching, writing, showing changes, or running commands. Reuse the returned workspaceId for later calls in the same folder. In ChatGPT, repeated calls for the same target in one conversation reuse the existing workspace and omit bootstrap details already returned. Set reopen=true only when the user explicitly asks for a fresh workspace. By default this opens the actual checkout; set mode=\"worktree\" when the user asks for an isolated or parallel coding session.",
       inputSchema: {
         path: z
           .string()
@@ -768,11 +769,19 @@ function createMcpServer(
           .string()
           .optional()
           .describe("Git ref to base a worktree on. Only used with mode=\"worktree\". Defaults to HEAD."),
+        reopen: z
+          .boolean()
+          .optional()
+          .describe(
+            "Bypass same-conversation workspace reuse and create a fresh workspace. Use only when the user explicitly asks to reopen or create another worktree.",
+          ),
       },
       outputSchema: {
         workspaceId: z.string(),
         root: z.string(),
         mode: z.enum(["checkout", "worktree"]),
+        reused: z.boolean(),
+        bootstrapIncluded: z.boolean(),
         sourceRoot: z.string().optional(),
         worktree: z
           .object({
@@ -784,60 +793,72 @@ function createMcpServer(
             managed: z.boolean(),
           })
           .optional(),
-        agentsFiles: z.array(workspaceAgentsFileOutputSchema),
-        availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema),
-        skills: z.array(workspaceSkillOutputSchema),
-        agentProviders: z.array(workspaceLocalAgentProviderOutputSchema),
-        agents: z.array(workspaceLocalAgentOutputSchema),
-        skillDiagnostics: z.array(z.unknown()),
+        agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
+        availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema).optional(),
+        skills: z.array(workspaceSkillOutputSchema).optional(),
+        agentProviders: z.array(workspaceLocalAgentProviderOutputSchema).optional(),
+        agents: z.array(workspaceLocalAgentOutputSchema).optional(),
+        skillDiagnostics: z.array(z.unknown()).optional(),
         instruction: z.string(),
       },
       ...toolWidgetDescriptorMeta(config, "workspace"),
       annotations: { readOnlyHint: true },
     },
-    async ({ path, mode, baseRef }) => {
+    async ({ path, mode, baseRef, reopen }, { _meta }) => {
       const startedAt = performance.now();
-      const { workspace, agentsFiles, availableAgentsFiles } = await workspaces.openWorkspace({ path, mode, baseRef });
+      const { workspace, agentsFiles, availableAgentsFiles, reused } = await workspaces.openWorkspace(
+        { path, mode, baseRef },
+        {
+          reuseScope: openAiConversationScope(_meta),
+          forceNew: reopen,
+        },
+      );
+      const bootstrapIncluded = !reused;
       if (config.widgets === "changes") {
         void reviewCheckpoints.initializeWorkspace({
           workspaceId: workspace.id,
           root: workspace.root,
         });
       }
-      const visibleSkills = workspace.skills
+      const visibleSkills = bootstrapIncluded ? workspace.skills
         .filter((skill) => !skill.disableModelInvocation)
         .map((skill) => ({
           name: skill.name,
           description: skill.description,
           path: formatPathForPrompt(skill.filePath),
-        }));
-      const visibleAgentProviders = config.subagents ? localAgentProviders : [];
-      const visibleAgents = workspace.agentProfiles.map((profile) => {
+        })) : [];
+      const visibleAgentProviders = bootstrapIncluded && config.subagents ? localAgentProviders : [];
+      const visibleAgents = bootstrapIncluded ? workspace.agentProfiles.map((profile) => {
         const summary = summarizeLocalAgentProfile(profile);
         const availability = visibleAgentProviders.find((provider) => provider.name === summary.provider);
         return {
           ...summary,
           providerAvailable: availability?.available,
           providerUnavailableReason: availability?.reason,
         };
-      });
-      const loadedAgentsFiles = agentsFiles.map((file) => ({
+      }) : [];
+      const loadedAgentsFiles = bootstrapIncluded ? agentsFiles.map((file) => ({
         path: formatAgentsPath(file.path, workspace.root),
         content: file.content,
-      }));
-      const availableAgentsFileOutputs = availableAgentsFiles.map((file) => ({
+      })) : [];
+      const availableAgentsFileOutputs = bootstrapIncluded ? availableAgentsFiles.map((file) => ({
         path: formatAgentsPath(file.path, workspace.root),
-      }));
-      const instruction = config.skillsEnabled
-        ? "Use this workspaceId in all subsequent tool calls for this project. Do not call open_workspace again for this same folder unless this workspaceId stops working, the user asks to reopen, or you switch to a different folder/worktree. Follow loaded agentsFiles instructions. Before working under a path listed in availableAgentsFiles, read that instruction file. When a task matches an available skill in skills, read its path before proceeding."
-        : "Use this workspaceId in all subsequent tool calls for this project. Do not call open_workspace again for this same folder unless this workspaceId stops working, the user asks to reopen, or you switch to a different folder/worktree. Follow loaded agentsFiles instructions. Before working under a path listed in availableAgentsFiles, read that instruction file.";
+      })) : [];
+      const instruction = reused
+        ? "Reuse this workspaceId for subsequent tool calls. Workspace instructions, nested instruction paths, skills, subagent metadata, and diagnostics were already returned earlier in this ChatGPT conversation and are intentionally omitted here."
+        : config.skillsEnabled
+          ? "Use this workspaceId in all subsequent tool calls for this project. Do not call open_workspace again for this same folder unless this workspaceId stops working, the user asks to reopen, or you switch to a different folder/worktree. Follow loaded agentsFiles instructions. Before working under a path listed in availableAgentsFiles, read that instruction file. When a task matches an available skill in skills, read its path before proceeding."
+          : "Use this workspaceId in all subsequent tool calls for this project. Do not call open_workspace again for this same folder unless this workspaceId stops working, the user asks to reopen, or you switch to a different folder/worktree. Follow loaded agentsFiles instructions. Before working under a path listed in availableAgentsFiles, read that instruction file.";
       const resultContent: ToolContent[] = [
         {
           type: "text" as const,
           text: [
-            `Opened workspace ${workspace.id}`,
+            `${reused ? "Reused" : "Opened"} workspace ${workspace.id}`,
             `Root: ${workspace.root}`,
             `Mode: ${workspace.mode}`,
+            reused
+              ? "Bootstrap details omitted because they were already returned in this ChatGPT conversation."
+              : undefined,
             loadedAgentsFiles.length > 0
               ? `Loaded project instructions: ${loadedAgentsFiles.map((file) => file.path).join(", ")}`
               : undefined,
@@ -878,6 +899,7 @@ function createMcpServer(
             path: workspace.root,
             summary: {
               mode: workspace.mode,
+              reused,
               agentsFiles: loadedAgentsFiles.length,
               availableAgentsFiles: availableAgentsFileOutputs.length,
               skills: visibleSkills.length,
@@ -891,14 +913,20 @@ function createMcpServer(
           workspaceId: workspace.id,
           root: workspace.root,
           mode: workspace.mode,
+          reused,
+          bootstrapIncluded,
           sourceRoot: workspace.sourceRoot,
           worktree: workspace.worktree,
-          agentsFiles: loadedAgentsFiles,
-          availableAgentsFiles: availableAgentsFileOutputs,
-          skills: visibleSkills,
-          agentProviders: visibleAgentProviders,
-          agents: visibleAgents,
-          skillDiagnostics: workspace.skillDiagnostics,
+          ...(bootstrapIncluded
+            ? {
+                agentsFiles: loadedAgentsFiles,
+                availableAgentsFiles: availableAgentsFileOutputs,
+                skills: visibleSkills,
+                agentProviders: visibleAgentProviders,
+                agents: visibleAgents,
+                skillDiagnostics: workspace.skillDiagnostics,
+              }
+            : {}),
           instruction,
         },
       };

src/ui/tool-display.test.ts

@@ -25,6 +25,10 @@ for (const [card, expected] of displayCases) {
 }
 
 assert.equal(getToolDisplay({ tool: "open_workspace", root: "/tmp/project" }).label, "/tmp/project");
+assert.equal(
+  getToolDisplay({ tool: "open_workspace", root: "/tmp/project", summary: { reused: true } }).title,
+  "Reused workspace",
+);
 assert.equal(
   getToolDisplay({ tool: "grep", summary: { pattern: "needle", scope: "src" } }).label,
   "needle in src",
@@ -95,6 +99,13 @@ assert.deepEqual(
   }),
   { kind: "text", text: "worktree · 1 instruction · 4 skills" },
 );
+assert.deepEqual(
+  getToolHeaderSummary({
+    tool: "open_workspace",
+    summary: { mode: "worktree", reused: true },
+  }),
+  { kind: "text", text: "worktree · reused" },
+);
 
 assert.deepEqual(
   getToolHeaderSummary({ tool: "exec_command", summary: { lines: 3, wallTimeMs: 1_500 } }),

src/ui/tool-display.ts

@@ -27,7 +27,7 @@ export function getToolDisplay(card: ToolResultCard): ToolDisplay {
     case "open_workspace":
       return {
         icon: toolIcons.folderOpen,
-        title: "Opened workspace",
+        title: card.summary?.reused === true ? "Reused workspace" : "Opened workspace",
         label: card.root ?? card.path,
         tone: "workspace",
       };
@@ -123,6 +123,7 @@ export function getToolHeaderSummary(card: ToolResultCard): ToolHeaderSummary {
   if (card.tool === "open_workspace") {
     const parts = [
       typeof summary.mode === "string" ? summary.mode : undefined,
+      summary.reused === true ? "reused" : undefined,
       countLabel(summaryNumber(summary, "agentsFiles"), "instruction"),
       countLabel(summaryNumber(summary, "skills"), "skill"),
     ].filter((part): part is string => Boolean(part));

src/workspaces.test.ts

@@ -59,6 +59,21 @@ try {
     agentsFiles.map((file) => file.content),
     ["global instructions\n", "root instructions\n"],
   );
+
+  const scopedCheckout = await registry.openWorkspace(root, { reuseScope: "chat-1" });
+  const reusedCheckout = await registry.openWorkspace(root, { reuseScope: "chat-1" });
+  assert.equal(scopedCheckout.reused, false);
+  assert.equal(reusedCheckout.reused, true);
+  assert.equal(reusedCheckout.workspace.id, scopedCheckout.workspace.id);
+  assert.deepEqual(reusedCheckout.agentsFiles, []);
+  assert.deepEqual(reusedCheckout.availableAgentsFiles, []);
+
+  const reopenedCheckout = await registry.openWorkspace(root, {
+    reuseScope: "chat-1",
+    forceNew: true,
+  });
+  assert.equal(reopenedCheckout.reused, false);
+  assert.notEqual(reopenedCheckout.workspace.id, scopedCheckout.workspace.id);
   assert.deepEqual(
     availableAgentsFiles.map((file) => file.path),
     [join(root, "nested", "AGENTS.md")],
@@ -141,7 +156,7 @@ try {
   const worktreeWorkspace = await registry.openWorkspace({
     path: gitRoot,
     mode: "worktree",
-  });
+  }, { reuseScope: "chat-worktree" });
   assert.equal(worktreeWorkspace.workspace.mode, "worktree");
   assert.notEqual(worktreeWorkspace.workspace.root, gitRoot);
   assert.match(worktreeWorkspace.workspace.root, /git-project-[a-f0-9]{8}$/);
@@ -153,6 +168,16 @@ try {
   assert.match(worktreeWorkspace.agentsFiles.map((file) => file.content).join("\n"), /global instructions/);
   assert.match(worktreeWorkspace.agentsFiles.map((file) => file.content).join("\n"), /git root instructions/);
 
+  const reusedWorktreeWorkspace = await registry.openWorkspace({
+    path: gitRoot,
+    mode: "worktree",
+  }, { reuseScope: "chat-worktree" });
+  assert.equal(reusedWorktreeWorkspace.reused, true);
+  assert.equal(reusedWorktreeWorkspace.workspace.id, worktreeWorkspace.workspace.id);
+  assert.equal(reusedWorktreeWorkspace.workspace.root, worktreeWorkspace.workspace.root);
+  assert.deepEqual(reusedWorktreeWorkspace.agentsFiles, []);
+  assert.deepEqual(reusedWorktreeWorkspace.availableAgentsFiles, []);
+
   const worktreeReadmePath = registry.resolvePath(worktreeWorkspace.workspace, "README.md");
   assert.equal(worktreeReadmePath.startsWith(worktreeWorkspace.workspace.root), true);