feat(workspace): reuse checkout opens and trim repeated bootstrap

docs/chatgpt-coding-workflow.md

@@ -17,6 +17,17 @@ 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. The workspace card still receives
+the complete hidden display payload, so first and repeated calls render the same
+workspace details without adding those fields to the model transcript again.
+
 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/review-checkpoints.test.ts

@@ -40,6 +40,16 @@ try {
   assert.equal(firstReview.files.some((file) => file.path === "new.txt"), true);
   assert.match(firstReview.patch, /world/);
 
+  const restartedManager = createReviewCheckpointManager();
+  await restartedManager.initializeWorkspace({ workspaceId: "ws_review", root });
+  const afterRestart = await restartedManager.reviewChanges({
+    workspaceId: "ws_review",
+    root,
+    markReviewed: false,
+  });
+  assert.equal(afterRestart.summary.files, 2);
+  assert.match(afterRestart.patch, /world/);
+
   const stillUnreviewed = await manager.reviewChanges({
     workspaceId: "ws_review",
     root,

src/review-checkpoints.ts

@@ -48,26 +48,32 @@ const REVIEW_REF_PREFIX = "refs/devspace/review";
 
 export function createReviewCheckpointManager(): ReviewCheckpointManager {
   const states = new Map<string, WorkspaceReviewState>();
+  const initializations = new Map<string, Promise<void>>();
 
   return {
     async initializeWorkspace({ workspaceId, root }) {
-      const refs = reviewRefs(workspaceId);
-      const state: WorkspaceReviewState = { root, ...refs };
-      states.set(workspaceId, state);
+      const existingState = states.get(workspaceId);
+      if (
+        existingState?.root === root &&
+        (existingState.gitRoot !== undefined || existingState.diagnostic !== undefined)
+      ) {
+        return;
+      }
+
+      const pending = initializations.get(workspaceId);
+      if (pending) {
+        await pending;
+        return;
+      }
 
+      const initialize = initializeWorkspaceState(states, workspaceId, root);
+      initializations.set(workspaceId, initialize);
       try {
-        const eligibility = await getGitEligibility(root);
-        if (!eligibility.ok || !eligibility.gitRoot) {
-          state.diagnostic = eligibility.message ?? "show_changes requires a Git workspace in this version.";
-          return;
+        await initialize;
+      } finally {
+        if (initializations.get(workspaceId) === initialize) {
+          initializations.delete(workspaceId);
         }
-
-        state.gitRoot = eligibility.gitRoot;
-        const commit = await createWorkingTreeSnapshot(eligibility.gitRoot);
-        await git(eligibility.gitRoot, ["update-ref", state.openRef, commit]);
-        await git(eligibility.gitRoot, ["update-ref", state.baselineRef, commit]);
-      } catch (error) {
-        state.diagnostic = error instanceof Error ? error.message : String(error);
       }
     },
 
@@ -111,6 +117,50 @@ export function createReviewCheckpointManager(): ReviewCheckpointManager {
   };
 }
 
+async function initializeWorkspaceState(
+  states: Map<string, WorkspaceReviewState>,
+  workspaceId: string,
+  root: string,
+): Promise<void> {
+  const refs = reviewRefs(workspaceId);
+  const state: WorkspaceReviewState = { root, ...refs };
+  states.set(workspaceId, state);
+
+  try {
+    const eligibility = await getGitEligibility(root);
+    if (!eligibility.ok || !eligibility.gitRoot) {
+      state.diagnostic = eligibility.message ?? "show_changes requires a Git workspace in this version.";
+      return;
+    }
+
+    state.gitRoot = eligibility.gitRoot;
+    const [hasOpenRef, hasBaselineRef] = await Promise.all([
+      hasCommitRef(eligibility.gitRoot, state.openRef),
+      hasCommitRef(eligibility.gitRoot, state.baselineRef),
+    ]);
+    if (hasOpenRef && hasBaselineRef) return;
+
+    const commit = await createWorkingTreeSnapshot(eligibility.gitRoot);
+    if (!hasOpenRef) {
+      await git(eligibility.gitRoot, ["update-ref", state.openRef, commit]);
+    }
+    if (!hasBaselineRef) {
+      await git(eligibility.gitRoot, ["update-ref", state.baselineRef, commit]);
+    }
+  } catch (error) {
+    state.diagnostic = error instanceof Error ? error.message : String(error);
+  }
+}
+
+async function hasCommitRef(gitRoot: string, ref: string): Promise<boolean> {
+  try {
+    await git(gitRoot, ["rev-parse", "--verify", `${ref}^{commit}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function reviewRefs(workspaceId: string): Pick<WorkspaceReviewState, "openRef" | "baselineRef"> {
   const segment = safeWorkspaceRefSegment(workspaceId);
   return {