feat(workspace): reuse opens within ChatGPT sessions

Author: Waishnav

docs/chatgpt-coding-workflow.md

@@ -17,6 +17,15 @@ 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. The conversation binding is persisted so reconnecting
+the MCP transport or restarting DevSpace does not create another managed worktree
+for the same ChatGPT conversation and target.
+
 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/db/migrations.ts

@@ -22,6 +22,11 @@ const migrations: Migration[] = [
     name: "local-agent-sessions",
     up: migrateLocalAgentSessions,
   },
+  {
+    version: 4,
+    name: "workspace-conversation-bindings",
+    up: migrateWorkspaceConversationBindings,
+  },
 ];
 
 export function migrateDatabase(sqlite: Database.Database): void {
@@ -174,6 +179,25 @@ function migrateLocalAgentSessions(sqlite: Database.Database): void {
   addColumnIfMissing(sqlite, "local_agent_sessions", "thinking", "text");
 }
 
+function migrateWorkspaceConversationBindings(sqlite: Database.Database): void {
+  sqlite.exec(`
+    create table if not exists workspace_conversation_bindings (
+      conversation_scope_hash text not null,
+      target_key text not null,
+      workspace_session_id text not null,
+      created_at text not null,
+      last_used_at text not null,
+      primary key (conversation_scope_hash, target_key),
+      foreign key (workspace_session_id)
+        references workspace_sessions(id)
+        on delete cascade
+    );
+
+    create index if not exists workspace_conversation_bindings_workspace_idx
+      on workspace_conversation_bindings(workspace_session_id);
+  `);
+}
+
 function addColumnIfMissing(
   sqlite: Database.Database,
   table: "workspace_sessions" | "local_agent_sessions",

src/db/schema.ts

@@ -38,6 +38,23 @@ export const loadedAgentFiles = sqliteTable(
   ],
 );
 
+export const workspaceConversationBindings = sqliteTable(
+  "workspace_conversation_bindings",
+  {
+    conversationScopeHash: text("conversation_scope_hash").notNull(),
+    targetKey: text("target_key").notNull(),
+    workspaceSessionId: text("workspace_session_id")
+      .notNull()
+      .references(() => workspaceSessions.id, { onDelete: "cascade" }),
+    createdAt: text("created_at").notNull(),
+    lastUsedAt: text("last_used_at").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.conversationScopeHash, table.targetKey] }),
+    index("workspace_conversation_bindings_workspace_idx").on(table.workspaceSessionId),
+  ],
+);
+
 export const oauthClients = sqliteTable(
   "oauth_clients",
   {
@@ -101,5 +118,7 @@ export type WorkspaceSessionRow = typeof workspaceSessions.$inferSelect;
 export type NewWorkspaceSessionRow = typeof workspaceSessions.$inferInsert;
 export type LoadedAgentFileRow = typeof loadedAgentFiles.$inferSelect;
 export type NewLoadedAgentFileRow = typeof loadedAgentFiles.$inferInsert;
+export type WorkspaceConversationBindingRow = typeof workspaceConversationBindings.$inferSelect;
+export type NewWorkspaceConversationBindingRow = typeof workspaceConversationBindings.$inferInsert;
 export type LocalAgentSessionRow = typeof localAgentSessions.$inferSelect;
 export type NewLocalAgentSessionRow = typeof localAgentSessions.$inferInsert;

src/oauth-store.test.ts

@@ -44,6 +44,7 @@ async function testDatabaseConfiguration(stateDir: string): Promise<void> {
       { version: 1, name: "workspace-state" },
       { version: 2, name: "oauth-state" },
       { version: 3, name: "local-agent-sessions" },
+      { version: 4, name: "workspace-conversation-bindings" },
     ]);
   } finally {
     database.close();

src/request-meta.test.ts

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { openAiConversationScopeHash } from "./request-meta.js";
+
+assert.equal(openAiConversationScopeHash(undefined), undefined);
+assert.equal(openAiConversationScopeHash({}), undefined);
+assert.equal(openAiConversationScopeHash({ "openai/session": "" }), undefined);
+
+const sessionOnly = openAiConversationScopeHash({ "openai/session": "chat-1" });
+assert.match(sessionOnly ?? "", /^[a-f0-9]{64}$/);
+assert.equal(
+  sessionOnly,
+  openAiConversationScopeHash({ "openai/session": "chat-1" }),
+);
+assert.notEqual(
+  sessionOnly,
+  openAiConversationScopeHash({ "openai/session": "chat-2" }),
+);
+
+assert.equal(
+  sessionOnly,
+  openAiConversationScopeHash({
+    "openai/session": "chat-1",
+    "openai/subject": "user-1",
+    "openai/organization": "org-1",
+  }),
+);

src/request-meta.ts

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+
+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 openAiConversationScopeHash(
+  meta: Record<string, unknown> | undefined,
+): string | undefined {
+  const session = metadataString(meta, "openai/session");
+  if (!session) return undefined;
+
+  return createHash("sha256")
+    .update(JSON.stringify(["openai", session]))
+    .digest("hex");
+}

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 { openAiConversationScopeHash } 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 return the existing workspaceId and omit bootstrap details already returned. 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()
@@ -784,60 +785,74 @@ 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 }, { _meta }) => {
       const startedAt = performance.now();
-      const { workspace, agentsFiles, availableAgentsFiles } = await workspaces.openWorkspace({ path, mode, baseRef });
-      if (config.widgets === "changes") {
+      const {
+        workspace,
+        agentsFiles,
+        availableAgentsFiles,
+        includeBootstrapContext,
+      } = await workspaces.openWorkspace(
+        { path, mode, baseRef },
+        { conversationScopeHash: openAiConversationScopeHash(_meta) },
+      );
+      const reused = !includeBootstrapContext;
+      if (config.widgets === "changes" && includeBootstrapContext) {
         void reviewCheckpoints.initializeWorkspace({
           workspaceId: workspace.id,
           root: workspace.root,
         });
       }
-      const visibleSkills = workspace.skills
+      const visibleSkills = includeBootstrapContext ? 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 = includeBootstrapContext && config.subagents ? localAgentProviders : [];
+      const visibleAgents = includeBootstrapContext ? 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 = includeBootstrapContext ? agentsFiles.map((file) => ({
         path: formatAgentsPath(file.path, workspace.root),
         content: file.content,
-      }));
-      const availableAgentsFileOutputs = availableAgentsFiles.map((file) => ({
+      })) : [];
+      const availableAgentsFileOutputs = includeBootstrapContext ? 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 ? "Workspace already open as" : "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 +893,7 @@ function createMcpServer(
             path: workspace.root,
             summary: {
               mode: workspace.mode,
+              reused,
               agentsFiles: loadedAgentsFiles.length,
               availableAgentsFiles: availableAgentsFileOutputs.length,
               skills: visibleSkills.length,
@@ -893,12 +909,16 @@ function createMcpServer(
           mode: workspace.mode,
           sourceRoot: workspace.sourceRoot,
           worktree: workspace.worktree,
-          agentsFiles: loadedAgentsFiles,
-          availableAgentsFiles: availableAgentsFileOutputs,
-          skills: visibleSkills,
-          agentProviders: visibleAgentProviders,
-          agents: visibleAgents,
-          skillDiagnostics: workspace.skillDiagnostics,
+          ...(includeBootstrapContext
+            ? {
+                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));