@spencer-kit/coder-studio 0.4.7 → 0.4.8

package/dist/esm/server-runner.mjs

@@ -625,7 +625,15 @@ var init_definition = __esm({
       id: "claude",
       displayName: "Claude Code",
       badge: "Claude",
+      kind: "built_in",
       capability: "full",
+      capabilities: [
+        { key: "interactive_session", supported: true, label: "Interactive session" },
+        { key: "supervisor_eval", supported: true, label: "Supervisor evaluation" },
+        { key: "idle_detection", supported: true, label: "Idle detection" },
+        { key: "context_attach", supported: false, label: "Context attach" },
+        { key: "review", supported: false, label: "Review" }
+      ],
       install: claudeInstallMetadata,
       // ===== Command construction =====
       buildCommand(config, ctx) {
@@ -795,7 +803,15 @@ var init_definition2 = __esm({
       id: "codex",
       displayName: "Codex",
       badge: "Codex",
+      kind: "built_in",
       capability: "full",
+      capabilities: [
+        { key: "interactive_session", supported: true, label: "Interactive session" },
+        { key: "supervisor_eval", supported: true, label: "Supervisor evaluation" },
+        { key: "idle_detection", supported: true, label: "Idle detection" },
+        { key: "context_attach", supported: false, label: "Context attach" },
+        { key: "review", supported: false, label: "Review" }
+      ],
       install: codexInstallMetadata,
       // ===== Command construction =====
       buildCommand(config, ctx) {
@@ -828,7 +844,78 @@ var init_definition2 = __esm({
   }
 });
 
+// packages/providers/src/presets.ts
+function cloneCapabilities(capabilities) {
+  return capabilities.map((capability) => ({ ...capability }));
+}
+var defaultCapabilities, providerPresets;
+var init_presets = __esm({
+  "packages/providers/src/presets.ts"() {
+    "use strict";
+    defaultCapabilities = [
+      { key: "interactive_session", supported: true, label: "Interactive session" },
+      { key: "context_attach", supported: true, label: "Context attach" },
+      { key: "review", supported: true, label: "Review" }
+    ];
+    providerPresets = [
+      {
+        id: "gemini-cli",
+        displayName: "Gemini CLI",
+        kind: "preset",
+        description: "Preset metadata for launching Google's Gemini CLI through the custom provider flow.",
+        command: "gemini",
+        args: [],
+        env: {},
+        cwdMode: "workspace_root",
+        sessionMode: "interactive",
+        startupPrompt: "Follow the workspace instructions and explain important tradeoffs.",
+        capabilities: cloneCapabilities(defaultCapabilities),
+        requiredCommands: ["gemini"]
+      },
+      {
+        id: "aider",
+        displayName: "Aider",
+        kind: "preset",
+        description: "Preset metadata for launching Aider as a workspace-root interactive coding agent.",
+        command: "aider",
+        args: [],
+        env: {},
+        cwdMode: "workspace_root",
+        sessionMode: "interactive",
+        startupPrompt: "Review the current workspace state before making edits.",
+        capabilities: cloneCapabilities(defaultCapabilities),
+        requiredCommands: ["aider"]
+      },
+      {
+        id: "opencode",
+        displayName: "OpenCode",
+        kind: "preset",
+        description: "Preset metadata for launching OpenCode from the workspace root.",
+        command: "opencode",
+        args: [],
+        env: {},
+        cwdMode: "workspace_root",
+        sessionMode: "interactive",
+        startupPrompt: "Use the repository instructions and verify changes before finishing.",
+        capabilities: cloneCapabilities(defaultCapabilities),
+        requiredCommands: ["opencode"]
+      }
+    ];
+  }
+});
+
 // packages/providers/src/registry.ts
+function toProviderListItem(provider) {
+  return {
+    id: provider.id,
+    displayName: provider.displayName,
+    badge: provider.badge,
+    kind: provider.kind,
+    capability: provider.capability,
+    capabilities: provider.capabilities.map((capability) => ({ ...capability })),
+    requiredCommands: [...provider.requiredCommands]
+  };
+}
 var providerRegistry;
 var init_registry = __esm({
   "packages/providers/src/registry.ts"() {
@@ -848,6 +935,7 @@ var init_src = __esm({
     init_config_schema2();
     init_definition2();
     init_stdout_heuristics();
+    init_presets();
     init_registry();
   }
 });
@@ -1690,7 +1778,7 @@ import { mkdir as mkdir3, mkdtemp, rm as rm3, writeFile as writeFile2 } from "fs
 import os2 from "os";
 import path7 from "path";
 async function runGit(cwd, args, options = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const gitArgs = [
       ...options.config?.flatMap(([key, value]) => ["-c", `${key}=${value}`]) ?? [],
       ...args
@@ -1717,7 +1805,7 @@ async function runGit(cwd, args, options = {}) {
         if (err) {
           reject(new GitError(err.message, stderr));
         } else {
-          resolve6({ stdout, stderr });
+          resolve8({ stdout, stderr });
         }
       }
     );
@@ -3598,12 +3686,12 @@ var init_auto_fetch = __esm({
       }
       acquireWorkspaceOperation(workspaceId) {
         const state = this.getOrCreateState(workspaceId);
-        return new Promise((resolve6) => {
+        return new Promise((resolve8) => {
           const grant = () => {
             state.inFlight = true;
             state.nextFetchAt = void 0;
             let released = false;
-            resolve6(() => {
+            resolve8(() => {
               if (released) {
                 return;
               }
@@ -4606,7 +4694,7 @@ var init_manager = __esm({
 // packages/server/src/provider-runtime/command-runner.ts
 import { spawn as spawn2 } from "node:child_process";
 async function runCommandAsString(file, args, options) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn2(file, args, {
       cwd: options?.cwd,
       env: options?.env,
@@ -4633,7 +4721,7 @@ async function runCommandAsString(file, args, options) {
       const stdout = Buffer.concat(stdoutChunks).toString("utf8");
       const stderr = Buffer.concat(stderrChunks).toString("utf8");
       if (code === 0) {
-        resolve6({ stdout, stderr });
+        resolve8({ stdout, stderr });
         return;
       }
       reject(
@@ -5433,6 +5521,66 @@ var init_tool_root = __esm({
   }
 });
 
+// packages/server/src/provider-runtime/custom-provider.ts
+import { z as z4 } from "zod";
+function deriveProviderCapability(capabilities) {
+  const interactive = capabilities.find((capability) => capability.key === "interactive_session");
+  if (!interactive?.supported) {
+    return "unsupported";
+  }
+  const allSupported = capabilities.length > 0 && capabilities.every((capability) => capability.supported);
+  return allSupported ? "full" : "limited";
+}
+function buildCustomProviderDefinition(config) {
+  const command = config.command.trim();
+  const requiredCommand = command.split(/\s+/)[0] ?? command;
+  return {
+    id: config.id,
+    displayName: config.displayName,
+    badge: "Custom",
+    kind: "custom",
+    capability: deriveProviderCapability(config.capabilities),
+    capabilities: config.capabilities.map((capability) => ({ ...capability })),
+    install: {
+      prerequisites: [],
+      manualGuideKeys: [],
+      docUrls: {
+        provider: "",
+        prerequisites: {}
+      },
+      strategies: {}
+    },
+    buildCommand(_providerConfig, ctx) {
+      return {
+        argv: [command, ...config.args],
+        env: {
+          ...config.env,
+          CODER_STUDIO_SESSION_ID: ctx.sessionId
+        },
+        cwd: ctx.workspacePath
+      };
+    },
+    configSchema: CUSTOM_PROVIDER_CONFIG_SCHEMA,
+    defaultConfig: {},
+    requiredCommands: requiredCommand ? [requiredCommand] : []
+  };
+}
+function upsertProviderDefinition(registry, provider) {
+  const next = registry.filter((item) => item.id !== provider.id);
+  next.push(provider);
+  return next;
+}
+function removeProviderDefinition(registry, providerId) {
+  return registry.filter((item) => item.id !== providerId);
+}
+var CUSTOM_PROVIDER_CONFIG_SCHEMA;
+var init_custom_provider = __esm({
+  "packages/server/src/provider-runtime/custom-provider.ts"() {
+    "use strict";
+    CUSTOM_PROVIDER_CONFIG_SCHEMA = z4.object({}).passthrough();
+  }
+});
+
 // packages/server/src/provider-runtime/e2e-provider-mock.ts
 import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname5, join as join8 } from "node:path";
@@ -5675,9 +5823,24 @@ var init_install_manager2 = __esm({
       deps;
       constructor(providers, deps = {}) {
         this.deps = deps;
+        this.setProviders(providers);
+      }
+      setProviders(providers) {
+        const nextIds = new Set(providers.map((provider) => provider.id));
+        this.providers.clear();
         for (const provider of providers) {
           this.providers.set(provider.id, provider);
         }
+        for (const providerId of this.activeJobIdsByProviderId.keys()) {
+          if (!nextIds.has(providerId)) {
+            this.activeJobIdsByProviderId.delete(providerId);
+          }
+        }
+        for (const providerId of this.inFlightStartsByProviderId.keys()) {
+          if (!nextIds.has(providerId)) {
+            this.inFlightStartsByProviderId.delete(providerId);
+          }
+        }
       }
       async start(providerId) {
         const activeJob = this.getActiveJob(providerId);
@@ -6147,7 +6310,7 @@ var init_update = __esm({
 });
 
 // packages/core/src/protocol/messages.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var TERMINAL_BINARY_PROTOCOL_VERSION, TERMINAL_BINARY_HEADER_SIZE, TerminalBinaryFrameType, RECOVERY_REASONS, TERMINAL_INPUT_ACTIVITIES, encodeTerminalBinaryFrame, TERMINAL_BINARY_OUTPUT_VERSION, encodeTerminalOutputFrame, CommandMessage, ResultMessage, EventMessage, SubscribeMessage, UnsubscribeMessage, ResyncMessage, ClientMessage, ServerMessage;
 var init_messages = __esm({
   "packages/core/src/protocol/messages.ts"() {
@@ -6210,49 +6373,49 @@ var init_messages = __esm({
       frame.set(payload, TERMINAL_BINARY_HEADER_SIZE + topicBytes.length);
       return frame;
     };
-    CommandMessage = z4.object({
-      kind: z4.literal("command"),
-      id: z4.string().uuid(),
-      op: z4.string(),
-      args: z4.unknown()
+    CommandMessage = z5.object({
+      kind: z5.literal("command"),
+      id: z5.string().uuid(),
+      op: z5.string(),
+      args: z5.unknown()
     });
-    ResultMessage = z4.object({
-      kind: z4.literal("result"),
-      id: z4.string().uuid(),
-      ok: z4.boolean(),
-      data: z4.unknown().optional(),
-      error: z4.object({
-        code: z4.string(),
-        message: z4.string(),
-        details: z4.unknown().optional()
+    ResultMessage = z5.object({
+      kind: z5.literal("result"),
+      id: z5.string().uuid(),
+      ok: z5.boolean(),
+      data: z5.unknown().optional(),
+      error: z5.object({
+        code: z5.string(),
+        message: z5.string(),
+        details: z5.unknown().optional()
       }).optional()
     });
-    EventMessage = z4.object({
-      kind: z4.literal("event"),
-      topic: z4.string(),
-      seq: z4.number().int().nonnegative(),
-      timestamp: z4.number().int().positive(),
-      data: z4.unknown()
+    EventMessage = z5.object({
+      kind: z5.literal("event"),
+      topic: z5.string(),
+      seq: z5.number().int().nonnegative(),
+      timestamp: z5.number().int().positive(),
+      data: z5.unknown()
     });
-    SubscribeMessage = z4.object({
-      kind: z4.literal("subscribe"),
-      topics: z4.array(z4.string())
+    SubscribeMessage = z5.object({
+      kind: z5.literal("subscribe"),
+      topics: z5.array(z5.string())
     });
-    UnsubscribeMessage = z4.object({
-      kind: z4.literal("unsubscribe"),
-      topics: z4.array(z4.string())
+    UnsubscribeMessage = z5.object({
+      kind: z5.literal("unsubscribe"),
+      topics: z5.array(z5.string())
     });
-    ResyncMessage = z4.object({
-      kind: z4.literal("resync"),
-      lastSeen: z4.record(z4.string(), z4.number())
+    ResyncMessage = z5.object({
+      kind: z5.literal("resync"),
+      lastSeen: z5.record(z5.string(), z5.number())
     });
-    ClientMessage = z4.discriminatedUnion("kind", [
+    ClientMessage = z5.discriminatedUnion("kind", [
       CommandMessage,
       SubscribeMessage,
       UnsubscribeMessage,
       ResyncMessage
     ]);
-    ServerMessage = z4.discriminatedUnion("kind", [ResultMessage, EventMessage]);
+    ServerMessage = z5.discriminatedUnion("kind", [ResultMessage, EventMessage]);
   }
 });
 
@@ -6325,7 +6488,7 @@ var init_src3 = __esm({
 });
 
 // packages/server/src/provider-config.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function isSupportedProviderId(providerId) {
   return supportedProviderIds.has(providerId);
 }
@@ -6345,17 +6508,17 @@ var init_provider_config = __esm({
     "use strict";
     SUPPORTED_PROVIDER_IDS = ["claude", "codex"];
     supportedProviderIds = new Set(SUPPORTED_PROVIDER_IDS);
-    ProviderLaunchConfigInputSchema = z5.object({
-      additionalArgs: z5.array(z5.string()).optional(),
-      envVars: z5.record(z5.string(), z5.string()).optional()
+    ProviderLaunchConfigInputSchema = z6.object({
+      additionalArgs: z6.array(z6.string()).optional(),
+      envVars: z6.record(z6.string(), z6.string()).optional()
     }).strict();
-    ProviderSettingsSchema = z5.object({
+    ProviderSettingsSchema = z6.object({
       claude: ProviderLaunchConfigInputSchema.optional(),
       codex: ProviderLaunchConfigInputSchema.optional()
     }).strict();
-    ProviderLaunchConfigSchema = z5.object({
-      additionalArgs: z5.array(z5.string()).default([]),
-      envVars: z5.record(z5.string(), z5.string()).optional()
+    ProviderLaunchConfigSchema = z6.object({
+      additionalArgs: z6.array(z6.string()).default([]),
+      envVars: z6.record(z6.string(), z6.string()).optional()
     });
   }
 });
@@ -6851,6 +7014,9 @@ var init_manager3 = __esm({
       comparators = /* @__PURE__ */ new Map();
       detectorUnsubscribes = /* @__PURE__ */ new Map();
       logger;
+      setProviderRegistry(providerRegistry2) {
+        this.deps.providerRegistry = providerRegistry2;
+      }
       /**
        * Create a new session with provider
        */
@@ -7815,15 +7981,104 @@ var init_auth_session_repo = __esm({
   }
 });
 
-// packages/server/src/storage/repositories/provider-config-repo.ts
+// packages/server/src/storage/repositories/custom-provider-repo.ts
 function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeProviderConfigFile(value) {
+function normalizeConfig(config) {
+  return {
+    ...config,
+    args: [...config.args],
+    env: { ...config.env },
+    capabilities: config.capabilities.map((capability) => ({ ...capability }))
+  };
+}
+function normalizeFileConfigs(value) {
   if (isRecord5(value) && value.version === 1 && isRecord5(value.providers)) {
-    return value.providers;
+    return Object.fromEntries(
+      Object.entries(value.providers).map(([id, config]) => [
+        id,
+        normalizeConfig(config)
+      ])
+    );
   }
   if (isRecord5(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([id, config]) => [
+        id,
+        normalizeConfig(config)
+      ])
+    );
+  }
+  return {};
+}
+var CustomProviderRepo;
+var init_custom_provider_repo = __esm({
+  "packages/server/src/storage/repositories/custom-provider-repo.ts"() {
+    "use strict";
+    init_json_file_store();
+    CustomProviderRepo = class {
+      filePath;
+      constructor(input) {
+        this.filePath = input.filePath;
+      }
+      list() {
+        return Object.values(this.loadFileConfigs()).sort(
+          (left, right) => right.updatedAt - left.updatedAt || left.id.localeCompare(right.id)
+        );
+      }
+      get(id) {
+        return this.loadFileConfigs()[id];
+      }
+      set(config) {
+        const existing = this.get(config.id);
+        const createdAt = existing?.createdAt ?? config.createdAt;
+        const normalized = normalizeConfig({
+          ...config,
+          createdAt
+        });
+        const next = this.loadFileConfigs();
+        next[normalized.id] = normalized;
+        this.saveFileConfigs(next);
+        return next[normalized.id];
+      }
+      delete(id) {
+        const next = this.loadFileConfigs();
+        if (!Object.prototype.hasOwnProperty.call(next, id)) {
+          return;
+        }
+        delete next[id];
+        this.saveFileConfigs(next);
+      }
+      loadFileConfigs() {
+        const parsed = readJsonFile(
+          this.filePath
+        );
+        if (parsed !== void 0) {
+          return normalizeFileConfigs(parsed);
+        }
+        return {};
+      }
+      saveFileConfigs(configs) {
+        const payload = {
+          version: 1,
+          providers: configs
+        };
+        writeJsonFileAtomic(this.filePath, payload);
+      }
+    };
+  }
+});
+
+// packages/server/src/storage/repositories/provider-config-repo.ts
+function isRecord6(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeProviderConfigFile(value) {
+  if (isRecord6(value) && value.version === 1 && isRecord6(value.providers)) {
+    return value.providers;
+  }
+  if (isRecord6(value)) {
     return value;
   }
   return {};
@@ -7896,15 +8151,159 @@ var init_provider_config_repo = __esm({
   }
 });
 
+// packages/server/src/workspace/workspace-state.ts
+import { join as join9 } from "node:path";
+function resolveWorkspaceStateFilePath(workspacePath, fileName) {
+  return join9(workspacePath, WORKSPACE_STATE_DIR, fileName);
+}
+var WORKSPACE_STATE_DIR, AGENT_INSTRUCTIONS_RELATIVE_PATH, SESSION_METADATA_FILE_NAME, SESSION_METADATA_RELATIVE_PATH;
+var init_workspace_state = __esm({
+  "packages/server/src/workspace/workspace-state.ts"() {
+    "use strict";
+    WORKSPACE_STATE_DIR = ".coder-studio";
+    AGENT_INSTRUCTIONS_RELATIVE_PATH = `${WORKSPACE_STATE_DIR}/AGENTS.md`;
+    SESSION_METADATA_FILE_NAME = "session-metadata.json";
+    SESSION_METADATA_RELATIVE_PATH = `${WORKSPACE_STATE_DIR}/${SESSION_METADATA_FILE_NAME}`;
+  }
+});
+
+// packages/server/src/storage/repositories/session-metadata-repo.ts
+function isRecord7(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeRun(run) {
+  return {
+    ...run
+  };
+}
+function normalizeMetadata(metadata) {
+  return {
+    sessionId: metadata.sessionId,
+    workspaceId: metadata.workspaceId,
+    providerId: metadata.providerId,
+    objective: metadata.objective ?? void 0,
+    baselineGitHead: metadata.baselineGitHead ?? void 0,
+    baselineCapturedAt: metadata.baselineCapturedAt ?? void 0,
+    verificationRuns: metadata.verificationRuns.map(normalizeRun)
+  };
+}
+function normalizeFileMetadata(value) {
+  if (isRecord7(value) && value.version === 1 && isRecord7(value.metadata)) {
+    return Object.fromEntries(
+      Object.entries(value.metadata).map(([sessionId, metadata]) => [
+        sessionId,
+        normalizeMetadata(metadata)
+      ])
+    );
+  }
+  if (isRecord7(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([sessionId, metadata]) => [
+        sessionId,
+        normalizeMetadata(metadata)
+      ])
+    );
+  }
+  return {};
+}
+var SessionMetadataRepo;
+var init_session_metadata_repo = __esm({
+  "packages/server/src/storage/repositories/session-metadata-repo.ts"() {
+    "use strict";
+    init_workspace_state();
+    init_json_file_store();
+    SessionMetadataRepo = class {
+      workspaceRepo;
+      constructor(input) {
+        this.workspaceRepo = input.workspaceRepo;
+      }
+      upsert(metadata) {
+        const normalized = normalizeMetadata(metadata);
+        const workspace = this.workspaceRepo.findById(normalized.workspaceId);
+        if (!workspace) {
+          throw new Error(`Workspace not found for session metadata: ${normalized.workspaceId}`);
+        }
+        const existing = this.findSessionLocation(normalized.sessionId);
+        if (existing && existing.workspace.id !== workspace.id) {
+          delete existing.fileMetadata[normalized.sessionId];
+          this.saveWorkspaceFileMetadata(existing.workspace.path, existing.fileMetadata);
+        }
+        const next = existing && existing.workspace.id === workspace.id ? existing.fileMetadata : this.loadWorkspaceFileMetadata(workspace.path);
+        next[normalized.sessionId] = normalized;
+        this.saveWorkspaceFileMetadata(workspace.path, next);
+        return next[normalized.sessionId];
+      }
+      get(sessionId) {
+        return this.findSessionLocation(sessionId)?.fileMetadata[sessionId];
+      }
+      addVerificationRun(sessionId, run) {
+        const existing = this.findSessionLocation(sessionId);
+        if (!existing) {
+          throw new Error(`Session metadata not found: ${sessionId}`);
+        }
+        existing.fileMetadata[sessionId] = normalizeMetadata({
+          ...existing.fileMetadata[sessionId],
+          verificationRuns: [...existing.fileMetadata[sessionId].verificationRuns, normalizeRun(run)]
+        });
+        this.saveWorkspaceFileMetadata(existing.workspace.path, existing.fileMetadata);
+        return existing.fileMetadata[sessionId];
+      }
+      delete(sessionId) {
+        this.deleteFromAnyWorkspace(sessionId);
+      }
+      findSessionLocation(sessionId) {
+        for (const workspace of this.workspaceRepo.list()) {
+          const fileMetadata = this.loadWorkspaceFileMetadata(workspace.path);
+          if (Object.prototype.hasOwnProperty.call(fileMetadata, sessionId)) {
+            return {
+              workspace,
+              fileMetadata
+            };
+          }
+        }
+        return void 0;
+      }
+      deleteFromAnyWorkspace(sessionId) {
+        const existing = this.findSessionLocation(sessionId);
+        if (!existing) {
+          return false;
+        }
+        delete existing.fileMetadata[sessionId];
+        this.saveWorkspaceFileMetadata(existing.workspace.path, existing.fileMetadata);
+        return true;
+      }
+      loadWorkspaceFileMetadata(workspacePath) {
+        const parsed = readJsonFile(
+          resolveWorkspaceStateFilePath(workspacePath, SESSION_METADATA_FILE_NAME)
+        );
+        if (parsed !== void 0) {
+          return normalizeFileMetadata(parsed);
+        }
+        return {};
+      }
+      saveWorkspaceFileMetadata(workspacePath, metadata) {
+        const payload = {
+          version: 1,
+          metadata
+        };
+        writeJsonFileAtomic(
+          resolveWorkspaceStateFilePath(workspacePath, SESSION_METADATA_FILE_NAME),
+          payload
+        );
+      }
+    };
+  }
+});
+
 // packages/server/src/storage/repositories/settings-repo.ts
-function isRecord6(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeSettingsFile(value) {
-  if (isRecord6(value) && value.version === 1 && isRecord6(value.settings)) {
+  if (isRecord8(value) && value.version === 1 && isRecord8(value.settings)) {
     return { ...value.settings };
   }
-  if (isRecord6(value)) {
+  if (isRecord8(value)) {
     return { ...value };
   }
   return {};
@@ -8055,11 +8454,11 @@ var init_supervisor_repo = __esm({
 });
 
 // packages/server/src/storage/repositories/terminal-repo.ts
-function isRecord7(value) {
+function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isTerminal(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord9(value)) {
     return false;
   }
   return typeof value.id === "string" && typeof value.workspaceId === "string" && (value.kind === "agent" || value.kind === "shell") && typeof value.cwd === "string" && Array.isArray(value.argv) && typeof value.cols === "number" && typeof value.rows === "number" && typeof value.alive === "boolean" && typeof value.createdAt === "number";
@@ -8071,7 +8470,7 @@ function normalizeTerminal(value) {
   };
 }
 function normalizeTerminalFile(value) {
-  if (isRecord7(value) && value.version === 1 && isRecord7(value.terminals)) {
+  if (isRecord9(value) && value.version === 1 && isRecord9(value.terminals)) {
     const normalized = {};
     for (const entry of Object.values(value.terminals)) {
       if (isTerminal(entry)) {
@@ -8089,7 +8488,7 @@ function normalizeTerminalFile(value) {
     }
     return normalized;
   }
-  if (isRecord7(value)) {
+  if (isRecord9(value)) {
     const normalized = {};
     for (const [terminalId, entry] of Object.entries(value)) {
       if (isTerminal(entry)) {
@@ -8255,12 +8654,12 @@ var init_terminal_repo = __esm({
 });
 
 // packages/server/src/storage/repositories/update-state-repo.ts
-function isRecord8(value) {
+function isRecord10(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeUpdateState(value, currentVersion) {
   const defaults = createDefaultUpdateState(currentVersion);
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     return defaults;
   }
   return {
@@ -8323,17 +8722,17 @@ var init_update_state_repo = __esm({
 });
 
 // packages/server/src/storage/repositories/workspace-repo.ts
-function isRecord9(value) {
+function isRecord11(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isWorkspace(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     return false;
   }
-  return typeof value.id === "string" && typeof value.path === "string" && (value.targetRuntime === "native" || value.targetRuntime === "wsl") && typeof value.openedAt === "number" && typeof value.lastActiveAt === "number" && isRecord9(value.uiState);
+  return typeof value.id === "string" && typeof value.path === "string" && (value.targetRuntime === "native" || value.targetRuntime === "wsl") && typeof value.openedAt === "number" && typeof value.lastActiveAt === "number" && isRecord11(value.uiState);
 }
 function normalizeWorkspaceFile(value) {
-  if (isRecord9(value) && value.version === 1 && isRecord9(value.workspaces)) {
+  if (isRecord11(value) && value.version === 1 && isRecord11(value.workspaces)) {
     const normalized = {};
     for (const entry of Object.values(value.workspaces)) {
       if (isWorkspace(entry)) {
@@ -8351,7 +8750,7 @@ function normalizeWorkspaceFile(value) {
     }
     return normalized;
   }
-  if (isRecord9(value)) {
+  if (isRecord11(value)) {
     const normalized = {};
     for (const [workspaceId, entry] of Object.entries(value)) {
       if (isWorkspace(entry)) {
@@ -8596,13 +8995,13 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
     return;
   }
   const arch = deps.arch ?? process.arch;
-  const resolve6 = deps.resolve ?? ((id) => require4.resolve(id));
+  const resolve8 = deps.resolve ?? ((id) => require4.resolve(id));
   const fileExists = deps.existsSync ?? existsSync6;
-  const stat11 = deps.statSync ?? statSync;
+  const stat12 = deps.statSync ?? statSync;
   const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
-    packageJsonPath = resolve6(NODE_PTY_PKG);
+    packageJsonPath = resolve8(NODE_PTY_PKG);
   } catch {
     return;
   }
@@ -8616,7 +9015,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
     if (!fileExists(helperPath)) {
       return;
     }
-    const currentMode = stat11(helperPath).mode;
+    const currentMode = stat12(helperPath).mode;
     const executableMode = currentMode | 73;
     if (executableMode === currentMode) {
       return;
@@ -8667,7 +9066,7 @@ async function escalateKillWithPolling(pid, signal, options) {
   const startTime = Date.now();
   const deadline = startTime + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
+    await new Promise((resolve8) => setTimeout(resolve8, pollIntervalMs));
     if (!isProcessAlive(pid)) {
       return true;
     }
@@ -9031,7 +9430,7 @@ async function runCommand(command, timeoutMs, options = {}) {
   if (options.signal?.aborted) {
     throw createSupervisorEvalAbortedError();
   }
-  return await new Promise((resolve6, reject) => {
+  return await new Promise((resolve8, reject) => {
     const child = spawn3(command.argv[0], command.argv.slice(1), {
       cwd: command.cwd,
       detached: process.platform !== "win32",
@@ -9061,7 +9460,7 @@ async function runCommand(command, timeoutMs, options = {}) {
       }
       settled = true;
       cleanup();
-      resolve6(value);
+      resolve8(value);
     };
     const terminate = (error) => {
       if (terminationError) {
@@ -9889,12 +10288,12 @@ var init_scheduler = __esm({
 
 // packages/server/src/supervisor/manager.ts
 function createDeferredCompletion() {
-  let resolve6 = () => {
+  let resolve8 = () => {
   };
   const promise = new Promise((innerResolve) => {
-    resolve6 = innerResolve;
+    resolve8 = innerResolve;
   });
-  return { promise, resolve: resolve6 };
+  return { promise, resolve: resolve8 };
 }
 function generateSupervisorId() {
   return `sup_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
@@ -10015,6 +10414,9 @@ var init_manager4 = __esm({
       logger;
       config;
       lifecycleUnsubscribe = null;
+      setProviderRegistry(providerRegistry2) {
+        this.deps.providerRegistry = providerRegistry2;
+      }
       start() {
         this.lifecycleUnsubscribe?.();
         this.lifecycleUnsubscribe = this.deps.eventBus.on(
@@ -11249,10 +11651,10 @@ var init_manager4 = __esm({
         if (signal?.aborted) {
           throw { code: "supervisor_eval_aborted", message: "Supervisor evaluator aborted" };
         }
-        await new Promise((resolve6, reject) => {
+        await new Promise((resolve8, reject) => {
           const timer = setTimeout(() => {
             signal?.removeEventListener("abort", onAbort);
-            resolve6();
+            resolve8();
           }, delayMs);
           timer.unref?.();
           const onAbort = () => {
@@ -11284,30 +11686,30 @@ __export(target_store_exports, {
   saveTargetMeta: () => saveTargetMeta
 });
 import { mkdir as mkdir4, mkdtemp as mkdtemp2, readdir as readdir2, readFile as readFile3, rename, rm as rm6, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname6, join as join10 } from "node:path";
 function targetDir(workspacePath, targetId) {
-  return join9(workspacePath, ".coder-studio", "supervisor", "targets", targetId);
+  return join10(workspacePath, ".coder-studio", "supervisor", "targets", targetId);
 }
 function metaPath(workspacePath, targetId) {
-  return join9(targetDir(workspacePath, targetId), "meta.json");
+  return join10(targetDir(workspacePath, targetId), "meta.json");
 }
 function memoryPath(workspacePath, targetId) {
-  return join9(targetDir(workspacePath, targetId), "memory.json");
+  return join10(targetDir(workspacePath, targetId), "memory.json");
 }
 function cyclesPath(workspacePath, targetId) {
-  return join9(targetDir(workspacePath, targetId), "cycles.jsonl");
+  return join10(targetDir(workspacePath, targetId), "cycles.jsonl");
 }
 function targetsRoot(workspacePath) {
-  return join9(workspacePath, ".coder-studio", "supervisor", "targets");
+  return join10(workspacePath, ".coder-studio", "supervisor", "targets");
 }
 function metaFilePath(dirPath) {
-  return join9(dirPath, "meta.json");
+  return join10(dirPath, "meta.json");
 }
 function memoryFilePath(dirPath) {
-  return join9(dirPath, "memory.json");
+  return join10(dirPath, "memory.json");
 }
 function cyclesFilePath(dirPath) {
-  return join9(dirPath, "cycles.jsonl");
+  return join10(dirPath, "cycles.jsonl");
 }
 function hasCode2(error, code) {
   return Boolean(
@@ -11326,7 +11728,7 @@ function errorMessage(error, fallback) {
   }
   return fallback;
 }
-function isRecord10(value) {
+function isRecord12(value) {
   return Boolean(value) && typeof value === "object";
 }
 function readNonEmptyString(value) {
@@ -11370,7 +11772,7 @@ function fallbackAcceptanceCriteria(title) {
   return [`${title} is complete`];
 }
 function normalizeItem(value, fallbackKind) {
-  if (!isRecord10(value)) {
+  if (!isRecord12(value)) {
     return null;
   }
   const id = readNonEmptyString(value.id);
@@ -11401,7 +11803,7 @@ function normalizeLegacyPlanItems(plan) {
   }
   return plan.flatMap((value) => {
     const item = normalizeItem(
-      isRecord10(value) ? {
+      isRecord12(value) ? {
         id: value.id,
         kind: "stage",
         title: value.title,
@@ -11425,7 +11827,7 @@ function resolveActiveItemId(items, candidate) {
   return items.find((item) => item.status === "in_progress")?.id ?? items.find((item) => item.status === "pending")?.id ?? items[0]?.id;
 }
 function normalizeTargetMemory(raw, targetId) {
-  if (!isRecord10(raw)) {
+  if (!isRecord12(raw)) {
     return buildTargetMemory(targetId, 0);
   }
   const updatedAt = readTimestamp(raw.updatedAt, 0);
@@ -11452,7 +11854,7 @@ function normalizeTargetMemory(raw, targetId) {
   };
 }
 function normalizePersistedSupervisor(raw, fallback) {
-  if (!isRecord10(raw)) {
+  if (!isRecord12(raw)) {
     return void 0;
   }
   const id = readNonEmptyString(raw.id) ?? fallback.targetId;
@@ -11488,7 +11890,7 @@ function normalizePersistedSupervisor(raw, fallback) {
   };
 }
 function normalizeTargetMeta(raw, fallbackTargetId) {
-  if (!isRecord10(raw)) {
+  if (!isRecord12(raw)) {
     const targetId2 = fallbackTargetId ?? "";
     return {
       targetId: targetId2,
@@ -11609,7 +12011,7 @@ async function resetTargetFiles(workspacePath, input) {
   const parentDir = dirname6(dir);
   const backupDir = `${dir}.backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   await mkdir4(parentDir, { recursive: true });
-  const stagingDir = await mkdtemp2(join9(parentDir, `${input.targetId}.reset-`));
+  const stagingDir = await mkdtemp2(join10(parentDir, `${input.targetId}.reset-`));
   let backupCreated = false;
   let promoted = false;
   let restored = false;
@@ -12066,8 +12468,8 @@ var init_terminal_snapshot_buffer = __esm({
         if (this.pendingWriteCount === 0) {
           return Promise.resolve();
         }
-        return new Promise((resolve6) => {
-          this.drainResolvers.push(resolve6);
+        return new Promise((resolve8) => {
+          this.drainResolvers.push(resolve8);
         });
       }
       resolveDrainIfIdle() {
@@ -12076,8 +12478,8 @@ var init_terminal_snapshot_buffer = __esm({
         }
         const resolvers = this.drainResolvers;
         this.drainResolvers = [];
-        for (const resolve6 of resolvers) {
-          resolve6();
+        for (const resolve8 of resolvers) {
+          resolve8();
         }
       }
       requireTerminal() {
@@ -12438,10 +12840,10 @@ var init_manager5 = __esm({
           }
           return existing.promise;
         }
-        let resolve6 = () => {
+        let resolve8 = () => {
         };
         const promise = new Promise((innerResolve) => {
-          resolve6 = innerResolve;
+          resolve8 = innerResolve;
         });
         let markKillCompleted = () => {
         };
@@ -12454,7 +12856,7 @@ var init_manager5 = __esm({
           markKillCompleted,
           finalized: false,
           promise,
-          resolve: resolve6
+          resolve: resolve8
         });
         void terminal.pty.kill(signal).finally(() => {
           const waiter = this.explicitCloseWaiters.get(terminalId);
@@ -13024,7 +13426,7 @@ var init_validator = __esm({
 // packages/server/src/fs/gitignore.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import ignore from "ignore";
-import { join as join10, relative as relative2 } from "path";
+import { join as join11, relative as relative2 } from "path";
 function normalizePath(path14) {
   return path14.replace(/\\/g, "/");
 }
@@ -13047,7 +13449,7 @@ function isIgnoredByGitignore(ig, path14) {
   return ig.ignores(path14) || ig.ignores(`${path14}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
-  const gitignorePath = join10(rootPath, ".gitignore");
+  const gitignorePath = join11(rootPath, ".gitignore");
   if (!existsSync7(gitignorePath)) {
     return (name) => !isDefaultTreeIgnored(name);
   }
@@ -13057,7 +13459,7 @@ function createGitignoreFilter(rootPath, dirPath) {
     if (isAlwaysTreeIgnored(name)) {
       return false;
     }
-    const relativePath = relativeToRoot(rootPath, join10(dirPath, name));
+    const relativePath = relativeToRoot(rootPath, join11(dirPath, name));
     return !isIgnoredByGitignore(ig, relativePath);
   };
 }
@@ -13730,7 +14132,7 @@ var init_fencing = __esm({
 // packages/server/src/commands/terminal.ts
 import { stat as stat8 } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute2 } from "node:path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function decodeTerminalInput(args) {
   if ("bytes" in args) {
     return Buffer.from(args.bytes, "base64");
@@ -13802,29 +14204,29 @@ var init_terminal = __esm({
     init_src3();
     init_file_io();
     init_dispatch();
-    TerminalInputActivitySchema = z6.enum(TERMINAL_INPUT_ACTIVITIES).optional();
-    TerminalInputSchema = z6.union([
-      z6.object({
-        terminalId: z6.string(),
-        bytes: z6.string(),
+    TerminalInputActivitySchema = z7.enum(TERMINAL_INPUT_ACTIVITIES).optional();
+    TerminalInputSchema = z7.union([
+      z7.object({
+        terminalId: z7.string(),
+        bytes: z7.string(),
         activity: TerminalInputActivitySchema,
-        submittedText: z6.string().optional()
+        submittedText: z7.string().optional()
       }),
-      z6.object({
-        terminalId: z6.string(),
-        transport: z6.literal("binary"),
-        streamId: z6.number().int().nonnegative(),
-        size: z6.number().int().nonnegative(),
+      z7.object({
+        terminalId: z7.string(),
+        transport: z7.literal("binary"),
+        streamId: z7.number().int().nonnegative(),
+        size: z7.number().int().nonnegative(),
         activity: TerminalInputActivitySchema,
-        submittedText: z6.string().optional()
+        submittedText: z7.string().optional()
       })
     ]);
     pendingTerminalInput = /* @__PURE__ */ new Map();
     nextOutboundBinaryStreamId = 0;
     registerCommand(
       "terminal.list",
-      z6.object({
-        workspaceId: z6.string()
+      z7.object({
+        workspaceId: z7.string()
       }),
       async (args, ctx) => {
         return ctx.terminalMgr.getAll().map((terminal) => terminal.toDTO()).filter((terminal) => terminal.workspaceId === args.workspaceId);
@@ -13832,12 +14234,12 @@ var init_terminal = __esm({
     );
     registerCommand(
       "terminal.create",
-      z6.object({
-        workspaceId: z6.string(),
-        cols: z6.number().int().positive().optional(),
-        rows: z6.number().int().positive().optional(),
-        cwdPath: z6.string().optional(),
-        themeBackground: z6.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional()
+      z7.object({
+        workspaceId: z7.string(),
+        cols: z7.number().int().positive().optional(),
+        rows: z7.number().int().positive().optional(),
+        cwdPath: z7.string().optional(),
+        themeBackground: z7.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -13883,9 +14285,9 @@ var init_terminal = __esm({
     );
     registerCommand(
       "terminal.replay",
-      z6.object({
-        terminalId: z6.string(),
-        lastSeq: z6.number().int().nonnegative().optional()
+      z7.object({
+        terminalId: z7.string(),
+        lastSeq: z7.number().int().nonnegative().optional()
       }),
       async (args, ctx, clientId) => {
         const replay = ctx.terminalMgr.replay(args.terminalId, args.lastSeq ?? 0);
@@ -13910,8 +14312,8 @@ var init_terminal = __esm({
     );
     registerCommand(
       "terminal.snapshot",
-      z6.object({
-        terminalId: z6.string()
+      z7.object({
+        terminalId: z7.string()
       }),
       async (args, ctx, clientId) => {
         const snapshot = await ctx.terminalMgr.snapshot(args.terminalId);
@@ -13939,8 +14341,8 @@ var init_terminal = __esm({
     );
     registerCommand(
       "terminal.close",
-      z6.object({
-        terminalId: z6.string()
+      z7.object({
+        terminalId: z7.string()
       }),
       async (args, ctx) => {
         await ctx.terminalMgr.close(args.terminalId);
@@ -13962,10 +14364,10 @@ var init_terminal = __esm({
     });
     registerCommand(
       "terminal.resize",
-      z6.object({
-        terminalId: z6.string(),
-        cols: z6.number().int().positive(),
-        rows: z6.number().int().positive()
+      z7.object({
+        terminalId: z7.string(),
+        cols: z7.number().int().positive(),
+        rows: z7.number().int().positive()
       }),
       async (args, ctx) => {
         const sessionId = ctx.sessionMgr.findSessionIdByTerminal(args.terminalId);
@@ -14588,7 +14990,7 @@ var init_hub = __esm({
         }
       }
       awaitBinaryPayload(clientId) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           const timer = setTimeout(() => {
             const waiters = this.pendingBinaryWaiters.get(clientId);
             if (!waiters) return;
@@ -14600,7 +15002,7 @@ var init_hub = __esm({
             }
             reject(new Error("Timeout waiting for terminal input binary payload"));
           }, BINARY_PAYLOAD_TIMEOUT_MS);
-          const waiter = { resolve: resolve6, reject, timer };
+          const waiter = { resolve: resolve8, reject, timer };
           const queue = this.pendingBinaryWaiters.get(clientId);
           if (queue) {
             queue.push(waiter);
@@ -14904,57 +15306,270 @@ var init_hub = __esm({
   }
 });
 
-// packages/server/src/commands/workspace.ts
-import { readdir as readdir3, realpath as realpath3 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute3, join as join11, resolve as resolve4 } from "node:path";
-import { z as z7 } from "zod";
-function resolveBrowsePath(path14) {
-  const home = homedir2();
-  if (!path14 || path14 === "~") {
-    return home;
+// packages/server/src/workspace/intelligence.ts
+import { access as access2, lstat as lstat2, readFile as readFile4, stat as stat9 } from "node:fs/promises";
+import { join as join12, resolve as resolve4 } from "node:path";
+async function inspectWorkspaceIntelligence(input) {
+  const [packageManager, manifest, git, docsExistence, agentsExists, frameworks] = await Promise.all([
+    detectPackageManager(input.rootPath),
+    readPackageJson(input.rootPath),
+    detectGitState(input.rootPath),
+    detectDocs(input.rootPath),
+    pathExists(join12(input.rootPath, AGENT_INSTRUCTIONS_RELATIVE_PATH)),
+    detectFrameworks(input.rootPath)
+  ]);
+  const scripts = extractScripts(manifest);
+  return {
+    workspaceId: input.workspaceId,
+    rootPath: input.rootPath,
+    git,
+    packageManager,
+    frameworks,
+    scripts,
+    recommendedCommands: buildRecommendedCommands(packageManager, scripts),
+    docs: docsExistence,
+    agentInstructions: {
+      exists: agentsExists,
+      path: AGENT_INSTRUCTIONS_RELATIVE_PATH
+    }
+  };
+}
+async function detectPackageManager(rootPath) {
+  for (const candidate of packageManagerCandidates) {
+    if (await pathExists(join12(rootPath, candidate.file))) {
+      return candidate.manager;
+    }
   }
-  if (path14.startsWith("~/")) {
-    return join11(home, path14.slice(2));
+  if (await pathExists(join12(rootPath, "package.json"))) {
+    return "npm";
   }
-  return isAbsolute3(path14) ? path14 : resolve4(home, path14);
+  return void 0;
 }
-async function buildRootPaths(currentPath) {
-  const roots = /* @__PURE__ */ new Set(["/"]);
-  const home = homedir2();
-  roots.add(home);
+async function readPackageJson(rootPath) {
+  const packageJsonPath = join12(rootPath, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return null;
+  }
   try {
-    roots.add(await realpath3(home));
+    const raw = await readFile4(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
+    return null;
   }
-  const currentSegments = currentPath.split("/").filter(Boolean);
-  if (currentSegments.length > 0) {
-    roots.add(`/${currentSegments[0]}`);
+}
+function extractScripts(manifest) {
+  const scripts = manifest?.scripts ?? {};
+  return {
+    dev: normalizeScript(scripts.dev),
+    test: normalizeScript(scripts.test),
+    build: normalizeScript(scripts.build),
+    lint: normalizeScript(scripts.lint)
+  };
+}
+function normalizeScript(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function buildRecommendedCommands(packageManager, scripts) {
+  if (!packageManager) {
+    return [];
   }
-  return Array.from(roots);
+  return packageScriptKeys.flatMap((key) => {
+    if (!scripts[key]) {
+      return [];
+    }
+    return [
+      {
+        key,
+        command: buildPackageCommand(packageManager, key),
+        source: "package_json"
+      }
+    ];
+  });
 }
-var init_workspace = __esm({
-  "packages/server/src/commands/workspace.ts"() {
-    "use strict";
-    init_dispatch();
-    registerCommand("workspace.list", z7.object({}), async (_args, ctx) => {
-      return ctx.workspaceMgr.list();
-    });
-    registerCommand(
-      "workspace.browse",
-      z7.object({
-        path: z7.string().optional()
-      }),
-      async (args) => {
-        const basePath = resolveBrowsePath(args.path);
-        const entries = await readdir3(basePath, { withFileTypes: true });
-        const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+function buildPackageCommand(packageManager, scriptName) {
+  switch (packageManager) {
+    case "pnpm":
+      return `pnpm ${scriptName}`;
+    case "yarn":
+      return `yarn ${scriptName}`;
+    case "bun":
+      return `bun run ${scriptName}`;
+    case "npm":
+    default:
+      return `npm run ${scriptName}`;
+  }
+}
+async function detectFrameworks(rootPath) {
+  const manifest = await readPackageJson(rootPath);
+  const deps = {
+    ...manifest?.dependencies ?? {},
+    ...manifest?.devDependencies ?? {}
+  };
+  const frameworks = /* @__PURE__ */ new Set();
+  if ("next" in deps) {
+    frameworks.add("Next.js");
+  }
+  if ("react" in deps) {
+    frameworks.add("React");
+  }
+  if ("vite" in deps || await hasAnyPath(rootPath, viteConfigFiles)) {
+    frameworks.add("Vite");
+  }
+  if (manifest) {
+    frameworks.add("Node");
+  }
+  if (await hasAnyPath(rootPath, ["pnpm-workspace.yaml", "turbo.json", "nx.json"])) {
+    frameworks.add("Monorepo");
+  }
+  return frameworkOrder.filter((framework) => frameworks.has(framework));
+}
+async function detectGitState(rootPath) {
+  const gitPath = join12(rootPath, ".git");
+  let stats;
+  try {
+    stats = await lstat2(gitPath);
+  } catch {
+    return { isRepo: false };
+  }
+  const gitDir = stats.isDirectory() ? gitPath : stats.isFile() ? await resolveGitDirFromFile(rootPath, gitPath) : null;
+  if (!gitDir) {
+    return { isRepo: false };
+  }
+  const branch = await readGitBranch(gitDir);
+  return branch ? { isRepo: true, branch } : { isRepo: true };
+}
+async function resolveGitDirFromFile(rootPath, gitFilePath) {
+  try {
+    const raw = await readFile4(gitFilePath, "utf8");
+    const match = raw.match(/^gitdir:\s*(.+)\s*$/m);
+    if (!match) {
+      return null;
+    }
+    const gitDirPath = match[1];
+    if (!gitDirPath) {
+      return null;
+    }
+    return resolve4(rootPath, gitDirPath);
+  } catch {
+    return null;
+  }
+}
+async function readGitBranch(gitDir) {
+  try {
+    const head = await readFile4(join12(gitDir, "HEAD"), "utf8");
+    const refMatch = head.match(/^ref:\s*refs\/heads\/(.+)\s*$/);
+    return refMatch?.[1];
+  } catch {
+    return void 0;
+  }
+}
+async function detectDocs(rootPath) {
+  const docs = [];
+  if (await pathExists(join12(rootPath, "README.md"))) {
+    docs.push({ path: "README.md", kind: "readme" });
+  }
+  if (await pathExists(join12(rootPath, "docs"))) {
+    try {
+      const docsStats = await stat9(join12(rootPath, "docs"));
+      if (docsStats.isDirectory()) {
+        docs.push({ path: "docs", kind: "docs" });
+      }
+    } catch {
+    }
+  }
+  return docs;
+}
+async function hasAnyPath(rootPath, relativePaths) {
+  for (const relativePath of relativePaths) {
+    if (await pathExists(join12(rootPath, relativePath))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function pathExists(path14) {
+  try {
+    await access2(path14);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var frameworkOrder, packageManagerCandidates, packageScriptKeys, viteConfigFiles;
+var init_intelligence = __esm({
+  "packages/server/src/workspace/intelligence.ts"() {
+    "use strict";
+    init_workspace_state();
+    frameworkOrder = ["Next.js", "React", "Vite", "Node", "Monorepo"];
+    packageManagerCandidates = [
+      { file: "pnpm-lock.yaml", manager: "pnpm" },
+      { file: "yarn.lock", manager: "yarn" },
+      { file: "bun.lockb", manager: "bun" },
+      { file: "package-lock.json", manager: "npm" }
+    ];
+    packageScriptKeys = ["dev", "test", "build", "lint"];
+    viteConfigFiles = [
+      "vite.config.ts",
+      "vite.config.js",
+      "vite.config.mjs",
+      "vite.config.cjs"
+    ];
+  }
+});
+
+// packages/server/src/commands/workspace.ts
+import { readdir as readdir3, realpath as realpath3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join13, resolve as resolve5 } from "node:path";
+import { z as z8 } from "zod";
+function resolveBrowsePath(path14) {
+  const home = homedir2();
+  if (!path14 || path14 === "~") {
+    return home;
+  }
+  if (path14.startsWith("~/")) {
+    return join13(home, path14.slice(2));
+  }
+  return isAbsolute3(path14) ? path14 : resolve5(home, path14);
+}
+async function buildRootPaths(currentPath) {
+  const roots = /* @__PURE__ */ new Set(["/"]);
+  const home = homedir2();
+  roots.add(home);
+  try {
+    roots.add(await realpath3(home));
+  } catch {
+  }
+  const currentSegments = currentPath.split("/").filter(Boolean);
+  if (currentSegments.length > 0) {
+    roots.add(`/${currentSegments[0]}`);
+  }
+  return Array.from(roots);
+}
+var init_workspace = __esm({
+  "packages/server/src/commands/workspace.ts"() {
+    "use strict";
+    init_intelligence();
+    init_dispatch();
+    registerCommand("workspace.list", z8.object({}), async (_args, ctx) => {
+      return ctx.workspaceMgr.list();
+    });
+    registerCommand(
+      "workspace.browse",
+      z8.object({
+        path: z8.string().optional()
+      }),
+      async (args) => {
+        const basePath = resolveBrowsePath(args.path);
+        const entries = await readdir3(basePath, { withFileTypes: true });
+        const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
           name: entry.name,
-          path: join11(basePath, entry.name)
+          path: join13(basePath, entry.name)
         })).sort((a, b) => a.name.localeCompare(b.name));
         return {
           currentPath: basePath,
-          parentPath: basePath !== "/" ? join11(basePath, "..") : null,
+          parentPath: basePath !== "/" ? join13(basePath, "..") : null,
           directories,
           rootPaths: await buildRootPaths(basePath)
         };
@@ -14962,8 +15577,8 @@ var init_workspace = __esm({
     );
     registerCommand(
       "workspace.open",
-      z7.object({
-        path: z7.string()
+      z8.object({
+        path: z8.string()
       }),
       async (args, ctx) => {
         return ctx.workspaceMgr.open({
@@ -14971,10 +15586,26 @@ var init_workspace = __esm({
         });
       }
     );
+    registerCommand(
+      "workspace.intelligence",
+      z8.object({
+        workspaceId: z8.string()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return inspectWorkspaceIntelligence({
+          workspaceId: workspace.id,
+          rootPath: workspace.path
+        });
+      }
+    );
     registerCommand(
       "workspace.close",
-      z7.object({
-        id: z7.string()
+      z8.object({
+        id: z8.string()
       }),
       async (args, ctx) => {
         await ctx.workspaceMgr.close(args.id);
@@ -14982,27 +15613,27 @@ var init_workspace = __esm({
     );
     registerCommand(
       "workspace.uiState.set",
-      z7.object({
-        workspaceId: z7.string(),
-        uiState: z7.object({
-          leftPanelWidth: z7.number(),
-          bottomPanelHeight: z7.number(),
-          focusMode: z7.boolean(),
-          activeSessionId: z7.string().optional(),
-          fileTreeExpandedDirs: z7.array(z7.string()).optional(),
-          paneLayout: z7.object({
-            id: z7.string(),
-            type: z7.enum(["leaf", "split"]),
-            sessionId: z7.string().optional(),
-            direction: z7.enum(["horizontal", "vertical"]).optional(),
-            children: z7.lazy(
-              () => z7.array(
-                z7.object({
-                  id: z7.string(),
-                  type: z7.enum(["leaf", "split"]),
-                  sessionId: z7.string().optional(),
-                  direction: z7.enum(["horizontal", "vertical"]).optional(),
-                  children: z7.any().optional()
+      z8.object({
+        workspaceId: z8.string(),
+        uiState: z8.object({
+          leftPanelWidth: z8.number(),
+          bottomPanelHeight: z8.number(),
+          focusMode: z8.boolean(),
+          activeSessionId: z8.string().optional(),
+          fileTreeExpandedDirs: z8.array(z8.string()).optional(),
+          paneLayout: z8.object({
+            id: z8.string(),
+            type: z8.enum(["leaf", "split"]),
+            sessionId: z8.string().optional(),
+            direction: z8.enum(["horizontal", "vertical"]).optional(),
+            children: z8.lazy(
+              () => z8.array(
+                z8.object({
+                  id: z8.string(),
+                  type: z8.enum(["leaf", "split"]),
+                  sessionId: z8.string().optional(),
+                  direction: z8.enum(["horizontal", "vertical"]).optional(),
+                  children: z8.any().optional()
                 })
               )
             ).optional()
@@ -15022,7 +15653,7 @@ var init_workspace = __esm({
 });
 
 // packages/server/src/commands/workspace-activity.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function parseWorkspaceLastViewedTarget(value) {
   try {
     const parsed = JSON.parse(value);
@@ -15038,15 +15669,15 @@ var init_workspace_activity = __esm({
     "use strict";
     init_dispatch();
     WORKSPACE_LAST_VIEWED_TARGET_KEY = "workspace.lastViewedTarget";
-    workspaceLastViewedTargetSchema = z8.object({
-      workspaceId: z8.string(),
-      sessionId: z8.string().optional(),
-      updatedAt: z8.number()
+    workspaceLastViewedTargetSchema = z9.object({
+      workspaceId: z9.string(),
+      sessionId: z9.string().optional(),
+      updatedAt: z9.number()
     });
     registerCommand(
       "workspace.activate",
-      z8.object({
-        workspaceId: z8.string()
+      z9.object({
+        workspaceId: z9.string()
       }),
       async (args, ctx, clientId) => {
         if (!clientId) {
@@ -15056,14 +15687,14 @@ var init_workspace_activity = __esm({
         return {};
       }
     );
-    registerCommand("workspace.deactivate", z8.object({}), async (_args, ctx, clientId) => {
+    registerCommand("workspace.deactivate", z9.object({}), async (_args, ctx, clientId) => {
       if (!clientId) {
         return {};
       }
       ctx.autoFetch.unregisterViewer(clientId);
       return {};
     });
-    registerCommand("workspace.lastViewedTarget.get", z8.object({}), async (_args, ctx) => {
+    registerCommand("workspace.lastViewedTarget.get", z9.object({}), async (_args, ctx) => {
       const value = ctx.settingsRepo.get(WORKSPACE_LAST_VIEWED_TARGET_KEY);
       if (value === void 0) {
         return null;
@@ -15072,9 +15703,9 @@ var init_workspace_activity = __esm({
     });
     registerCommand(
       "workspace.lastViewedTarget.set",
-      z8.object({
-        workspaceId: z8.string(),
-        sessionId: z8.string().optional()
+      z9.object({
+        workspaceId: z9.string(),
+        sessionId: z9.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -15098,14 +15729,14 @@ var init_workspace_activity = __esm({
 });
 
 // packages/server/src/commands/activation.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var init_activation2 = __esm({
   "packages/server/src/commands/activation.ts"() {
     "use strict";
     init_dispatch();
     registerCommand(
       "activation.claim",
-      z9.object({ clientInstanceId: z9.string().min(1) }),
+      z10.object({ clientInstanceId: z10.string().min(1) }),
       async (args, ctx, clientId) => {
         if (!clientId) {
           throw {
@@ -15129,7 +15760,7 @@ var init_activation2 = __esm({
     );
     registerCommand(
       "activation.release",
-      z9.object({ clientInstanceId: z9.string(), generation: z9.number().int().positive() }),
+      z10.object({ clientInstanceId: z10.string(), generation: z10.number().int().positive() }),
       async (args, ctx, clientId) => {
         const lease = ctx.activationMgr.getLease();
         if (!clientId || !lease || lease.wsClientId !== clientId) {
@@ -15143,34 +15774,34 @@ var init_activation2 = __esm({
 });
 
 // packages/server/src/commands/connection.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var init_connection = __esm({
   "packages/server/src/commands/connection.ts"() {
     "use strict";
     init_dispatch();
-    registerCommand("connection.probe", z10.object({}).default({}), async () => {
+    registerCommand("connection.probe", z11.object({}).default({}), async () => {
       return { ok: true };
     });
   }
 });
 
 // packages/server/src/commands/recovery.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var RecoveryReasonSchema;
 var init_recovery = __esm({
   "packages/server/src/commands/recovery.ts"() {
     "use strict";
     init_src3();
     init_dispatch();
-    RecoveryReasonSchema = z11.enum(RECOVERY_REASONS);
+    RecoveryReasonSchema = z12.enum(RECOVERY_REASONS);
     registerCommand(
       "recovery.reconcile",
-      z11.object({
+      z12.object({
         reason: RecoveryReasonSchema,
-        terminals: z11.array(
-          z11.object({
-            terminalId: z11.string(),
-            renderedSeq: z11.number().int().nonnegative()
+        terminals: z12.array(
+          z12.object({
+            terminalId: z12.string(),
+            renderedSeq: z12.number().int().nonnegative()
           })
         )
       }),
@@ -15416,15 +16047,33 @@ var init_pane_layout = __esm({
 });
 
 // packages/server/src/commands/session.ts
-import { z as z12 } from "zod";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join14, resolve as resolve6 } from "node:path";
+import { z as z13 } from "zod";
 function delay(ms) {
-  return new Promise((resolve6) => {
-    setTimeout(resolve6, ms);
+  return new Promise((resolve8) => {
+    setTimeout(resolve8, ms);
   });
 }
 function getProviderFromRegistry(providerId, registry) {
   return registry.find((provider) => provider.id === providerId);
 }
+async function tryReadGitHead(workspacePath) {
+  try {
+    const gitEntryPath = join14(workspacePath, ".git");
+    const gitEntry = await readFile5(gitEntryPath, "utf8").catch(() => null);
+    let gitDir = gitEntryPath;
+    if (gitEntry && gitEntry.startsWith("gitdir:")) {
+      const relativeGitDir = gitEntry.slice("gitdir:".length).trim();
+      gitDir = resolve6(workspacePath, relativeGitDir);
+    }
+    const head = await readFile5(join14(gitDir, "HEAD"), "utf8");
+    const trimmed = head.trim();
+    return trimmed.length > 0 && !trimmed.startsWith("ref:") ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var SESSION_CLOSE_POLL_INTERVAL_MS, SESSION_CLOSE_TIMEOUT_MS;
 var init_session2 = __esm({
   "packages/server/src/commands/session.ts"() {
@@ -15436,8 +16085,8 @@ var init_session2 = __esm({
     SESSION_CLOSE_TIMEOUT_MS = 5e3;
     registerCommand(
       "session.list",
-      z12.object({
-        workspaceId: z12.string()
+      z13.object({
+        workspaceId: z13.string()
       }),
       async (args, ctx) => {
         return ctx.sessionMgr.getForWorkspace(args.workspaceId);
@@ -15445,11 +16094,11 @@ var init_session2 = __esm({
     );
     registerCommand(
       "session.create",
-      z12.object({
-        workspaceId: z12.string(),
-        providerId: z12.string(),
-        draft: z12.string().optional(),
-        themeBackground: z12.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional()
+      z13.object({
+        workspaceId: z13.string(),
+        providerId: z13.string(),
+        draft: z13.string().optional(),
+        themeBackground: z13.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -15472,7 +16121,7 @@ var init_session2 = __esm({
             }
           };
         }
-        return ctx.sessionMgr.create({
+        const session = await ctx.sessionMgr.create({
           workspaceId: args.workspaceId,
           workspacePath: workspace.path,
           providerId: args.providerId,
@@ -15480,12 +16129,22 @@ var init_session2 = __esm({
           draft: args.draft,
           themeBackground: args.themeBackground
         });
+        ctx.sessionMetadataRepo?.upsert({
+          sessionId: session.id,
+          workspaceId: args.workspaceId,
+          providerId: args.providerId,
+          objective: args.draft?.trim() || void 0,
+          baselineGitHead: await tryReadGitHead(workspace.path),
+          baselineCapturedAt: Date.now(),
+          verificationRuns: []
+        });
+        return session;
       }
     );
     registerCommand(
       "session.stop",
-      z12.object({
-        sessionId: z12.string()
+      z13.object({
+        sessionId: z13.string()
       }),
       async (args, ctx) => {
         await ctx.sessionMgr.stop(args.sessionId);
@@ -15493,8 +16152,8 @@ var init_session2 = __esm({
     );
     registerCommand(
       "session.remove",
-      z12.object({
-        sessionId: z12.string()
+      z13.object({
+        sessionId: z13.string()
       }),
       async (args, ctx) => {
         const session = ctx.sessionMgr.get(args.sessionId);
@@ -15505,13 +16164,14 @@ var init_session2 = __esm({
           throw { code: "invalid_state", message: `Cannot remove session in state: ${session.state}` };
         }
         ctx.sessionMgr.delete(args.sessionId);
+        ctx.sessionMetadataRepo?.delete(args.sessionId);
       }
     );
     registerCommand(
       "session.close",
-      z12.object({
-        sessionId: z12.string(),
-        paneDisposition: z12.enum(["draft", "remove"]).default("draft")
+      z13.object({
+        sessionId: z13.string(),
+        paneDisposition: z13.enum(["draft", "remove"]).default("draft")
       }),
       async (args, ctx) => {
         let session = ctx.sessionMgr.get(args.sessionId);
@@ -15567,112 +16227,553 @@ var init_session2 = __esm({
         };
         ctx.workspaceMgr.updateUiState(session.workspaceId, nextUiState);
         ctx.sessionMgr.delete(args.sessionId);
+        ctx.sessionMetadataRepo?.delete(args.sessionId);
       }
     );
   }
 });
 
-// packages/server/src/fs/content-search.ts
-import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { readdir as readdir4, readFile as readFile4, stat as stat9 } from "fs/promises";
-import { basename as basename2, join as join12, relative as relative3 } from "path";
-import { createInterface } from "readline";
-async function searchFileContents(rootPath, options) {
-  const query = options.query.trim();
-  if (!query) {
-    return {
-      files: [],
-      totalMatchCount: 0,
-      hasMoreFiles: false,
-      truncatedMatchFileCount: 0
+// packages/server/src/commands/session-metadata.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { z as z14 } from "zod";
+function requireSessionMetadataRepo(ctx) {
+  if (!ctx.sessionMetadataRepo) {
+    throw {
+      code: "session_metadata_unavailable",
+      message: "Session metadata repository is not configured"
     };
   }
-  const result = await searchWithRipgrep(rootPath, query, options.maxFiles).catch(
-    async (error) => {
-      if (error.code === "ENOENT") {
-        return searchWithNode(rootPath, query, options.maxFiles);
-      }
-      throw error;
-    }
-  );
-  return finalizeResults(result, options.maxFiles, options.maxMatchesPerFile);
 }
-async function searchWithRipgrep(rootPath, query, maxFiles) {
-  const hasGitignore = existsSync8(join12(rootPath, ".gitignore"));
-  const args = [
-    "--json",
-    "--line-number",
-    "--column",
-    "--fixed-strings",
-    "--sort",
-    "path",
-    "--with-filename",
-    "--glob",
-    "!**/.git/**",
-    "--glob",
-    "!**/node_modules/**"
-  ];
-  if (hasGitignore) {
-    args.push("--hidden");
-    args.push("--no-require-git");
-  }
-  args.push(query, ".");
-  return new Promise((resolve6, reject) => {
-    const child = spawn5("rg", args, { cwd: rootPath, stdio: ["ignore", "pipe", "pipe"] });
-    const stdout = createInterface({ input: child.stdout });
-    const files = /* @__PURE__ */ new Map();
-    let totalMatchCount = 0;
-    let hasMoreFiles = false;
-    let stderr = "";
-    stdout.on("line", (line) => {
-      if (!line.trim()) {
-        return;
-      }
-      const event = JSON.parse(line);
-      if (event.type !== "match") {
-        return;
-      }
-      const rawPath = event.data?.path?.text;
-      if (!rawPath) {
-        return;
-      }
-      const relativePath = normalizeRelativePath(relative3(rootPath, join12(rootPath, rawPath)));
-      const preview = (event.data?.lines?.text ?? "").replace(/\r?\n$/, "");
-      const lineNumber = event.data?.line_number ?? 1;
-      const submatches = event.data?.submatches ?? [];
-      totalMatchCount += submatches.length;
-      if (!files.has(relativePath) && files.size >= maxFiles) {
-        hasMoreFiles = true;
-        return;
+var init_session_metadata = __esm({
+  "packages/server/src/commands/session-metadata.ts"() {
+    "use strict";
+    init_dispatch();
+    registerCommand(
+      "session.metadata.get",
+      z14.object({
+        sessionId: z14.string()
+      }),
+      async (args, ctx) => {
+        requireSessionMetadataRepo(ctx);
+        const metadata = ctx.sessionMetadataRepo.get(args.sessionId);
+        if (!metadata) {
+          throw {
+            code: "session_metadata_not_found",
+            message: `Session metadata not found: ${args.sessionId}`
+          };
+        }
+        return metadata;
       }
-      for (const submatch of submatches) {
-        pushMatch(files, relativePath, {
-          line: lineNumber,
-          column: byteOffsetToColumn(preview, submatch.start),
-          endColumn: byteOffsetToColumn(preview, submatch.end),
-          preview,
-          previewColumnStart: byteOffsetToColumn(preview, submatch.start),
-          previewColumnEnd: byteOffsetToColumn(preview, submatch.end)
+    );
+    registerCommand(
+      "session.verification.add",
+      z14.object({
+        sessionId: z14.string(),
+        command: z14.string().trim().min(1),
+        status: z14.enum(["passed", "failed", "unknown"]),
+        exitCode: z14.number().int().optional(),
+        summary: z14.string().optional()
+      }),
+      async (args, ctx) => {
+        requireSessionMetadataRepo(ctx);
+        return ctx.sessionMetadataRepo.addVerificationRun(args.sessionId, {
+          id: randomUUID6(),
+          command: args.command,
+          status: args.status,
+          exitCode: args.exitCode,
+          summary: args.summary?.trim() || void 0,
+          createdAt: Date.now()
         });
       }
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => {
-      void stdout.close();
-      reject(error);
-    });
-    child.on("close", (code) => {
-      void stdout.close();
-      if (code === 0 || code === 1) {
-        resolve6({
-          files: sortAccumulators(files),
-          totalMatchCount,
-          hasMoreFiles
-        });
-        return;
+    );
+  }
+});
+
+// packages/server/src/git/diff.ts
+import { mkdtemp as mkdtemp3, readFile as readFile6, rm as rm7 } from "fs/promises";
+import os3 from "os";
+import path11 from "path";
+async function isTrackedPath(cwd, filePath) {
+  try {
+    await runGit(cwd, ["ls-files", "--error-unmatch", "--", filePath]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getUntrackedFileDiff(cwd, filePath) {
+  const tempDir = await mkdtemp3(path11.join(os3.tmpdir(), "coder-studio-git-diff-"));
+  const tempIndex = path11.join(tempDir, "index");
+  try {
+    try {
+      await runGit(cwd, ["read-tree", "HEAD"], {
+        env: { GIT_INDEX_FILE: tempIndex }
+      });
+    } catch (error) {
+      if (!(error instanceof GitError)) {
+        throw error;
+      }
+      await runGit(cwd, ["read-tree", "--empty"], {
+        env: { GIT_INDEX_FILE: tempIndex }
+      });
+    }
+    await runGit(cwd, ["add", "-N", "--", filePath], {
+      env: { GIT_INDEX_FILE: tempIndex }
+    });
+    const result = await runGit(cwd, ["diff", "--", filePath], {
+      env: { GIT_INDEX_FILE: tempIndex }
+    });
+    return result.stdout;
+  } finally {
+    await rm7(tempDir, { recursive: true, force: true });
+  }
+}
+async function pathExists2(cwd, filePath) {
+  try {
+    await readFile6(resolveSafe(cwd, filePath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextAtRevision(cwd, revision, filePath) {
+  if (revision === "WORKTREE") {
+    return readFile6(resolveSafe(cwd, filePath), "utf-8");
+  }
+  try {
+    const gitSpec = revision === "INDEX" ? `:${filePath}` : `${revision}:${filePath}`;
+    const result = await runGit(cwd, ["show", gitSpec]);
+    return result.stdout;
+  } catch {
+    return "";
+  }
+}
+async function deriveFileDiffStatus(cwd, filePath, staged) {
+  const tracked = await isTrackedPath(cwd, filePath);
+  const existsOnDisk = await pathExists2(cwd, filePath);
+  if (!staged && !tracked) {
+    return "added";
+  }
+  if (staged) {
+    try {
+      await runGit(cwd, ["cat-file", "-e", `HEAD:${filePath}`]);
+      return existsOnDisk ? "modified" : "deleted";
+    } catch {
+      return "added";
+    }
+  }
+  return existsOnDisk ? "modified" : "deleted";
+}
+async function buildTextDiffResult(cwd, filePath, staged, diff) {
+  const status = await deriveFileDiffStatus(cwd, filePath, staged);
+  if (status === "added") {
+    return {
+      diff,
+      renderAs: "text",
+      status,
+      originalContent: "",
+      modifiedContent: await readTextAtRevision(cwd, staged ? "INDEX" : "WORKTREE", filePath)
+    };
+  }
+  if (status === "deleted") {
+    return {
+      diff,
+      renderAs: "text",
+      status,
+      originalContent: await readTextAtRevision(cwd, staged ? "HEAD" : "INDEX", filePath),
+      modifiedContent: ""
+    };
+  }
+  return {
+    diff,
+    renderAs: "text",
+    status,
+    originalContent: await readTextAtRevision(cwd, staged ? "HEAD" : "INDEX", filePath),
+    modifiedContent: await readTextAtRevision(cwd, staged ? "INDEX" : "WORKTREE", filePath)
+  };
+}
+async function getFileDiff(cwd, path14, staged = false) {
+  const imageType = getImageTypeInfo(path14);
+  if (!staged && !await isTrackedPath(cwd, path14)) {
+    const diff = await getUntrackedFileDiff(cwd, path14);
+    if (imageType) {
+      return {
+        diff,
+        renderAs: "image",
+        status: "added",
+        originalRevision: "HEAD",
+        modifiedRevision: "WORKTREE"
+      };
+    }
+    return buildTextDiffResult(cwd, path14, staged, diff);
+  }
+  const args = staged ? ["diff", "--staged", "--", path14] : ["diff", "--", path14];
+  const result = await runGit(cwd, args);
+  if (imageType && /Binary files .* differ/.test(result.stdout)) {
+    return {
+      diff: result.stdout,
+      renderAs: "image",
+      status: await deriveFileDiffStatus(cwd, path14, staged),
+      originalRevision: staged ? "HEAD" : "INDEX",
+      modifiedRevision: staged ? "INDEX" : "WORKTREE"
+    };
+  }
+  return buildTextDiffResult(cwd, path14, staged, result.stdout);
+}
+var init_diff = __esm({
+  "packages/server/src/git/diff.ts"() {
+    "use strict";
+    init_file_io();
+    init_image();
+    init_cli();
+  }
+});
+
+// packages/server/src/session-review/review.ts
+function isWorkspaceStatePath(path14) {
+  return path14 === WORKSPACE_STATE_DIR || path14.startsWith(`${WORKSPACE_STATE_DIR}/`);
+}
+function requireSessionMetadata(metadataRepo, sessionId) {
+  const metadata = metadataRepo.get(sessionId);
+  if (!metadata) {
+    throw {
+      code: "session_metadata_not_found",
+      message: `Session metadata not found: ${sessionId}`
+    };
+  }
+  return metadata;
+}
+async function isGitRepository(workspacePath) {
+  try {
+    await runGit(workspacePath, ["rev-parse", "--git-dir"]);
+    return true;
+  } catch (error) {
+    if (error instanceof GitError) {
+      return false;
+    }
+    throw error;
+  }
+}
+function compareGitChanges(a, b) {
+  const pathCompare = a.path.localeCompare(b.path);
+  if (pathCompare !== 0) {
+    return pathCompare;
+  }
+  return (a.oldPath ?? "").localeCompare(b.oldPath ?? "");
+}
+function mapGitStatus(code) {
+  switch (code[0]) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "M":
+    default:
+      return "modified";
+  }
+}
+async function listTrackedChangesSinceBaseline(workspacePath, baselineGitHead) {
+  const { stdout } = await runGit(workspacePath, [
+    "diff",
+    "--name-status",
+    "--find-renames",
+    baselineGitHead,
+    "--"
+  ]);
+  const changes = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+    const parts = line.split("	");
+    const statusCode = parts[0] ?? "M";
+    if (statusCode.startsWith("R")) {
+      const oldPath = parts[1];
+      const path15 = parts[2];
+      if (!oldPath || !path15) {
+        return null;
+      }
+      return {
+        oldPath,
+        path: path15,
+        status: "renamed"
+      };
+    }
+    const path14 = parts[1];
+    if (!path14) {
+      return null;
+    }
+    return {
+      path: path14,
+      status: mapGitStatus(statusCode)
+    };
+  });
+  return changes.filter((change) => change !== null).filter((change) => !isWorkspaceStatePath(change.path)).sort(compareGitChanges);
+}
+async function listUntrackedChanges(workspacePath) {
+  const { stdout } = await runGit(workspacePath, ["ls-files", "--others", "--exclude-standard"]);
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((path14) => ({
+    path: path14,
+    status: "untracked"
+  })).filter((change) => !isWorkspaceStatePath(change.path)).sort(compareGitChanges);
+}
+async function isUntrackedPath(workspacePath, filePath) {
+  const { stdout } = await runGit(workspacePath, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "--",
+    filePath
+  ]);
+  return stdout.trim().length > 0;
+}
+async function buildSessionReviewSummary(input) {
+  const metadata = requireSessionMetadata(input.metadataRepo, input.sessionId);
+  if (!metadata.baselineGitHead) {
+    return {
+      sessionId: metadata.sessionId,
+      workspaceId: metadata.workspaceId,
+      baselineGitHead: metadata.baselineGitHead,
+      changedFiles: [],
+      verificationRuns: metadata.verificationRuns,
+      warnings: [MISSING_BASELINE_WARNING]
+    };
+  }
+  if (!await isGitRepository(input.workspacePath)) {
+    return {
+      sessionId: metadata.sessionId,
+      workspaceId: metadata.workspaceId,
+      baselineGitHead: metadata.baselineGitHead,
+      changedFiles: [],
+      verificationRuns: metadata.verificationRuns,
+      warnings: [NOT_GIT_REPO_WARNING]
+    };
+  }
+  const trackedChanges = await listTrackedChangesSinceBaseline(
+    input.workspacePath,
+    metadata.baselineGitHead
+  );
+  const trackedPaths = new Set(trackedChanges.map((change) => change.path));
+  const untrackedChanges = (await listUntrackedChanges(input.workspacePath)).filter(
+    (change) => !trackedPaths.has(change.path)
+  );
+  return {
+    sessionId: metadata.sessionId,
+    workspaceId: metadata.workspaceId,
+    baselineGitHead: metadata.baselineGitHead,
+    changedFiles: [...trackedChanges, ...untrackedChanges],
+    verificationRuns: metadata.verificationRuns,
+    warnings: []
+  };
+}
+async function getSessionReviewDiff(input) {
+  const metadata = requireSessionMetadata(input.metadataRepo, input.sessionId);
+  if (!metadata.baselineGitHead) {
+    return "";
+  }
+  if (!await isGitRepository(input.workspacePath)) {
+    return "";
+  }
+  if (await isUntrackedPath(input.workspacePath, input.path)) {
+    return (await getFileDiff(input.workspacePath, input.path)).diff;
+  }
+  const { stdout } = await runGit(input.workspacePath, [
+    "diff",
+    metadata.baselineGitHead,
+    "--",
+    input.path
+  ]);
+  return stdout;
+}
+var MISSING_BASELINE_WARNING, NOT_GIT_REPO_WARNING;
+var init_review = __esm({
+  "packages/server/src/session-review/review.ts"() {
+    "use strict";
+    init_cli();
+    init_diff();
+    init_workspace_state();
+    MISSING_BASELINE_WARNING = {
+      code: "missing_baseline",
+      message: "Session baseline is missing."
+    };
+    NOT_GIT_REPO_WARNING = {
+      code: "not_git_repo",
+      message: "Workspace is not a Git repository."
+    };
+  }
+});
+
+// packages/server/src/commands/session-review.ts
+import { z as z15 } from "zod";
+function requireSessionMetadataRepo2(ctx) {
+  if (!ctx.sessionMetadataRepo) {
+    throw {
+      code: "session_metadata_unavailable",
+      message: "Session metadata repository is not configured"
+    };
+  }
+}
+function requireWorkspace(ctx, workspaceId) {
+  const workspace = ctx.workspaceMgr.get(workspaceId);
+  if (!workspace) {
+    throw { code: "workspace_not_found", message: `Workspace not found: ${workspaceId}` };
+  }
+  return workspace;
+}
+var init_session_review = __esm({
+  "packages/server/src/commands/session-review.ts"() {
+    "use strict";
+    init_review();
+    init_dispatch();
+    registerCommand(
+      "sessionReview.summary",
+      z15.object({
+        sessionId: z15.string()
+      }),
+      async (args, ctx) => {
+        requireSessionMetadataRepo2(ctx);
+        const metadata = ctx.sessionMetadataRepo.get(args.sessionId);
+        if (!metadata) {
+          throw {
+            code: "session_metadata_not_found",
+            message: `Session metadata not found: ${args.sessionId}`
+          };
+        }
+        const workspace = requireWorkspace(ctx, metadata.workspaceId);
+        return buildSessionReviewSummary({
+          sessionId: args.sessionId,
+          workspacePath: workspace.path,
+          metadataRepo: ctx.sessionMetadataRepo
+        });
+      }
+    );
+    registerCommand(
+      "sessionReview.diff",
+      z15.object({
+        sessionId: z15.string(),
+        path: z15.string().trim().min(1)
+      }),
+      async (args, ctx) => {
+        requireSessionMetadataRepo2(ctx);
+        const metadata = ctx.sessionMetadataRepo.get(args.sessionId);
+        if (!metadata) {
+          throw {
+            code: "session_metadata_not_found",
+            message: `Session metadata not found: ${args.sessionId}`
+          };
+        }
+        const workspace = requireWorkspace(ctx, metadata.workspaceId);
+        return {
+          path: args.path,
+          diff: await getSessionReviewDiff({
+            sessionId: args.sessionId,
+            workspacePath: workspace.path,
+            metadataRepo: ctx.sessionMetadataRepo,
+            path: args.path
+          })
+        };
+      }
+    );
+  }
+});
+
+// packages/server/src/fs/content-search.ts
+import { spawn as spawn5 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { readdir as readdir4, readFile as readFile7, stat as stat10 } from "fs/promises";
+import { basename as basename2, join as join15, relative as relative3 } from "path";
+import { createInterface } from "readline";
+async function searchFileContents(rootPath, options) {
+  const query = options.query.trim();
+  if (!query) {
+    return {
+      files: [],
+      totalMatchCount: 0,
+      hasMoreFiles: false,
+      truncatedMatchFileCount: 0
+    };
+  }
+  const result = await searchWithRipgrep(rootPath, query, options.maxFiles).catch(
+    async (error) => {
+      if (error.code === "ENOENT") {
+        return searchWithNode(rootPath, query, options.maxFiles);
+      }
+      throw error;
+    }
+  );
+  return finalizeResults(result, options.maxFiles, options.maxMatchesPerFile);
+}
+async function searchWithRipgrep(rootPath, query, maxFiles) {
+  const hasGitignore = existsSync8(join15(rootPath, ".gitignore"));
+  const args = [
+    "--json",
+    "--line-number",
+    "--column",
+    "--fixed-strings",
+    "--sort",
+    "path",
+    "--with-filename",
+    "--glob",
+    "!**/.git/**",
+    "--glob",
+    "!**/node_modules/**"
+  ];
+  if (hasGitignore) {
+    args.push("--hidden");
+    args.push("--no-require-git");
+  }
+  args.push(query, ".");
+  return new Promise((resolve8, reject) => {
+    const child = spawn5("rg", args, { cwd: rootPath, stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = createInterface({ input: child.stdout });
+    const files = /* @__PURE__ */ new Map();
+    let totalMatchCount = 0;
+    let hasMoreFiles = false;
+    let stderr = "";
+    stdout.on("line", (line) => {
+      if (!line.trim()) {
+        return;
+      }
+      const event = JSON.parse(line);
+      if (event.type !== "match") {
+        return;
+      }
+      const rawPath = event.data?.path?.text;
+      if (!rawPath) {
+        return;
+      }
+      const relativePath = normalizeRelativePath(relative3(rootPath, join15(rootPath, rawPath)));
+      const preview = (event.data?.lines?.text ?? "").replace(/\r?\n$/, "");
+      const lineNumber = event.data?.line_number ?? 1;
+      const submatches = event.data?.submatches ?? [];
+      totalMatchCount += submatches.length;
+      if (!files.has(relativePath) && files.size >= maxFiles) {
+        hasMoreFiles = true;
+        return;
+      }
+      for (const submatch of submatches) {
+        pushMatch(files, relativePath, {
+          line: lineNumber,
+          column: byteOffsetToColumn(preview, submatch.start),
+          endColumn: byteOffsetToColumn(preview, submatch.end),
+          preview,
+          previewColumnStart: byteOffsetToColumn(preview, submatch.start),
+          previewColumnEnd: byteOffsetToColumn(preview, submatch.end)
+        });
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      void stdout.close();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      void stdout.close();
+      if (code === 0 || code === 1) {
+        resolve8({
+          files: sortAccumulators(files),
+          totalMatchCount,
+          hasMoreFiles
+        });
+        return;
       }
       reject(
         Object.assign(new Error(stderr || `rg exited with code ${code ?? "unknown"}`), { code })
@@ -15690,7 +16791,7 @@ async function searchWithNode(rootPath, query, maxFiles) {
     const filteredEntries = entries.filter((entry) => filter(entry.name));
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
-      const fullPath = join12(dirPath, entry.name);
+      const fullPath = join15(dirPath, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -15698,11 +16799,11 @@ async function searchWithNode(rootPath, query, maxFiles) {
       if (!entry.isFile()) {
         continue;
       }
-      const fileStat = await stat9(fullPath);
+      const fileStat = await stat10(fullPath);
       if (fileStat.size > FALLBACK_MAX_FILE_BYTES) {
         continue;
       }
-      const buffer = await readFile4(fullPath);
+      const buffer = await readFile7(fullPath);
       if (isBinaryFile(buffer)) {
         continue;
       }
@@ -15813,10 +16914,10 @@ var init_content_search = __esm({
 });
 
 // packages/server/src/fs/tree.ts
-import { readdir as readdir5, stat as stat10 } from "fs/promises";
-import { join as join13, relative as relative4 } from "path";
+import { readdir as readdir5, stat as stat11 } from "fs/promises";
+import { join as join16, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
-  const targetPath = subdir ? join13(rootPath, subdir) : rootPath;
+  const targetPath = subdir ? join16(rootPath, subdir) : rootPath;
   const filter = createTreeVisibilityFilter();
   const entries = await readdir5(targetPath, { withFileTypes: true });
   const nodes = [];
@@ -15824,7 +16925,7 @@ async function readTree(rootPath, subdir) {
     if (!filter(entry.name)) {
       continue;
     }
-    const fullPath = join13(targetPath, entry.name);
+    const fullPath = join16(targetPath, entry.name);
     const relPath = relative4(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
@@ -15835,7 +16936,7 @@ async function readTree(rootPath, subdir) {
         // Not loaded yet - client will request on expand
       });
     } else if (entry.isFile()) {
-      const stats = await stat10(fullPath);
+      const stats = await stat11(fullPath);
       nodes.push({
         name: entry.name,
         path: relPath,
@@ -15868,7 +16969,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     const filteredEntries = entries.filter((entry) => filter(entry.name));
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
-      const fullPath = join13(dirPath, entry.name);
+      const fullPath = join16(dirPath, entry.name);
       const relPath = relative4(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -15904,7 +17005,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     }
     return a.path.toLowerCase().localeCompare(b.path.toLowerCase());
   }).slice(0, limit)) {
-    const stats = await stat10(match.fullPath);
+    const stats = await stat11(match.fullPath);
     files.push({
       name: match.name,
       path: match.path,
@@ -15984,7 +17085,7 @@ var init_tree = __esm({
 });
 
 // packages/server/src/commands/file.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 var init_file = __esm({
   "packages/server/src/commands/file.ts"() {
     "use strict";
@@ -15994,9 +17095,9 @@ var init_file = __esm({
     init_dispatch();
     registerCommand(
       "file.readTree",
-      z13.object({
-        workspaceId: z13.string(),
-        subPath: z13.string().optional()
+      z16.object({
+        workspaceId: z16.string(),
+        subPath: z16.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16008,10 +17109,10 @@ var init_file = __esm({
     );
     registerCommand(
       "file.search",
-      z13.object({
-        workspaceId: z13.string(),
-        query: z13.string(),
-        limit: z13.number().int().positive().max(50).optional()
+      z16.object({
+        workspaceId: z16.string(),
+        query: z16.string(),
+        limit: z16.number().int().positive().max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16023,11 +17124,11 @@ var init_file = __esm({
     );
     registerCommand(
       "file.searchContent",
-      z13.object({
-        workspaceId: z13.string(),
-        query: z13.string(),
-        maxFiles: z13.number().int().positive().max(100),
-        maxMatchesPerFile: z13.number().int().positive().max(100)
+      z16.object({
+        workspaceId: z16.string(),
+        query: z16.string(),
+        maxFiles: z16.number().int().positive().max(100),
+        maxMatchesPerFile: z16.number().int().positive().max(100)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16043,9 +17144,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.read",
-      z13.object({
-        workspaceId: z13.string(),
-        path: z13.string()
+      z16.object({
+        workspaceId: z16.string(),
+        path: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16057,9 +17158,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.create",
-      z13.object({
-        workspaceId: z13.string(),
-        path: z13.string()
+      z16.object({
+        workspaceId: z16.string(),
+        path: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16077,9 +17178,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.mkdir",
-      z13.object({
-        workspaceId: z13.string(),
-        path: z13.string()
+      z16.object({
+        workspaceId: z16.string(),
+        path: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16097,9 +17198,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.delete",
-      z13.object({
-        workspaceId: z13.string(),
-        path: z13.string()
+      z16.object({
+        workspaceId: z16.string(),
+        path: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16117,10 +17218,10 @@ var init_file = __esm({
     );
     registerCommand(
       "file.rename",
-      z13.object({
-        workspaceId: z13.string(),
-        fromPath: z13.string(),
-        toPath: z13.string()
+      z16.object({
+        workspaceId: z16.string(),
+        fromPath: z16.string(),
+        toPath: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16138,167 +17239,27 @@ var init_file = __esm({
     );
     registerCommand(
       "file.write",
-      z13.object({
-        workspaceId: z13.string(),
-        path: z13.string(),
-        content: z13.string(),
-        baseHash: z13.string().optional()
+      z16.object({
+        workspaceId: z16.string(),
+        path: z16.string(),
+        content: z16.string(),
+        baseHash: z16.string().optional()
         // For conflict detection
       }),
-      async (args, ctx) => {
-        const workspace = ctx.workspaceMgr.get(args.workspaceId);
-        if (!workspace) {
-          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
-        }
-        const result = await writeFile(workspace.path, args.path, args.content, args.baseHash);
-        ctx.eventBus.emit({
-          type: "fs.dirty",
-          workspaceId: args.workspaceId,
-          reason: "file_content"
-        });
-        return result;
-      }
-    );
-  }
-});
-
-// packages/server/src/git/diff.ts
-import { mkdtemp as mkdtemp3, readFile as readFile5, rm as rm7 } from "fs/promises";
-import os3 from "os";
-import path11 from "path";
-async function isTrackedPath(cwd, filePath) {
-  try {
-    await runGit(cwd, ["ls-files", "--error-unmatch", "--", filePath]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getUntrackedFileDiff(cwd, filePath) {
-  const tempDir = await mkdtemp3(path11.join(os3.tmpdir(), "coder-studio-git-diff-"));
-  const tempIndex = path11.join(tempDir, "index");
-  try {
-    try {
-      await runGit(cwd, ["read-tree", "HEAD"], {
-        env: { GIT_INDEX_FILE: tempIndex }
-      });
-    } catch (error) {
-      if (!(error instanceof GitError)) {
-        throw error;
-      }
-      await runGit(cwd, ["read-tree", "--empty"], {
-        env: { GIT_INDEX_FILE: tempIndex }
-      });
-    }
-    await runGit(cwd, ["add", "-N", "--", filePath], {
-      env: { GIT_INDEX_FILE: tempIndex }
-    });
-    const result = await runGit(cwd, ["diff", "--", filePath], {
-      env: { GIT_INDEX_FILE: tempIndex }
-    });
-    return result.stdout;
-  } finally {
-    await rm7(tempDir, { recursive: true, force: true });
-  }
-}
-async function pathExists(cwd, filePath) {
-  try {
-    await readFile5(resolveSafe(cwd, filePath));
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readTextAtRevision(cwd, revision, filePath) {
-  if (revision === "WORKTREE") {
-    return readFile5(resolveSafe(cwd, filePath), "utf-8");
-  }
-  try {
-    const gitSpec = revision === "INDEX" ? `:${filePath}` : `${revision}:${filePath}`;
-    const result = await runGit(cwd, ["show", gitSpec]);
-    return result.stdout;
-  } catch {
-    return "";
-  }
-}
-async function deriveFileDiffStatus(cwd, filePath, staged) {
-  const tracked = await isTrackedPath(cwd, filePath);
-  const existsOnDisk = await pathExists(cwd, filePath);
-  if (!staged && !tracked) {
-    return "added";
-  }
-  if (staged) {
-    try {
-      await runGit(cwd, ["cat-file", "-e", `HEAD:${filePath}`]);
-      return existsOnDisk ? "modified" : "deleted";
-    } catch {
-      return "added";
-    }
-  }
-  return existsOnDisk ? "modified" : "deleted";
-}
-async function buildTextDiffResult(cwd, filePath, staged, diff) {
-  const status = await deriveFileDiffStatus(cwd, filePath, staged);
-  if (status === "added") {
-    return {
-      diff,
-      renderAs: "text",
-      status,
-      originalContent: "",
-      modifiedContent: await readTextAtRevision(cwd, staged ? "INDEX" : "WORKTREE", filePath)
-    };
-  }
-  if (status === "deleted") {
-    return {
-      diff,
-      renderAs: "text",
-      status,
-      originalContent: await readTextAtRevision(cwd, staged ? "HEAD" : "INDEX", filePath),
-      modifiedContent: ""
-    };
-  }
-  return {
-    diff,
-    renderAs: "text",
-    status,
-    originalContent: await readTextAtRevision(cwd, staged ? "HEAD" : "INDEX", filePath),
-    modifiedContent: await readTextAtRevision(cwd, staged ? "INDEX" : "WORKTREE", filePath)
-  };
-}
-async function getFileDiff(cwd, path14, staged = false) {
-  const imageType = getImageTypeInfo(path14);
-  if (!staged && !await isTrackedPath(cwd, path14)) {
-    const diff = await getUntrackedFileDiff(cwd, path14);
-    if (imageType) {
-      return {
-        diff,
-        renderAs: "image",
-        status: "added",
-        originalRevision: "HEAD",
-        modifiedRevision: "WORKTREE"
-      };
-    }
-    return buildTextDiffResult(cwd, path14, staged, diff);
-  }
-  const args = staged ? ["diff", "--staged", "--", path14] : ["diff", "--", path14];
-  const result = await runGit(cwd, args);
-  if (imageType && /Binary files .* differ/.test(result.stdout)) {
-    return {
-      diff: result.stdout,
-      renderAs: "image",
-      status: await deriveFileDiffStatus(cwd, path14, staged),
-      originalRevision: staged ? "HEAD" : "INDEX",
-      modifiedRevision: staged ? "INDEX" : "WORKTREE"
-    };
-  }
-  return buildTextDiffResult(cwd, path14, staged, result.stdout);
-}
-var init_diff = __esm({
-  "packages/server/src/git/diff.ts"() {
-    "use strict";
-    init_file_io();
-    init_image();
-    init_cli();
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        const result = await writeFile(workspace.path, args.path, args.content, args.baseHash);
+        ctx.eventBus.emit({
+          type: "fs.dirty",
+          workspaceId: args.workspaceId,
+          reason: "file_content"
+        });
+        return result;
+      }
+    );
   }
 });
 
@@ -16319,7 +17280,7 @@ var init_git_events = __esm({
 });
 
 // packages/server/src/commands/git.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 async function runGitNetworkOperation(ctx, workspaceId, op) {
   if (!ctx.autoFetch?.runExclusive) {
     return op();
@@ -16334,16 +17295,16 @@ var init_git2 = __esm({
     init_diff();
     init_dispatch();
     init_git_events();
-    gitHttpAuthSchema = z14.object({
-      username: z14.string(),
-      password: z14.string()
+    gitHttpAuthSchema = z17.object({
+      username: z17.string(),
+      password: z17.string()
     });
-    gitCommitRevisionSchema = z14.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
+    gitCommitRevisionSchema = z17.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
     GIT_BACKGROUND_FETCH_TIMEOUT_MS = 30 * 1e3;
     registerCommand(
       "git.status",
-      z14.object({
-        workspaceId: z14.string()
+      z17.object({
+        workspaceId: z17.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16355,9 +17316,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.stage",
-      z14.object({
-        workspaceId: z14.string(),
-        paths: z14.array(z14.string())
+      z17.object({
+        workspaceId: z17.string(),
+        paths: z17.array(z17.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16371,10 +17332,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.diff",
-      z14.object({
-        workspaceId: z14.string(),
-        path: z14.string(),
-        staged: z14.boolean().optional()
+      z17.object({
+        workspaceId: z17.string(),
+        path: z17.string(),
+        staged: z17.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16386,9 +17347,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.log",
-      z14.object({
-        workspaceId: z14.string(),
-        limit: z14.number().int().min(1).max(50).optional()
+      z17.object({
+        workspaceId: z17.string(),
+        limit: z17.number().int().min(1).max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16402,8 +17363,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.show",
-      z14.object({
-        workspaceId: z14.string(),
+      z17.object({
+        workspaceId: z17.string(),
         sha: gitCommitRevisionSchema
       }),
       async (args, ctx) => {
@@ -16418,9 +17379,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.unstage",
-      z14.object({
-        workspaceId: z14.string(),
-        paths: z14.array(z14.string())
+      z17.object({
+        workspaceId: z17.string(),
+        paths: z17.array(z17.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16434,9 +17395,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.discard",
-      z14.object({
-        workspaceId: z14.string(),
-        paths: z14.array(z14.string())
+      z17.object({
+        workspaceId: z17.string(),
+        paths: z17.array(z17.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16452,9 +17413,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.commit",
-      z14.object({
-        workspaceId: z14.string(),
-        message: z14.string()
+      z17.object({
+        workspaceId: z17.string(),
+        message: z17.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -16471,11 +17432,11 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.push",
-      z14.object({
-        workspaceId: z14.string(),
-        remote: z14.string().optional(),
-        branch: z14.string().optional(),
-        force: z14.boolean().optional(),
+      z17.object({
+        workspaceId: z17.string(),
+        remote: z17.string().optional(),
+        branch: z17.string().optional(),
+        force: z17.boolean().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -16501,128 +17462,737 @@ var init_git2 = __esm({
       }
     );
     registerCommand(
-      "git.pull",
-      z14.object({
-        workspaceId: z14.string(),
-        remote: z14.string().optional(),
-        branch: z14.string().optional(),
-        auth: gitHttpAuthSchema.optional()
+      "git.pull",
+      z17.object({
+        workspaceId: z17.string(),
+        remote: z17.string().optional(),
+        branch: z17.string().optional(),
+        auth: gitHttpAuthSchema.optional()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        const result = await runGitNetworkOperation(
+          ctx,
+          args.workspaceId,
+          () => runGitPull(workspace.path, {
+            remote: args.remote,
+            branch: args.branch,
+            auth: args.auth
+          })
+        );
+        ctx.workspaceMgr.recordFetch(args.workspaceId);
+        emitGitStateChanged(ctx, args.workspaceId, {
+          treeChanged: true,
+          branchChanged: true,
+          worktreeChanged: true
+        });
+        return result;
+      }
+    );
+    registerCommand(
+      "git.fetch",
+      z17.object({
+        workspaceId: z17.string(),
+        remote: z17.string().optional(),
+        prune: z17.boolean().optional(),
+        auth: gitHttpAuthSchema.optional(),
+        background: z17.boolean().optional()
+      }),
+      async (args, ctx, clientId) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        try {
+          const isInternalBackgroundFetch = args.background === true && !clientId;
+          const runFetch = () => runGitFetch(workspace.path, {
+            remote: args.remote,
+            prune: args.prune,
+            auth: args.auth,
+            timeoutMs: args.background ? GIT_BACKGROUND_FETCH_TIMEOUT_MS : void 0
+          });
+          const result = isInternalBackgroundFetch ? await runFetch() : await runGitNetworkOperation(ctx, args.workspaceId, runFetch);
+          ctx.workspaceMgr.recordFetch(args.workspaceId);
+          emitGitStateChanged(ctx, args.workspaceId, { branchChanged: true });
+          return result;
+        } catch (err) {
+          if (args.background && err instanceof GitAuthError) {
+            return { success: false, message: err.message, updatedRefs: [] };
+          }
+          throw err;
+        }
+      }
+    );
+    registerCommand(
+      "git.checkout",
+      z17.object({
+        workspaceId: z17.string(),
+        ref: z17.string(),
+        createBranch: z17.boolean().optional()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        const result = await runGitCheckout(workspace.path, args.ref, {
+          createBranch: args.createBranch
+        });
+        if (result.success) {
+          emitGitStateChanged(ctx, args.workspaceId, {
+            treeChanged: true,
+            branchChanged: true,
+            worktreeChanged: true
+          });
+        }
+        return result;
+      }
+    );
+    registerCommand(
+      "git.branch",
+      z17.object({
+        workspaceId: z17.string(),
+        name: z17.string(),
+        startPoint: z17.string().optional()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        const result = await runGitCreateBranch(workspace.path, args.name, {
+          startPoint: args.startPoint
+        });
+        emitGitStateChanged(ctx, args.workspaceId, {
+          branchChanged: true,
+          worktreeChanged: true
+        });
+        return result;
+      }
+    );
+    registerCommand(
+      "git.branches",
+      z17.object({
+        workspaceId: z17.string()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return runGitListBranches(workspace.path);
+      }
+    );
+  }
+});
+
+// packages/server/src/agent-instructions/generator.ts
+function buildAgentInstructionsMarkdown(summary) {
+  const lines = ["# Agent Instructions", ""];
+  pushSection(lines, "Project Overview", buildProjectOverview(summary));
+  pushSection(lines, "Development Commands", buildDevelopmentCommands(summary));
+  pushSection(lines, "Working Rules", [...WORKING_RULES.map((rule) => `- ${rule}`)]);
+  pushSection(
+    lines,
+    "Review Expectations",
+    REVIEW_EXPECTATIONS.map((rule) => `- ${rule}`)
+  );
+  pushSection(
+    lines,
+    "Provider Notes",
+    PROVIDER_NOTES.map((note) => `- ${note}`)
+  );
+  return lines.join("\n");
+}
+function buildProjectOverview(summary) {
+  const lines = [];
+  if (summary.git.isRepo) {
+    if (summary.git.branch) {
+      lines.push(`- Git branch: ${summary.git.branch}`);
+    } else {
+      lines.push("- Git repository: yes");
+    }
+  } else {
+    lines.push("- Git repository: no");
+  }
+  if (summary.packageManager) {
+    lines.push(`- Package manager: ${summary.packageManager}`);
+  }
+  if (summary.frameworks.length > 0) {
+    lines.push(`- Frameworks: ${summary.frameworks.join(", ")}`);
+  }
+  if (summary.docs.length > 0) {
+    lines.push(`- Docs: ${summary.docs.map((doc) => doc.path).join(", ")}`);
+  }
+  lines.push(
+    `- ${summary.agentInstructions.path}: ${summary.agentInstructions.exists ? "exists" : "missing"}`
+  );
+  return lines;
+}
+function buildDevelopmentCommands(summary) {
+  const lines = [];
+  const commandLabels = {
+    dev: "Dev",
+    test: "Test",
+    build: "Build",
+    lint: "Lint"
+  };
+  for (const key of ["dev", "test", "build", "lint"]) {
+    const command = summary.recommendedCommands.find((item) => item.key === key)?.command;
+    if (!command) {
+      continue;
+    }
+    lines.push(`- ${commandLabels[key]}: \`${command}\``);
+  }
+  return lines;
+}
+function pushSection(lines, heading, body) {
+  lines.push(`## ${heading}`, "");
+  lines.push(...body);
+  lines.push("");
+}
+var WORKING_RULES, REVIEW_EXPECTATIONS, PROVIDER_NOTES;
+var init_generator = __esm({
+  "packages/server/src/agent-instructions/generator.ts"() {
+    "use strict";
+    WORKING_RULES = [
+      "Keep changes focused on the requested task.",
+      "Do not revert user changes unless explicitly asked.",
+      "Prefer the project's existing patterns.",
+      "Run the relevant verification command before reporting completion."
+    ];
+    REVIEW_EXPECTATIONS = [
+      "Summarize changed files.",
+      "Report verification commands and results.",
+      "Call out risks, skipped tests, and assumptions."
+    ];
+    PROVIDER_NOTES = [
+      "Claude Code: use the project rules above.",
+      "Codex: use the project rules above."
+    ];
+  }
+});
+
+// packages/server/src/agent-instructions/health.ts
+function evaluateAgentInstructionsMarkdown(content) {
+  if (!content.trim()) {
+    return {
+      path: AGENT_INSTRUCTIONS_RELATIVE_PATH,
+      exists: false,
+      status: "missing",
+      checks: {
+        projectOverview: false,
+        developmentCommands: false,
+        workingRules: false,
+        reviewExpectations: false,
+        safetyRules: false,
+        providerNotes: false
+      },
+      issues: [
+        {
+          code: "missing_document",
+          message: `${AGENT_INSTRUCTIONS_RELATIVE_PATH} is missing`
+        }
+      ]
+    };
+  }
+  const sections = indexSections(content);
+  const projectOverview = sections.has("Project Overview");
+  const developmentCommands = hasAnyBullet(sections.get("Development Commands"));
+  const workingRulesSection = sections.get("Working Rules");
+  const reviewExpectationsSection = sections.get("Review Expectations");
+  const providerNotesSection = sections.get("Provider Notes");
+  const workingRules = hasAnyBullet(workingRulesSection);
+  const reviewExpectations = hasAnyBullet(reviewExpectationsSection) && REQUIRED_REVIEW_EXPECTATIONS.every(
+    (rule) => reviewExpectationsSection?.some((line) => line.includes(rule))
+  );
+  const providerNotes = hasAnyBullet(providerNotesSection) && PROVIDER_NOTE_MARKERS.some(
+    (marker) => providerNotesSection?.some((line) => line.includes(marker))
+  );
+  const safetyRules = REQUIRED_WORKING_RULES.every(
+    (rule) => workingRulesSection?.some((line) => line.includes(rule))
+  );
+  const issues = [];
+  if (!projectOverview) {
+    issues.push({
+      code: "missing_project_overview",
+      message: "Project Overview section is missing"
+    });
+  }
+  if (!developmentCommands) {
+    issues.push({
+      code: "missing_development_commands",
+      message: "Development Commands section is missing"
+    });
+  }
+  if (!workingRules) {
+    issues.push({
+      code: "missing_working_rules",
+      message: "Working Rules section is missing"
+    });
+  }
+  if (!reviewExpectations) {
+    issues.push({
+      code: "missing_review_expectations",
+      message: "Review Expectations section is missing"
+    });
+  }
+  if (!safetyRules) {
+    issues.push({
+      code: "missing_safety_rules",
+      message: "Working rules do not include the required safety rules"
+    });
+  }
+  if (!providerNotes) {
+    issues.push({
+      code: "missing_provider_notes",
+      message: "Provider Notes section is missing"
+    });
+  }
+  const status = issues.length === 0 ? "healthy" : "warning";
+  return {
+    path: AGENT_INSTRUCTIONS_RELATIVE_PATH,
+    exists: true,
+    status,
+    checks: {
+      projectOverview,
+      developmentCommands,
+      workingRules,
+      reviewExpectations,
+      safetyRules,
+      providerNotes
+    },
+    issues
+  };
+}
+function indexSections(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = content.split(/\r?\n/);
+  let currentHeading = null;
+  for (const line of lines) {
+    const heading = line.match(/^##\s+(.+?)\s*$/)?.[1];
+    if (heading) {
+      currentHeading = heading;
+      if (!sections.has(heading)) {
+        sections.set(heading, []);
+      }
+      continue;
+    }
+    if (currentHeading) {
+      sections.get(currentHeading)?.push(line);
+    }
+  }
+  return sections;
+}
+function hasAnyBullet(lines) {
+  return Boolean(lines?.some((line) => line.trimStart().startsWith("- ")));
+}
+var REQUIRED_WORKING_RULES, REQUIRED_REVIEW_EXPECTATIONS, PROVIDER_NOTE_MARKERS;
+var init_health = __esm({
+  "packages/server/src/agent-instructions/health.ts"() {
+    "use strict";
+    init_workspace_state();
+    REQUIRED_WORKING_RULES = [
+      "Keep changes focused on the requested task.",
+      "Do not revert user changes unless explicitly asked.",
+      "Prefer the project's existing patterns.",
+      "Run the relevant verification command before reporting completion."
+    ];
+    REQUIRED_REVIEW_EXPECTATIONS = [
+      "Summarize changed files.",
+      "Report verification commands and results.",
+      "Call out risks, skipped tests, and assumptions."
+    ];
+    PROVIDER_NOTE_MARKERS = ["Claude Code:", "Codex:"];
+  }
+});
+
+// packages/server/src/commands/agent-instructions.ts
+import { z as z18 } from "zod";
+async function readAgentInstructionsDocument(workspaceId, rootPath) {
+  const path14 = AGENT_INSTRUCTIONS_RELATIVE_PATH;
+  try {
+    const result = await readFile(workspaceId, rootPath, path14);
+    if (result.kind !== "text") {
+      return {
+        path: path14,
+        exists: true,
+        content: ""
+      };
+    }
+    return {
+      path: path14,
+      exists: true,
+      content: result.content,
+      baseHash: result.baseHash
+    };
+  } catch {
+    return {
+      path: path14,
+      exists: false,
+      content: ""
+    };
+  }
+}
+var init_agent_instructions = __esm({
+  "packages/server/src/commands/agent-instructions.ts"() {
+    "use strict";
+    init_generator();
+    init_health();
+    init_file_io();
+    init_intelligence();
+    init_workspace_state();
+    init_dispatch();
+    registerCommand(
+      "agentInstructions.read",
+      z18.object({
+        workspaceId: z18.string()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return readAgentInstructionsDocument(workspace.id, workspace.path);
+      }
+    );
+    registerCommand(
+      "agentInstructions.generate",
+      z18.object({
+        workspaceId: z18.string()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        const summary = await inspectWorkspaceIntelligence({
+          workspaceId: workspace.id,
+          rootPath: workspace.path
+        });
+        return {
+          path: AGENT_INSTRUCTIONS_RELATIVE_PATH,
+          exists: false,
+          content: buildAgentInstructionsMarkdown(summary)
+        };
+      }
+    );
+    registerCommand(
+      "agentInstructions.write",
+      z18.object({
+        workspaceId: z18.string(),
+        content: z18.string(),
+        overwrite: z18.boolean().optional(),
+        baseHash: z18.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
-        const result = await runGitNetworkOperation(
-          ctx,
-          args.workspaceId,
-          () => runGitPull(workspace.path, {
-            remote: args.remote,
-            branch: args.branch,
-            auth: args.auth
-          })
+        const existing = await readAgentInstructionsDocument(workspace.id, workspace.path);
+        if (existing.exists && !args.overwrite) {
+          throw {
+            code: "agent_instructions_exists",
+            message: `${AGENT_INSTRUCTIONS_RELATIVE_PATH} already exists`
+          };
+        }
+        const result = await writeFile(
+          workspace.path,
+          AGENT_INSTRUCTIONS_RELATIVE_PATH,
+          args.content,
+          args.baseHash
         );
-        ctx.workspaceMgr.recordFetch(args.workspaceId);
-        emitGitStateChanged(ctx, args.workspaceId, {
-          treeChanged: true,
-          branchChanged: true,
-          worktreeChanged: true
+        ctx.eventBus.emit({
+          type: "fs.dirty",
+          workspaceId: args.workspaceId,
+          reason: "file_content"
         });
-        return result;
+        return {
+          path: AGENT_INSTRUCTIONS_RELATIVE_PATH,
+          exists: true,
+          content: args.content,
+          baseHash: result.newHash
+        };
       }
     );
     registerCommand(
-      "git.fetch",
-      z14.object({
-        workspaceId: z14.string(),
-        remote: z14.string().optional(),
-        prune: z14.boolean().optional(),
-        auth: gitHttpAuthSchema.optional(),
-        background: z14.boolean().optional()
+      "agentInstructions.health",
+      z18.object({
+        workspaceId: z18.string()
       }),
-      async (args, ctx, clientId) => {
+      async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
-        try {
-          const isInternalBackgroundFetch = args.background === true && !clientId;
-          const runFetch = () => runGitFetch(workspace.path, {
-            remote: args.remote,
-            prune: args.prune,
-            auth: args.auth,
-            timeoutMs: args.background ? GIT_BACKGROUND_FETCH_TIMEOUT_MS : void 0
-          });
-          const result = isInternalBackgroundFetch ? await runFetch() : await runGitNetworkOperation(ctx, args.workspaceId, runFetch);
-          ctx.workspaceMgr.recordFetch(args.workspaceId);
-          emitGitStateChanged(ctx, args.workspaceId, { branchChanged: true });
-          return result;
-        } catch (err) {
-          if (args.background && err instanceof GitAuthError) {
-            return { success: false, message: err.message, updatedRefs: [] };
-          }
-          throw err;
-        }
+        const document = await readAgentInstructionsDocument(workspace.id, workspace.path);
+        return evaluateAgentInstructionsMarkdown(document.content);
       }
     );
+  }
+});
+
+// packages/server/src/agent-context/context-package.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { readFile as readFile8 } from "node:fs/promises";
+function resolveOptions(options) {
+  return {
+    createId: options?.createId ?? randomUUID7,
+    now: options?.now ?? Date.now
+  };
+}
+function formatSource(source) {
+  const parts = [`workspace=${source.workspaceId}`];
+  if (source.sessionId) {
+    parts.push(`session=${source.sessionId}`);
+  }
+  if (source.path) {
+    parts.push(`path=${source.path}`);
+  }
+  if (source.terminalId) {
+    parts.push(`terminal=${source.terminalId}`);
+  }
+  return parts.join(" ");
+}
+function wrapContext(title, source, body) {
+  return `Context: ${title}
+Source: ${formatSource(source)}
+
+${body}`;
+}
+function createContextPackage(kind, title, source, body, options) {
+  const resolved = resolveOptions(options);
+  return {
+    id: resolved.createId(),
+    kind,
+    title,
+    body: wrapContext(title, source, body),
+    source,
+    createdAt: resolved.now()
+  };
+}
+function requireSessionMetadata2(metadataRepo, sessionId) {
+  const metadata = metadataRepo.get(sessionId);
+  if (!metadata) {
+    throw {
+      code: "session_metadata_not_found",
+      message: `Session metadata not found: ${sessionId}`
+    };
+  }
+  return metadata;
+}
+function buildProjectSummaryBody(summary) {
+  const lines = [
+    `Git: ${summary.git.isRepo ? "repository detected" : "no repository detected"}`,
+    `Package manager: ${summary.packageManager ?? "unknown"}`,
+    `Frameworks: ${summary.frameworks.length > 0 ? summary.frameworks.join(", ") : "none"}`
+  ];
+  if (summary.recommendedCommands.length > 0) {
+    lines.push("Recommended commands:");
+    for (const command of summary.recommendedCommands) {
+      lines.push(`- ${command.key}: ${command.command}`);
+    }
+  } else {
+    lines.push("Recommended commands: none");
+  }
+  if (summary.docs.length > 0) {
+    lines.push("Docs:");
+    for (const doc of summary.docs) {
+      lines.push(`- ${doc.path}`);
+    }
+  } else {
+    lines.push("Docs: none");
+  }
+  lines.push(
+    `Agent instructions: ${summary.agentInstructions.path} ${summary.agentInstructions.exists ? "present" : "missing"}`
+  );
+  return lines.join("\n");
+}
+async function buildFileContextPackage(input, options) {
+  const content = await readFile8(resolveSafe(input.workspacePath, input.path), "utf8");
+  return createContextPackage(
+    "file",
+    `File: ${input.path}`,
+    {
+      workspaceId: input.workspaceId,
+      path: input.path
+    },
+    content,
+    options
+  );
+}
+async function buildDiffContextPackage(input, options) {
+  const metadata = requireSessionMetadata2(input.metadataRepo, input.sessionId);
+  const diff = await getSessionReviewDiff({
+    sessionId: input.sessionId,
+    workspacePath: input.workspacePath,
+    metadataRepo: input.metadataRepo,
+    path: input.path
+  });
+  return createContextPackage(
+    "git_diff",
+    `Git Diff: ${input.path}`,
+    {
+      workspaceId: metadata.workspaceId,
+      sessionId: input.sessionId,
+      path: input.path
+    },
+    diff,
+    options
+  );
+}
+async function buildProjectSummaryContextPackage(input, options) {
+  const summary = await inspectWorkspaceIntelligence({
+    workspaceId: input.workspaceId,
+    rootPath: input.workspacePath
+  });
+  return createContextPackage(
+    "project_summary",
+    "Project Summary",
+    {
+      workspaceId: input.workspaceId
+    },
+    buildProjectSummaryBody(summary),
+    options
+  );
+}
+async function buildSessionReviewContextPackage(input, options) {
+  const metadata = requireSessionMetadata2(input.metadataRepo, input.sessionId);
+  const summary = await buildSessionReviewSummary({
+    sessionId: input.sessionId,
+    workspacePath: input.workspacePath,
+    metadataRepo: input.metadataRepo
+  });
+  const lines = [
+    `Baseline: ${summary.baselineGitHead ?? "missing"}`,
+    "Changed files:",
+    ...summary.changedFiles.length > 0 ? summary.changedFiles.map((change) => `- ${change.status ?? "modified"}: ${change.path}`) : ["- none"],
+    "Verification runs:",
+    ...summary.verificationRuns.length > 0 ? summary.verificationRuns.map((run) => `- ${run.status}: ${run.command}`) : ["- none"]
+  ];
+  if (summary.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const warning of summary.warnings) {
+      lines.push(`- ${warning.code}: ${warning.message}`);
+    }
+  }
+  return createContextPackage(
+    "session_review",
+    `Session Review: ${summary.sessionId}`,
+    {
+      workspaceId: metadata.workspaceId,
+      sessionId: input.sessionId
+    },
+    lines.join("\n"),
+    options
+  );
+}
+var init_context_package = __esm({
+  "packages/server/src/agent-context/context-package.ts"() {
+    "use strict";
+    init_file_io();
+    init_review();
+    init_intelligence();
+  }
+});
+
+// packages/server/src/commands/agent-context.ts
+import { z as z19 } from "zod";
+function requireWorkspace2(ctx, workspaceId) {
+  const workspace = ctx.workspaceMgr.get(workspaceId);
+  if (!workspace) {
+    throw { code: "workspace_not_found", message: `Workspace not found: ${workspaceId}` };
+  }
+  return workspace;
+}
+function requireSessionMetadataRepo3(ctx) {
+  if (!ctx.sessionMetadataRepo) {
+    throw {
+      code: "session_metadata_unavailable",
+      message: "Session metadata repository is not configured"
+    };
+  }
+}
+function getSessionWorkspace(ctx, sessionId) {
+  const metadata = ctx.sessionMetadataRepo.get(sessionId);
+  if (!metadata) {
+    throw {
+      code: "session_metadata_not_found",
+      message: `Session metadata not found: ${sessionId}`
+    };
+  }
+  return {
+    metadata,
+    workspace: requireWorkspace2(ctx, metadata.workspaceId)
+  };
+}
+var init_agent_context = __esm({
+  "packages/server/src/commands/agent-context.ts"() {
+    "use strict";
+    init_context_package();
+    init_dispatch();
     registerCommand(
-      "git.checkout",
-      z14.object({
-        workspaceId: z14.string(),
-        ref: z14.string(),
-        createBranch: z14.boolean().optional()
+      "agentContext.fromFile",
+      z19.object({
+        workspaceId: z19.string(),
+        path: z19.string().trim().min(1)
       }),
       async (args, ctx) => {
-        const workspace = ctx.workspaceMgr.get(args.workspaceId);
-        if (!workspace) {
-          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
-        }
-        const result = await runGitCheckout(workspace.path, args.ref, {
-          createBranch: args.createBranch
+        const workspace = requireWorkspace2(ctx, args.workspaceId);
+        return buildFileContextPackage({
+          workspaceId: workspace.id,
+          workspacePath: workspace.path,
+          path: args.path
         });
-        if (result.success) {
-          emitGitStateChanged(ctx, args.workspaceId, {
-            treeChanged: true,
-            branchChanged: true,
-            worktreeChanged: true
-          });
-        }
-        return result;
       }
     );
     registerCommand(
-      "git.branch",
-      z14.object({
-        workspaceId: z14.string(),
-        name: z14.string(),
-        startPoint: z14.string().optional()
+      "agentContext.fromDiff",
+      z19.object({
+        sessionId: z19.string(),
+        path: z19.string().trim().min(1)
       }),
       async (args, ctx) => {
-        const workspace = ctx.workspaceMgr.get(args.workspaceId);
-        if (!workspace) {
-          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
-        }
-        const result = await runGitCreateBranch(workspace.path, args.name, {
-          startPoint: args.startPoint
+        requireSessionMetadataRepo3(ctx);
+        const { workspace } = getSessionWorkspace(ctx, args.sessionId);
+        return buildDiffContextPackage({
+          sessionId: args.sessionId,
+          path: args.path,
+          workspacePath: workspace.path,
+          metadataRepo: ctx.sessionMetadataRepo
         });
-        emitGitStateChanged(ctx, args.workspaceId, {
-          branchChanged: true,
-          worktreeChanged: true
+      }
+    );
+    registerCommand(
+      "agentContext.fromProjectSummary",
+      z19.object({
+        workspaceId: z19.string()
+      }),
+      async (args, ctx) => {
+        const workspace = requireWorkspace2(ctx, args.workspaceId);
+        return buildProjectSummaryContextPackage({
+          workspaceId: workspace.id,
+          workspacePath: workspace.path
         });
-        return result;
       }
     );
     registerCommand(
-      "git.branches",
-      z14.object({
-        workspaceId: z14.string()
+      "agentContext.fromSessionReview",
+      z19.object({
+        sessionId: z19.string()
       }),
       async (args, ctx) => {
-        const workspace = ctx.workspaceMgr.get(args.workspaceId);
-        if (!workspace) {
-          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
-        }
-        return runGitListBranches(workspace.path);
+        requireSessionMetadataRepo3(ctx);
+        const { workspace } = getSessionWorkspace(ctx, args.sessionId);
+        return buildSessionReviewContextPackage({
+          sessionId: args.sessionId,
+          workspacePath: workspace.path,
+          metadataRepo: ctx.sessionMetadataRepo
+        });
       }
     );
   }
@@ -16631,25 +18201,25 @@ var init_git2 = __esm({
 // packages/server/src/config/config-io.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname7, join as join14 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join17 } from "node:path";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
     const testHome = process.env.CODER_STUDIO_CODEX_HOME;
     if (testHome && testHome.trim()) {
-      return join14(testHome, "config.toml");
+      return join17(testHome, "config.toml");
     }
     const codexHome = process.env.CODEX_HOME;
     if (codexHome && codexHome.trim()) {
-      return join14(codexHome, "config.toml");
+      return join17(codexHome, "config.toml");
     }
-    return join14(homedir3(), ".codex", "config.toml");
+    return join17(homedir3(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
-      return join14(testHome, "settings.json");
+      return join17(testHome, "settings.json");
     }
-    return join14(homedir3(), ".claude", "settings.json");
+    return join17(homedir3(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
@@ -16694,7 +18264,7 @@ function createBackup(filePath) {
   const base = basename3(filePath, `.${ext}`);
   const dir = dirname7(filePath);
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join14(dir, `${base}.bak.${ts}.${ext}`);
+  const backupPath = join17(dir, `${base}.bak.${ts}.${ext}`);
   writeFileSync5(backupPath, original, "utf-8");
   return backupPath;
 }
@@ -16709,7 +18279,7 @@ var init_config_io = __esm({
 });
 
 // packages/server/src/commands/settings.ts
-import { z as z15 } from "zod";
+import { z as z20 } from "zod";
 function flattenSettings(obj, prefix = "") {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -16760,13 +18330,13 @@ var init_settings2 = __esm({
     init_provider_config();
     init_settings();
     init_dispatch();
-    PersonalizationOverridesSchema = z15.object({
-      backgroundAssetId: z15.string().min(1).nullable().optional(),
-      backgroundDimness: z15.number().int().min(0).max(100).optional(),
-      backgroundBlur: z15.number().int().min(0).max(40).optional(),
-      glassEnabled: z15.boolean().optional(),
-      glassIntensity: z15.number().int().min(0).max(100).optional(),
-      surfaceOpacity: z15.number().int().min(0).max(100).optional()
+    PersonalizationOverridesSchema = z20.object({
+      backgroundAssetId: z20.string().min(1).nullable().optional(),
+      backgroundDimness: z20.number().int().min(0).max(100).optional(),
+      backgroundBlur: z20.number().int().min(0).max(40).optional(),
+      glassEnabled: z20.boolean().optional(),
+      glassIntensity: z20.number().int().min(0).max(100).optional(),
+      surfaceOpacity: z20.number().int().min(0).max(100).optional()
     });
     PERSONALIZATION_OVERRIDE_BRANCHES = ["desktop", "mobile"];
     PERSONALIZATION_OVERRIDE_FIELDS = [
@@ -16777,59 +18347,59 @@ var init_settings2 = __esm({
       "glassIntensity",
       "surfaceOpacity"
     ];
-    SettingsSchema = z15.object({
-      defaultProviderId: z15.string().optional(),
-      notifications: z15.object({
-        enabled: z15.boolean().optional(),
-        soundEnabled: z15.boolean().optional(),
+    SettingsSchema = z20.object({
+      defaultProviderId: z20.string().optional(),
+      notifications: z20.object({
+        enabled: z20.boolean().optional(),
+        soundEnabled: z20.boolean().optional(),
         // Legacy field — accepted for backward compat with older clients but
         // no longer surfaced in the UI. The web client now picks the channel
         // automatically based on workspace focus + page visibility.
-        onlyWhenBackgrounded: z15.boolean().optional()
+        onlyWhenBackgrounded: z20.boolean().optional()
       }).optional(),
-      supervisor: z15.object({
-        evaluationTimeoutSec: z15.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional(),
-        retryEnabled: z15.boolean().optional(),
-        retryMaxCount: z15.number().int().min(0).max(MAX_SUPERVISOR_RETRY_MAX_COUNT).optional(),
-        retryDelaySec: z15.number().int().min(1).max(MAX_SUPERVISOR_RETRY_DELAY_SEC).optional(),
-        retryOnTimeout: z15.boolean().optional(),
-        retryOnEvaluatorError: z15.boolean().optional()
+      supervisor: z20.object({
+        evaluationTimeoutSec: z20.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional(),
+        retryEnabled: z20.boolean().optional(),
+        retryMaxCount: z20.number().int().min(0).max(MAX_SUPERVISOR_RETRY_MAX_COUNT).optional(),
+        retryDelaySec: z20.number().int().min(1).max(MAX_SUPERVISOR_RETRY_DELAY_SEC).optional(),
+        retryOnTimeout: z20.boolean().optional(),
+        retryOnEvaluatorError: z20.boolean().optional()
       }).optional(),
-      appearance: z15.object({
-        theme: z15.enum(["dark", "light"]).optional(),
-        themeId: z15.string().optional(),
-        terminalRenderer: z15.enum(["standard", "compatibility"]).optional(),
-        terminalCopyOnSelect: z15.boolean().optional(),
-        terminalFontSize: z15.number().int().min(10).max(18).optional(),
-        desktopTerminalFontSize: z15.number().int().min(10).max(18).optional(),
-        mobileTerminalFontSize: z15.number().int().min(10).max(18).optional(),
-        locale: z15.enum(["zh", "en"]).optional(),
-        personalization: z15.object({
-          version: z15.literal(1).optional(),
-          common: z15.object({
-            backgroundMode: z15.enum(["none", "image"]).optional(),
-            backgroundAssetId: z15.string().min(1).nullable().optional(),
-            backgroundFit: z15.enum(["cover", "contain"]).optional(),
-            backgroundDimness: z15.number().int().min(0).max(100).optional(),
-            backgroundBlur: z15.number().int().min(0).max(40).optional(),
-            glassEnabled: z15.boolean().optional(),
-            glassIntensity: z15.number().int().min(0).max(100).optional(),
-            surfaceOpacity: z15.number().int().min(0).max(100).optional()
+      appearance: z20.object({
+        theme: z20.enum(["dark", "light"]).optional(),
+        themeId: z20.string().optional(),
+        terminalRenderer: z20.enum(["standard", "compatibility"]).optional(),
+        terminalCopyOnSelect: z20.boolean().optional(),
+        terminalFontSize: z20.number().int().min(10).max(18).optional(),
+        desktopTerminalFontSize: z20.number().int().min(10).max(18).optional(),
+        mobileTerminalFontSize: z20.number().int().min(10).max(18).optional(),
+        locale: z20.enum(["zh", "en"]).optional(),
+        personalization: z20.object({
+          version: z20.literal(1).optional(),
+          common: z20.object({
+            backgroundMode: z20.enum(["none", "image"]).optional(),
+            backgroundAssetId: z20.string().min(1).nullable().optional(),
+            backgroundFit: z20.enum(["cover", "contain"]).optional(),
+            backgroundDimness: z20.number().int().min(0).max(100).optional(),
+            backgroundBlur: z20.number().int().min(0).max(40).optional(),
+            glassEnabled: z20.boolean().optional(),
+            glassIntensity: z20.number().int().min(0).max(100).optional(),
+            surfaceOpacity: z20.number().int().min(0).max(100).optional()
           }).optional(),
           desktop: PersonalizationOverridesSchema.optional(),
           mobile: PersonalizationOverridesSchema.optional()
         }).optional()
       }).optional(),
-      lsp: z15.object({
-        mode: z15.enum(["auto", "off"]).optional()
+      lsp: z20.object({
+        mode: z20.enum(["auto", "off"]).optional()
       }).optional(),
-      updates: z15.object({
-        autoCheckEnabled: z15.boolean().optional(),
-        checkIntervalSec: z15.number().int().refine(isUpdateCheckIntervalSec).optional()
+      updates: z20.object({
+        autoCheckEnabled: z20.boolean().optional(),
+        checkIntervalSec: z20.number().int().refine(isUpdateCheckIntervalSec).optional()
       }).optional(),
       providers: ProviderSettingsSchema.optional()
     });
-    registerCommand("settings.get", z15.object({}), async (_args, ctx) => {
+    registerCommand("settings.get", z20.object({}), async (_args, ctx) => {
       const settings = {};
       for (const [key, value] of Object.entries(ctx.settingsRepo.getAll())) {
         if (key.startsWith("providers.")) {
@@ -16881,7 +18451,7 @@ var init_settings2 = __esm({
     });
     registerCommand(
       "settings.update",
-      z15.object({
+      z20.object({
         settings: SettingsSchema
       }),
       async (args, ctx) => {
@@ -16914,10 +18484,10 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.previewCommand",
-      z15.object({
-        providerId: z15.string(),
+      z20.object({
+        providerId: z20.string(),
         config: ProviderLaunchConfigInputSchema,
-        workspacePath: z15.string().optional()
+        workspacePath: z20.string().optional()
       }),
       async (args, ctx) => {
         const provider = ctx.providerRegistry.find((item) => item.id === args.providerId);
@@ -16938,8 +18508,8 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.readConfigFile",
-      z15.object({
-        configType: z15.enum(["codex", "claude"])
+      z20.object({
+        configType: z20.enum(["codex", "claude"])
       }),
       async (args) => {
         const result = readConfigFile(args.configType);
@@ -16948,9 +18518,9 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.writeConfigFile",
-      z15.object({
-        configType: z15.enum(["codex", "claude"]),
-        content: z15.string()
+      z20.object({
+        configType: z20.enum(["codex", "claude"]),
+        content: z20.string()
       }),
       async (args) => {
         const result = writeConfigFile(args.configType, args.content);
@@ -16961,7 +18531,7 @@ var init_settings2 = __esm({
 });
 
 // packages/server/src/commands/diagnostics.ts
-import { z as z16 } from "zod";
+import { z as z21 } from "zod";
 function isLoopbackHost(host) {
   return host === void 0 || host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0";
 }
@@ -17331,11 +18901,11 @@ var init_diagnostics2 = __esm({
     init_runtime_status();
     init_validator();
     init_dispatch();
-    DiagnosticsRequestSchema = z16.object({
-      context: z16.enum(["workspace_open", "session_start", "mobile_continue", "manual_check"]),
-      workspaceId: z16.string().optional(),
-      workspacePath: z16.string().optional(),
-      providerId: z16.string().optional()
+    DiagnosticsRequestSchema = z21.object({
+      context: z21.enum(["workspace_open", "session_start", "mobile_continue", "manual_check"]),
+      workspaceId: z21.string().optional(),
+      workspacePath: z21.string().optional(),
+      providerId: z21.string().optional()
     });
     registerCommand("diagnostics.get", DiagnosticsRequestSchema, async (args, ctx) => {
       return buildDiagnostics(args, ctx);
@@ -17347,19 +18917,23 @@ var init_diagnostics2 = __esm({
 });
 
 // packages/server/src/commands/provider.ts
-import { z as z17 } from "zod";
+import { z as z22 } from "zod";
 var init_provider = __esm({
   "packages/server/src/commands/provider.ts"() {
     "use strict";
+    init_src();
     init_runtime_status();
     init_dispatch();
-    registerCommand("provider.runtimeStatus", z17.object({}), async (_args, ctx) => {
+    registerCommand("provider.list", z22.object({}), async (_args, ctx) => {
+      return ctx.providerRegistry.map((provider) => toProviderListItem(provider));
+    });
+    registerCommand("provider.runtimeStatus", z22.object({}), async (_args, ctx) => {
       return buildProviderRuntimeStatus(ctx.providerRegistry, ctx.providerRuntimeDeps);
     });
     registerCommand(
       "provider.install.start",
-      z17.object({
-        providerId: z17.string()
+      z22.object({
+        providerId: z22.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -17373,8 +18947,8 @@ var init_provider = __esm({
     );
     registerCommand(
       "provider.install.get",
-      z17.object({
-        jobId: z17.string()
+      z22.object({
+        jobId: z22.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -17396,45 +18970,147 @@ var init_provider = __esm({
   }
 });
 
+// packages/server/src/commands/custom-provider.ts
+import { z as z23 } from "zod";
+function requireCustomProviderSupport(ctx) {
+  if (!ctx.customProviderRepo || !ctx.setProviderRegistry) {
+    throw {
+      code: "custom_provider_unavailable",
+      message: "Custom provider runtime is not configured"
+    };
+  }
+}
+function materializeConfig(input, previous) {
+  const now = Date.now();
+  return {
+    ...input,
+    startupPrompt: input.startupPrompt?.trim() || void 0,
+    createdAt: previous?.createdAt ?? now,
+    updatedAt: now
+  };
+}
+var CapabilitySchema, BaseCustomProviderInputSchema;
+var init_custom_provider2 = __esm({
+  "packages/server/src/commands/custom-provider.ts"() {
+    "use strict";
+    init_src();
+    init_custom_provider();
+    init_dispatch();
+    CapabilitySchema = z23.object({
+      key: z23.enum([
+        "interactive_session",
+        "supervisor_eval",
+        "idle_detection",
+        "context_attach",
+        "review"
+      ]),
+      supported: z23.boolean(),
+      label: z23.string().min(1)
+    });
+    BaseCustomProviderInputSchema = z23.object({
+      id: z23.string().trim().min(1).regex(/^[a-z0-9][a-z0-9-_]*$/),
+      displayName: z23.string().trim().min(1),
+      command: z23.string().trim().min(1),
+      args: z23.array(z23.string()),
+      env: z23.record(z23.string(), z23.string()),
+      cwdMode: z23.literal("workspace_root"),
+      sessionMode: z23.literal("interactive"),
+      startupPrompt: z23.string().optional(),
+      capabilities: z23.array(CapabilitySchema).min(1)
+    });
+    registerCommand("customProvider.list", z23.object({}), async (_args, ctx) => {
+      requireCustomProviderSupport(ctx);
+      return ctx.customProviderRepo.list().map((config) => toProviderListItem(buildCustomProviderDefinition(config)));
+    });
+    registerCommand("customProvider.create", BaseCustomProviderInputSchema, async (args, ctx) => {
+      requireCustomProviderSupport(ctx);
+      if (ctx.providerRegistry.some((provider) => provider.id === args.id)) {
+        throw {
+          code: "custom_provider_exists",
+          message: `Provider already exists: ${args.id}`
+        };
+      }
+      const config = materializeConfig(args);
+      const saved = ctx.customProviderRepo.set(config);
+      const definition = buildCustomProviderDefinition(saved);
+      ctx.setProviderRegistry(upsertProviderDefinition(ctx.providerRegistry, definition));
+      return toProviderListItem(definition);
+    });
+    registerCommand("customProvider.update", BaseCustomProviderInputSchema, async (args, ctx) => {
+      requireCustomProviderSupport(ctx);
+      const existing = ctx.customProviderRepo.get(args.id);
+      if (!existing) {
+        throw {
+          code: "custom_provider_not_found",
+          message: `Custom provider not found: ${args.id}`
+        };
+      }
+      const saved = ctx.customProviderRepo.set(materializeConfig(args, existing));
+      const definition = buildCustomProviderDefinition(saved);
+      ctx.setProviderRegistry(upsertProviderDefinition(ctx.providerRegistry, definition));
+      return toProviderListItem(definition);
+    });
+    registerCommand(
+      "customProvider.delete",
+      z23.object({
+        id: z23.string().trim().min(1)
+      }),
+      async (args, ctx) => {
+        requireCustomProviderSupport(ctx);
+        const existing = ctx.customProviderRepo.get(args.id);
+        if (!existing) {
+          throw {
+            code: "custom_provider_not_found",
+            message: `Custom provider not found: ${args.id}`
+          };
+        }
+        ctx.customProviderRepo.delete(args.id);
+        ctx.setProviderRegistry(removeProviderDefinition(ctx.providerRegistry, args.id));
+        return { deleted: true, id: args.id };
+      }
+    );
+  }
+});
+
 // packages/server/src/commands/supervisor.ts
-import { z as z18 } from "zod";
+import { z as z24 } from "zod";
 var supervisorObjectiveSchema, createSupervisorSchema, updateSupervisorSchema, sessionIdSchema, workspaceIdSchema, supervisorIdSchema, restoreSupervisorSchema;
 var init_supervisor2 = __esm({
   "packages/server/src/commands/supervisor.ts"() {
     "use strict";
     init_dispatch();
-    supervisorObjectiveSchema = z18.string().trim().min(1).max(4e3);
-    createSupervisorSchema = z18.object({
-      sessionId: z18.string(),
-      workspaceId: z18.string(),
+    supervisorObjectiveSchema = z24.string().trim().min(1).max(4e3);
+    createSupervisorSchema = z24.object({
+      sessionId: z24.string(),
+      workspaceId: z24.string(),
       objective: supervisorObjectiveSchema,
-      evaluatorProviderId: z18.string(),
-      evaluatorModel: z18.string().trim().min(1).max(200).optional(),
-      maxSupervisionCount: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      scheduledAt: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+      evaluatorProviderId: z24.string(),
+      evaluatorModel: z24.string().trim().min(1).max(200).optional(),
+      maxSupervisionCount: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
     }).strict();
-    updateSupervisorSchema = z18.object({
-      id: z18.string(),
+    updateSupervisorSchema = z24.object({
+      id: z24.string(),
       objective: supervisorObjectiveSchema.optional(),
-      evaluatorProviderId: z18.string().optional(),
-      evaluatorModel: z18.string().trim().min(1).max(200).nullable().optional(),
-      maxSupervisionCount: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      scheduledAt: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable().optional()
+      evaluatorProviderId: z24.string().optional(),
+      evaluatorModel: z24.string().trim().min(1).max(200).nullable().optional(),
+      maxSupervisionCount: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable().optional()
     }).strict().refine(
       (input) => input.objective !== void 0 || input.evaluatorProviderId !== void 0 || input.evaluatorModel !== void 0 || input.maxSupervisionCount !== void 0 || input.scheduledAt !== void 0,
       "at least one supervisor field is required"
     );
-    sessionIdSchema = z18.object({ sessionId: z18.string() });
-    workspaceIdSchema = z18.object({ workspaceId: z18.string() });
-    supervisorIdSchema = z18.object({ id: z18.string() });
-    restoreSupervisorSchema = z18.object({
-      sessionId: z18.string(),
-      workspaceId: z18.string(),
-      sourceTargetId: z18.string(),
-      evaluatorProviderId: z18.string(),
-      evaluatorModel: z18.string().trim().min(1).max(200).optional(),
-      maxSupervisionCount: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      scheduledAt: z18.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+    sessionIdSchema = z24.object({ sessionId: z24.string() });
+    workspaceIdSchema = z24.object({ workspaceId: z24.string() });
+    supervisorIdSchema = z24.object({ id: z24.string() });
+    restoreSupervisorSchema = z24.object({
+      sessionId: z24.string(),
+      workspaceId: z24.string(),
+      sourceTargetId: z24.string(),
+      evaluatorProviderId: z24.string(),
+      evaluatorModel: z24.string().trim().min(1).max(200).optional(),
+      maxSupervisionCount: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z24.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
     }).strict();
     registerCommand("supervisor.create", createSupervisorSchema, async (args, ctx) => {
       return {
@@ -17636,7 +19312,7 @@ var init_worktree = __esm({
 
 // packages/server/src/commands/worktree.ts
 import path13 from "node:path";
-import { z as z19 } from "zod";
+import { z as z25 } from "zod";
 async function findRelatedWorkspaceIds(ctx, workspacePath) {
   const targetCommonDir = await getGitCommonDirPath(workspacePath);
   const relatedWorkspaceIds = await Promise.all(
@@ -17669,7 +19345,7 @@ var init_worktree2 = __esm({
     init_worktree();
     init_dispatch();
     init_git_events();
-    registerCommand("worktree.list", z19.object({ workspaceId: z19.string() }), async (args, ctx) => {
+    registerCommand("worktree.list", z25.object({ workspaceId: z25.string() }), async (args, ctx) => {
       const workspace = ctx.workspaceMgr.get(args.workspaceId);
       if (!workspace) {
         throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
@@ -17678,7 +19354,7 @@ var init_worktree2 = __esm({
     });
     registerCommand(
       "worktree.status",
-      z19.object({ workspaceId: z19.string(), worktreePath: z19.string() }),
+      z25.object({ workspaceId: z25.string(), worktreePath: z25.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -17690,10 +19366,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.diff",
-      z19.object({
-        workspaceId: z19.string(),
-        worktreePath: z19.string(),
-        staged: z19.boolean().optional().default(false)
+      z25.object({
+        workspaceId: z25.string(),
+        worktreePath: z25.string(),
+        staged: z25.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -17706,7 +19382,7 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.tree",
-      z19.object({ workspaceId: z19.string(), worktreePath: z19.string() }),
+      z25.object({ workspaceId: z25.string(), worktreePath: z25.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -17718,10 +19394,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.create",
-      z19.object({
-        workspaceId: z19.string(),
-        branch: z19.string(),
-        path: z19.string()
+      z25.object({
+        workspaceId: z25.string(),
+        branch: z25.string(),
+        path: z25.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -17736,10 +19412,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.remove",
-      z19.object({
-        workspaceId: z19.string(),
-        worktreePath: z19.string(),
-        force: z19.boolean().optional().default(false)
+      z25.object({
+        workspaceId: z25.string(),
+        worktreePath: z25.string(),
+        force: z25.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -17763,7 +19439,7 @@ var init_worktree2 = __esm({
 });
 
 // packages/server/src/commands/fencing.ts
-import { z as z20 } from "zod";
+import { z as z26 } from "zod";
 function createMockFencingRequest() {
   return {
     ip: "127.0.0.1",
@@ -17776,9 +19452,9 @@ var init_fencing2 = __esm({
     init_dispatch();
     registerCommand(
       "fencing.request",
-      z20.object({
-        workspaceId: z20.string(),
-        tabId: z20.string()
+      z26.object({
+        workspaceId: z26.string(),
+        tabId: z26.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.requestControl(
@@ -17791,7 +19467,7 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.heartbeat",
-      z20.object({ workspaceId: z20.string() }),
+      z26.object({ workspaceId: z26.string() }),
       async (args, ctx, clientId) => {
         const success = ctx.fencingMgr.heartbeat(args.workspaceId, clientId);
         return { success };
@@ -17799,13 +19475,13 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.release",
-      z20.object({ workspaceId: z20.string() }),
+      z26.object({ workspaceId: z26.string() }),
       async (args, ctx, clientId) => {
         ctx.fencingMgr.release(args.workspaceId, clientId);
         return {};
       }
     );
-    registerCommand("fencing.status", z20.object({ workspaceId: z20.string() }), async (args, ctx) => {
+    registerCommand("fencing.status", z26.object({ workspaceId: z26.string() }), async (args, ctx) => {
       const controller = ctx.fencingMgr.getController(args.workspaceId);
       const isUnresponsive = ctx.fencingMgr.isControllerUnresponsive(args.workspaceId);
       return {
@@ -17816,9 +19492,9 @@ var init_fencing2 = __esm({
     });
     registerCommand(
       "fencing.takeover",
-      z20.object({
-        workspaceId: z20.string(),
-        tabId: z20.string()
+      z26.object({
+        workspaceId: z26.string(),
+        tabId: z26.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.forceTakeover(
@@ -17856,7 +19532,7 @@ var init_runtime_status2 = __esm({
 });
 
 // packages/server/src/commands/lsp.ts
-import { z as z21 } from "zod";
+import { z as z27 } from "zod";
 var init_lsp2 = __esm({
   "packages/server/src/commands/lsp.ts"() {
     "use strict";
@@ -17864,16 +19540,16 @@ var init_lsp2 = __esm({
     init_dispatch();
     registerCommand(
       "lsp.ensureSession",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string()
       }),
       async (args, ctx) => ctx.lspMgr.ensureSession(args)
     );
     registerCommand(
       "lsp.setMode",
-      z21.object({
-        mode: z21.enum(["auto", "off"])
+      z27.object({
+        mode: z27.enum(["auto", "off"])
       }),
       async (args, ctx) => {
         await ctx.lspMgr.setRuntimeMode(args.mode);
@@ -17882,8 +19558,8 @@ var init_lsp2 = __esm({
     );
     registerCommand(
       "lsp.runtimeStatus",
-      z21.object({
-        workspaceId: z21.string()
+      z27.object({
+        workspaceId: z27.string()
       }),
       async (args, ctx) => {
         if (!ctx.lspToolMgr) {
@@ -17907,9 +19583,9 @@ var init_lsp2 = __esm({
     );
     registerCommand(
       "lsp.install.start",
-      z21.object({
-        workspaceId: z21.string(),
-        serverKind: z21.enum(["typescript", "python", "go", "rust"])
+      z27.object({
+        workspaceId: z27.string(),
+        serverKind: z27.enum(["typescript", "python", "go", "rust"])
       }),
       async (args, ctx) => {
         if (!ctx.lspToolInstallMgr) {
@@ -17933,8 +19609,8 @@ var init_lsp2 = __esm({
     );
     registerCommand(
       "lsp.install.get",
-      z21.object({
-        jobId: z21.string()
+      z27.object({
+        jobId: z27.string()
       }),
       async (args, ctx) => {
         if (!ctx.lspToolInstallMgr) {
@@ -17955,86 +19631,86 @@ var init_lsp2 = __esm({
     );
     registerCommand(
       "lsp.openDocument",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        languageId: z21.string(),
-        text: z21.string()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        languageId: z27.string(),
+        text: z27.string()
       }),
       async (args, ctx) => ctx.lspMgr.openDocument(args)
     );
     registerCommand(
       "lsp.changeDocument",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        text: z21.string()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        text: z27.string()
       }),
       async (args, ctx) => ctx.lspMgr.changeDocument(args)
     );
     registerCommand(
       "lsp.closeDocument",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string()
       }),
       async (args, ctx) => ctx.lspMgr.closeDocument(args)
     );
     registerCommand(
       "lsp.definition",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        line: z21.number().int().positive(),
-        column: z21.number().int().positive()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        line: z27.number().int().positive(),
+        column: z27.number().int().positive()
       }),
       async (args, ctx) => ctx.lspMgr.definition(args)
     );
     registerCommand(
       "lsp.declaration",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        line: z21.number().int().positive(),
-        column: z21.number().int().positive()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        line: z27.number().int().positive(),
+        column: z27.number().int().positive()
       }),
       async (args, ctx) => ctx.lspMgr.declaration(args)
     );
     registerCommand(
       "lsp.typeDefinition",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        line: z21.number().int().positive(),
-        column: z21.number().int().positive()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        line: z27.number().int().positive(),
+        column: z27.number().int().positive()
       }),
       async (args, ctx) => ctx.lspMgr.typeDefinition(args)
     );
     registerCommand(
       "lsp.references",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        line: z21.number().int().positive(),
-        column: z21.number().int().positive()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        line: z27.number().int().positive(),
+        column: z27.number().int().positive()
       }),
       async (args, ctx) => ctx.lspMgr.references(args)
     );
     registerCommand(
       "lsp.hover",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string(),
-        line: z21.number().int().positive(),
-        column: z21.number().int().positive()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string(),
+        line: z27.number().int().positive(),
+        column: z27.number().int().positive()
       }),
       async (args, ctx) => ctx.lspMgr.hover(args)
     );
     registerCommand(
       "lsp.documentSymbols",
-      z21.object({
-        workspaceId: z21.string(),
-        path: z21.string()
+      z27.object({
+        workspaceId: z27.string(),
+        path: z27.string()
       }),
       async (args, ctx) => ctx.lspMgr.documentSymbols(args)
     );
@@ -18042,12 +19718,12 @@ var init_lsp2 = __esm({
 });
 
 // packages/server/src/commands/updates.ts
-import { z as z22 } from "zod";
+import { z as z28 } from "zod";
 var init_updates = __esm({
   "packages/server/src/commands/updates.ts"() {
     "use strict";
     init_dispatch();
-    registerCommand("updates.getState", z22.object({}).default({}), async (_args, ctx) => {
+    registerCommand("updates.getState", z28.object({}).default({}), async (_args, ctx) => {
       if (!ctx.updateService) {
         throw {
           code: "update_unavailable",
@@ -18056,7 +19732,7 @@ var init_updates = __esm({
       }
       return ctx.updateService.getStateView();
     });
-    registerCommand("updates.check", z22.object({}).default({}), async (_args, ctx) => {
+    registerCommand("updates.check", z28.object({}).default({}), async (_args, ctx) => {
       if (!ctx.updateService) {
         throw {
           code: "update_unavailable",
@@ -18065,7 +19741,7 @@ var init_updates = __esm({
       }
       return await ctx.updateService.checkForUpdates({ manual: true });
     });
-    registerCommand("updates.prepareInstall", z22.object({}).default({}), async (_args, ctx) => {
+    registerCommand("updates.prepareInstall", z28.object({}).default({}), async (_args, ctx) => {
       if (!ctx.updateService) {
         throw {
           code: "update_unavailable",
@@ -18076,9 +19752,9 @@ var init_updates = __esm({
     });
     registerCommand(
       "updates.startInstall",
-      z22.object({
-        targetVersion: z22.string().optional(),
-        force: z22.boolean().optional()
+      z28.object({
+        targetVersion: z28.string().optional(),
+        force: z28.boolean().optional()
       }),
       async (args, ctx) => {
         if (!ctx.updateService) {
@@ -18103,12 +19779,17 @@ var init_commands = __esm({
     init_connection();
     init_recovery();
     init_session2();
+    init_session_metadata();
+    init_session_review();
     init_terminal();
     init_file();
     init_git2();
+    init_agent_instructions();
+    init_agent_context();
     init_settings2();
     init_diagnostics2();
     init_provider();
+    init_custom_provider2();
     init_supervisor2();
     init_worktree2();
     init_fencing2();
@@ -18120,12 +19801,12 @@ var init_commands = __esm({
 // packages/server/src/server.ts
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join18 } from "node:path";
 async function createServer(configOverrides) {
   const config = parseServerConfig(configOverrides);
   const configuredStateDir = resolveConfiguredStateDir(config);
   const shouldCleanupStateRoot = configuredStateDir === IN_MEMORY_STATE_DIR;
-  const stateRoot = shouldCleanupStateRoot ? mkdtempSync(join15(tmpdir(), "coder-studio-state-")) : configuredStateDir;
+  const stateRoot = shouldCleanupStateRoot ? mkdtempSync(join18(tmpdir(), "coder-studio-state-")) : configuredStateDir;
   ensureStateDir(config);
   const eventBus = new EventBus();
   const activationMgr = new ActivationManager();
@@ -18135,10 +19816,10 @@ async function createServer(configOverrides) {
   let commandContext;
   let lspMgr = null;
   const terminalRepo = new TerminalRepo({
-    filePath: join15(stateRoot, "state", "terminals.json")
+    filePath: join18(stateRoot, "state", "terminals.json")
   });
   const sessionRepo = new SessionRepo({
-    filePath: join15(stateRoot, "state", "sessions.json")
+    filePath: join18(stateRoot, "state", "sessions.json")
   });
   const terminalMgr = new TerminalManager({
     ptyHost: createPtyHost(),
@@ -18146,10 +19827,10 @@ async function createServer(configOverrides) {
     db: terminalRepo
   });
   const settingsRepo = new SettingsRepo({
-    filePath: join15(stateRoot, "state", "settings.json")
+    filePath: join18(stateRoot, "state", "settings.json")
   });
   const updateStateRepo = new UpdateStateRepo({
-    filePath: join15(stateRoot, "state", "update-state.json"),
+    filePath: join18(stateRoot, "state", "update-state.json"),
     currentVersion: config.appVersion ?? "0.0.0"
   });
   const autoFetch = new AutoFetchScheduler({
@@ -18182,17 +19863,27 @@ async function createServer(configOverrides) {
     }
   });
   const providerConfigRepo = new ProviderConfigRepo({
-    filePath: join15(stateRoot, "state", "provider-configs.json")
+    filePath: join18(stateRoot, "state", "provider-configs.json")
+  });
+  const customProviderRepo = new CustomProviderRepo({
+    filePath: join18(stateRoot, "state", "custom-providers.json")
   });
   const workspaceRepo = new WorkspaceRepo({
-    filePath: join15(stateRoot, "state", "workspaces.json")
+    filePath: join18(stateRoot, "state", "workspaces.json")
+  });
+  const sessionMetadataRepo = new SessionMetadataRepo({
+    workspaceRepo
   });
+  let activeProviderRegistry = [
+    ...providerRegistry,
+    ...customProviderRepo.list().map((config2) => buildCustomProviderDefinition(config2))
+  ];
   const sessionMgr = new SessionManager({
     terminalMgr,
     eventBus,
     db: sessionRepo,
     broadcaster: wsHub,
-    providerRegistry,
+    providerRegistry: activeProviderRegistry,
     providerConfigRepo
   });
   let supervisorMgr;
@@ -18203,13 +19894,15 @@ async function createServer(configOverrides) {
     broadcaster: wsHub,
     autoFetch,
     teardown: async (workspaceId) => {
+      const persistedSessions = sessionRepo.findByWorkspaceId(workspaceId);
       await lspMgr?.disposeWorkspace(workspaceId);
       await supervisorMgr?.deleteForWorkspace(workspaceId);
       await sessionMgr.stopForWorkspace(workspaceId);
       await terminalMgr.closeForWorkspace(workspaceId);
       sessionMgr.deleteEndedForWorkspace(workspaceId);
-      for (const session of sessionRepo.findByWorkspaceId(workspaceId)) {
+      for (const session of persistedSessions) {
         sessionRepo.delete(session.id);
+        sessionMetadataRepo.delete(session.id);
       }
       for (const terminal of terminalRepo.listByWorkspace(workspaceId)) {
         terminalRepo.delete(terminal.id);
@@ -18220,13 +19913,13 @@ async function createServer(configOverrides) {
     )
   });
   const authSessionRepo = new AuthSessionRepo({
-    filePath: join15(stateRoot, "state", "auth-sessions.json")
+    filePath: join18(stateRoot, "state", "auth-sessions.json")
   });
   const authLoginBlockRepo = new AuthLoginBlockRepo({
-    filePath: join15(stateRoot, "state", "auth-login-blocks.json")
+    filePath: join18(stateRoot, "state", "auth-login-blocks.json")
   });
   const appearanceAssetRepo = new AppearanceAssetRepo({
-    filePath: join15(stateRoot, "state", "appearance-assets.json")
+    filePath: join18(stateRoot, "state", "appearance-assets.json")
   });
   const app = await buildFastifyApp({
     wsHub,
@@ -18277,7 +19970,7 @@ async function createServer(configOverrides) {
     terminalMgr,
     workspaceMgr,
     sessionMgr,
-    providerRegistry,
+    providerRegistry: activeProviderRegistry,
     providerConfigRepo,
     settingsRepo,
     supervisorRepo,
@@ -18290,7 +19983,7 @@ async function createServer(configOverrides) {
   const providerRuntimeDeps = providerMockOverrides ? {
     commandExists: providerMockOverrides.commandExists
   } : {};
-  const providerInstallMgr = new ProviderInstallManager(providerRegistry, {
+  const providerInstallMgr = new ProviderInstallManager(activeProviderRegistry, {
     ...providerRuntimeDeps,
     runCommand: providerMockOverrides?.runCommand ?? runCommandAsString
   });
@@ -18302,7 +19995,7 @@ async function createServer(configOverrides) {
       ...config.update,
       currentVersion: config.appVersion ?? "0.0.0"
     },
-    updateWorkerLogFilePath: join15(stateRoot, "logs", "update-worker.log"),
+    updateWorkerLogFilePath: join18(stateRoot, "logs", "update-worker.log"),
     countRunningTerminals: () => terminalMgr.getAll().filter((terminal) => terminal.alive).length,
     countRunningSessions: () => sessionMgr.getAll().filter((session) => session.state === "starting" || session.state === "running").length,
     countActiveSupervisors: () => supervisorMgr?.countActive() ?? 0
@@ -18316,7 +20009,7 @@ async function createServer(configOverrides) {
     broadcaster: wsHub,
     settingsRepo,
     providerConfigRepo,
-    providerRegistry,
+    providerRegistry: activeProviderRegistry,
     fencingMgr,
     supervisorMgr,
     autoFetch,
@@ -18327,7 +20020,16 @@ async function createServer(configOverrides) {
     lspMgr,
     lspToolMgr,
     lspToolInstallMgr,
-    updateService
+    updateService,
+    customProviderRepo,
+    sessionMetadataRepo,
+    setProviderRegistry: (providers) => {
+      activeProviderRegistry = providers;
+      commandContext.providerRegistry = providers;
+      providerInstallMgr.setProviders(providers);
+      sessionMgr.setProviderRegistry(providers);
+      supervisorMgr?.setProviderRegistry(providers);
+    }
   };
   wsHub.setCommandContext(commandContext);
   await app.listen({
@@ -18411,13 +20113,16 @@ var init_server = __esm({
     init_manifest_store();
     init_tool_root();
     init_command_runner();
+    init_custom_provider();
     init_e2e_provider_mock();
     init_install_manager2();
     init_manager3();
     init_appearance_asset_repo();
     init_auth_login_block_repo();
     init_auth_session_repo();
+    init_custom_provider_repo();
     init_provider_config_repo();
+    init_session_metadata_repo();
     init_session_repo();
     init_settings_repo();
     init_supervisor_repo();
@@ -18460,7 +20165,9 @@ var init_storage = __esm({
     "use strict";
     init_auth_login_block_repo();
     init_auth_session_repo();
+    init_custom_provider_repo();
     init_provider_config_repo();
+    init_session_metadata_repo();
     init_session_repo();
     init_settings_repo();
     init_supervisor_repo();
@@ -18488,10 +20195,12 @@ __export(src_exports, {
   ActiveTerminal: () => ActiveTerminal,
   AuthLoginBlockRepo: () => AuthLoginBlockRepo,
   AuthSessionRepo: () => AuthSessionRepo,
+  CustomProviderRepo: () => CustomProviderRepo,
   EventBus: () => EventBus,
   NodePtyHost: () => NodePtyHost,
   ProviderConfigRepo: () => ProviderConfigRepo,
   RingBuffer: () => RingBuffer,
+  SessionMetadataRepo: () => SessionMetadataRepo,
   SessionRepo: () => SessionRepo,
   SettingsRepo: () => SettingsRepo,
   SupervisorRepo: () => SupervisorRepo,
@@ -18533,9 +20242,9 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 init_state_paths();
 import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join16 } from "path";
+import { join as join19 } from "path";
 function getCliConfigPath() {
-  return join16(homedir4(), ".coder-studio", "config.json");
+  return join19(homedir4(), ".coder-studio", "config.json");
 }
 function normalizeLegacyDataDir(input) {
   return normalizeLegacyStateDir(input);
@@ -18563,11 +20272,11 @@ function readCliConfig() {
 
 // packages/cli/src/embed.ts
 import { existsSync as existsSync11 } from "fs";
-import { dirname as dirname8, resolve as resolve5 } from "path";
+import { dirname as dirname8, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname8(__filename);
-var WEB_ASSETS_DIR = resolve5(__dirname, "../web");
+var WEB_ASSETS_DIR = resolve7(__dirname, "../web");
 function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }
@@ -18631,13 +20340,13 @@ function getCliPackageName(importMetaUrl) {
 
 // packages/cli/src/update-runtime.ts
 import { existsSync as existsSync13 } from "node:fs";
-import { dirname as dirname9, join as join17 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveWorkerEntryPath(importMetaUrl) {
   const currentDir = dirname9(fileURLToPath3(importMetaUrl));
   const candidates = [
-    join17(currentDir, "update-worker.mjs"),
-    join17(currentDir, "../src/update-worker.ts")
+    join20(currentDir, "update-worker.mjs"),
+    join20(currentDir, "../src/update-worker.ts")
   ];
   return candidates.find((candidate) => existsSync13(candidate));
 }