@superblocksteam/cli 2.0.127-next.0 → 2.0.128-next.0

package/dist/{chunk-NPJMB63E.js → chunk-CFDMQXWR.js}

@@ -1,7 +1,7 @@
 if (typeof process === 'object' && process !== null &&
     process.env !== null && typeof process.env === 'object') {
   process.env.DD_GIT_REPOSITORY_URL = 'https://token@github.com/superblocksteam/superblocks.git';
-  process.env.DD_GIT_COMMIT_SHA = '25cc3037f32707a904e7459e80e958ca3ad1528d';
+  process.env.DD_GIT_COMMIT_SHA = '20de18b4be09a66317d3ef2bc2efbf8bfb1bbfa7';
 }
 import { createRequire as $dd_createRequire } from 'module';
 import { fileURLToPath as $dd_fileURLToPath } from 'url';
@@ -22,7 +22,7 @@ import {
   require_re,
   require_semver,
   require_valid
-} from "./chunk-KKNY3RBN.js";
+} from "./chunk-ECZ3M77Z.js";
 import {
   debounce_default,
   get_default,
@@ -39,23 +39,23 @@ import {
   require_lib,
   require_slugify,
   throttle_default
-} from "./chunk-BN5U26VC.js";
+} from "./chunk-HJRKYDBU.js";
 import {
   require_dd_trace,
   require_js_yaml,
   require_module_details_from_path,
   require_p_limit,
   require_path_to_regexp
-} from "./chunk-K3O6TE35.js";
+} from "./chunk-G53E6Y74.js";
 import {
   require_commonjs
-} from "./chunk-24JWMPGA.js";
+} from "./chunk-KSSU6DJH.js";
 import {
   require_dc_polyfill
-} from "./chunk-ZSID6E3B.js";
+} from "./chunk-WWRBGTXM.js";
 import {
   require_token_error
-} from "./chunk-N3OOJGMF.js";
+} from "./chunk-BLGSMTBW.js";
 import {
   SpanKind,
   SpanStatusCode,
@@ -65,7 +65,7 @@ import {
   init_esm,
   metrics,
   trace
-} from "./chunk-Y3SSO7TF.js";
+} from "./chunk-HZ57BTBJ.js";
 import {
   __commonJS,
   __esm,
@@ -74,7 +74,7 @@ import {
   __toCommonJS,
   __toESM,
   init_cjs_shims
-} from "./chunk-E5BF6ZNT.js";
+} from "./chunk-TVWA6CZX.js";
 
 // ../../../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js
 var require_constants3 = __commonJS({
@@ -97018,15 +97018,15 @@ var require_api_files = __commonJS({
     exports.readAppApiYamlFile = readAppApiYamlFile4;
     exports.resolveLanguageSpecificStepContentFromBlocks = resolveLanguageSpecificStepContentFromBlocks2;
     async function writeApiFiles3(...args) {
-      const esmFunction = await import("./api-PHWED3B7.js");
+      const esmFunction = await import("./api-GR5LHFUB.js");
       return esmFunction.writeApiFiles(...args);
     }
     async function readAppApiYamlFile4(...args) {
-      const esmFunction = await import("./api-PHWED3B7.js");
+      const esmFunction = await import("./api-GR5LHFUB.js");
       return esmFunction.readAppApiYamlFile(...args);
     }
     async function resolveLanguageSpecificStepContentFromBlocks2(...args) {
-      const esmFunction = await import("./api-PHWED3B7.js");
+      const esmFunction = await import("./api-GR5LHFUB.js");
       return esmFunction.resolveLanguageSpecificStepContentFromBlocks(...args);
     }
   }
@@ -103616,19 +103616,19 @@ var require_getMachineId = __commonJS({
       if (!getMachineIdImpl) {
         switch (process5.platform) {
           case "darwin":
-            getMachineIdImpl = (await import("./getMachineId-darwin-VRD623QA.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-darwin-Y7OUNXQ6.js")).getMachineId;
             break;
           case "linux":
-            getMachineIdImpl = (await import("./getMachineId-linux-EL5FHQHK.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-linux-DWD2G4MU.js")).getMachineId;
             break;
           case "freebsd":
-            getMachineIdImpl = (await import("./getMachineId-bsd-6CQNZOWX.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-bsd-EFWKCDBV.js")).getMachineId;
             break;
           case "win32":
-            getMachineIdImpl = (await import("./getMachineId-win-PUBLZQLL.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-win-YAXEWWSU.js")).getMachineId;
             break;
           default:
-            getMachineIdImpl = (await import("./getMachineId-unsupported-RU6ZPPJV.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-unsupported-C4F6X6HP.js")).getMachineId;
             break;
         }
       }
@@ -182586,8 +182586,8 @@ var require_get_vercel_oidc_token = __commonJS({
       }
       try {
         const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-          await import("./token-util-3CWH3NBE.js"),
-          await import("./token-F25OBSDW.js")
+          await import("./token-util-RCTSISL4.js"),
+          await import("./token-NGCVDZXF.js")
         ]);
         if (!token2 || isExpired(getTokenPayload(token2))) {
           await refreshToken();
@@ -213546,14 +213546,14 @@ var require_lib6 = __commonJS({
     };
     var mixinPluginNames = Object.keys(mixinPlugins);
     var ExpressionParser = class extends LValParser {
-      checkProto(prop2, isRecord, sawProto, refExpressionErrors) {
+      checkProto(prop2, isRecord2, sawProto, refExpressionErrors) {
         if (prop2.type === "SpreadElement" || this.isObjectMethod(prop2) || prop2.computed || prop2.shorthand) {
           return sawProto;
         }
         const key2 = prop2.key;
         const name17 = key2.type === "Identifier" ? key2.name : key2.value;
         if (name17 === "__proto__") {
-          if (isRecord) {
+          if (isRecord2) {
             this.raise(Errors.RecordNoProto, key2);
             return true;
           }
@@ -214611,8 +214611,8 @@ var require_lib6 = __commonJS({
       parseTemplateSubstitution() {
         return this.parseExpression();
       }
-      parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
-        if (isRecord) {
+      parseObjectLike(close, isPattern, isRecord2, refExpressionErrors) {
+        if (isRecord2) {
           this.expectPlugin("recordAndTuple");
         }
         const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
@@ -214637,9 +214637,9 @@ var require_lib6 = __commonJS({
             prop2 = this.parseBindingProperty();
           } else {
             prop2 = this.parsePropertyDefinition(refExpressionErrors);
-            sawProto = this.checkProto(prop2, isRecord, sawProto, refExpressionErrors);
+            sawProto = this.checkProto(prop2, isRecord2, sawProto, refExpressionErrors);
           }
-          if (isRecord && !this.isObjectProperty(prop2) && prop2.type !== "SpreadElement") {
+          if (isRecord2 && !this.isObjectProperty(prop2) && prop2.type !== "SpreadElement") {
             this.raise(Errors.InvalidRecordProperty, prop2);
           }
           if (prop2.shorthand) {
@@ -214652,7 +214652,7 @@ var require_lib6 = __commonJS({
         let type = "ObjectExpression";
         if (isPattern) {
           type = "ObjectPattern";
-        } else if (isRecord) {
+        } else if (isRecord2) {
           type = "RecordExpression";
         }
         return this.finishNode(node, type);
@@ -437974,7 +437974,7 @@ var require_config_loader = __commonJS({
        * @returns {Promise<{createJiti: Function|undefined, version: string;}>} A promise that fulfills with an object containing the jiti module's createJiti function and version.
        */
       static async loadJiti() {
-        const { createJiti } = await import("./jiti-ZVPDMBG2.js");
+        const { createJiti } = await import("./jiti-MWCTYY5S.js");
         const version4 = require_package5().version;
         return { createJiti, version: version4 };
       }
@@ -438303,7 +438303,7 @@ var require_eslint_helpers = __commonJS({
     }
     async function globMatch({ basePath, pattern }) {
       let found = false;
-      const { hfs } = await import("./src-KMJE6Z3I.js");
+      const { hfs } = await import("./src-HJMFY2GS.js");
       const patternToUse = normalizeToPosix(path78.relative(basePath, pattern));
       const matcher = new Minimatch2(patternToUse, MINIMATCH_OPTIONS);
       const walkSettings = {
@@ -438343,7 +438343,7 @@ var require_eslint_helpers = __commonJS({
         return new Minimatch2(patternToUse, MINIMATCH_OPTIONS);
       });
       const unmatchedPatterns = /* @__PURE__ */ new Set([...relativeToPatterns.keys()]);
-      const { hfs } = await import("./src-KMJE6Z3I.js");
+      const { hfs } = await import("./src-HJMFY2GS.js");
       const walk2 = hfs.walk(basePath, {
         async directoryFilter(entry) {
           if (!matchers.some((matcher) => matcher.match(entry.path, true))) {
@@ -494607,7 +494607,7 @@ init_cjs_shims();
 // ../sdk/package.json
 var package_default = {
   name: "@superblocksteam/sdk",
-  version: "2.0.127-next.0",
+  version: "2.0.128-next.0",
   description: "Superblocks JS SDK",
   homepage: "https://www.superblocks.com",
   license: "Superblocks Community Software License",
@@ -494969,7 +494969,7 @@ var config = void 0;
 var configured = false;
 var ddTracePromise = void 0;
 async function getDdTrace() {
-  ddTracePromise ??= import("./dd-trace-RM2ILFLC.js").then((module) => module.default);
+  ddTracePromise ??= import("./dd-trace-HKBFCAGL.js").then((module) => module.default);
   return await ddTracePromise;
 }
 var deploymentType = (() => {
@@ -518590,6 +518590,203 @@ function buildThinkingProviderOptions(coreModel, params) {
   return { anthropic: anthropic3, bedrock, headers };
 }
 
+// ../../../clark/dist/snowflake-cortex-fetch.js
+init_cjs_shims();
+var HTTP_STATUS_TO_ERROR_TYPE = {
+  400: "invalid_request_error",
+  401: "authentication_error",
+  403: "permission_error",
+  404: "not_found_error",
+  429: "rate_limit_error",
+  500: "api_error",
+  529: "overloaded_error"
+};
+function normalizeErrorResponse(response, text3) {
+  try {
+    const body = JSON.parse(text3);
+    if (body?.error && !body?.type) {
+      const errorType = HTTP_STATUS_TO_ERROR_TYPE[response.status] ?? "api_error";
+      return new Response(JSON.stringify({
+        type: "error",
+        error: {
+          type: errorType,
+          message: body.error.message ?? text3
+        }
+      }), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+  } catch {
+  }
+  return new Response(text3, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function normalizeSuccessfulResponseBody(value2) {
+  if (Array.isArray(value2)) {
+    return value2.map(normalizeSuccessfulResponseBody);
+  }
+  if (value2 && typeof value2 === "object") {
+    return Object.fromEntries(Object.entries(value2).map(([key2, nestedValue]) => {
+      if (key2 === "citations" && nestedValue === null) {
+        return [key2, []];
+      }
+      if ((key2 === "cache_creation_input_tokens" || key2 === "cache_read_input_tokens") && nestedValue === null) {
+        return [key2, 0];
+      }
+      return [key2, normalizeSuccessfulResponseBody(nestedValue)];
+    }));
+  }
+  return value2;
+}
+function normalizeSuccessResponse(response, text3) {
+  try {
+    return new Response(JSON.stringify(normalizeSuccessfulResponseBody(JSON.parse(text3))), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  } catch {
+    return new Response(text3, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+}
+function stripCacheControl(value2) {
+  if (Array.isArray(value2)) {
+    return value2.map(stripCacheControl);
+  }
+  if (value2 && typeof value2 === "object") {
+    return Object.fromEntries(Object.entries(value2).filter(([key2]) => key2 !== "cache_control").map(([key2, nested]) => [key2, stripCacheControl(nested)]));
+  }
+  return value2;
+}
+function stripCortexUnsupportedCacheControl(body) {
+  if (!body || typeof body !== "object") {
+    return body;
+  }
+  const result = {
+    ...body
+  };
+  delete result.cache_control;
+  if (Array.isArray(result.messages)) {
+    result.messages = result.messages.map((message) => message && typeof message === "object" && message.role === "user" ? message : stripCacheControl(message));
+  }
+  if (Array.isArray(result.tools)) {
+    result.tools = result.tools.map(stripCacheControl);
+  }
+  return result;
+}
+var UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties",
+  "patternProperties",
+  "propertyNames"
+]);
+var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set(["properties", "$defs", "definitions"]);
+var OPAQUE_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "enum",
+  "const",
+  "default",
+  "examples"
+]);
+function sanitizeJsonSchema(node) {
+  if (Array.isArray(node)) {
+    return node.map(sanitizeJsonSchema);
+  }
+  if (node && typeof node === "object") {
+    const sanitized = {};
+    for (const [key2, value2] of Object.entries(node)) {
+      if (UNSUPPORTED_SCHEMA_KEYWORDS.has(key2)) {
+        continue;
+      }
+      if (OPAQUE_SCHEMA_KEYWORDS.has(key2)) {
+        sanitized[key2] = value2;
+      } else if (SCHEMA_MAP_KEYWORDS.has(key2) && value2 && typeof value2 === "object" && !Array.isArray(value2)) {
+        sanitized[key2] = Object.fromEntries(Object.entries(value2).map(([name17, subSchema]) => [name17, sanitizeJsonSchema(subSchema)]));
+      } else {
+        sanitized[key2] = sanitizeJsonSchema(value2);
+      }
+    }
+    return sanitized;
+  }
+  return node;
+}
+function stripUnsupportedSchemaKeywords(value2) {
+  if (Array.isArray(value2)) {
+    return value2.map(stripUnsupportedSchemaKeywords);
+  }
+  if (value2 && typeof value2 === "object") {
+    return Object.fromEntries(Object.entries(value2).map(([key2, nested]) => key2 === "input_schema" ? [key2, sanitizeJsonSchema(nested)] : [key2, stripUnsupportedSchemaKeywords(nested)]));
+  }
+  return value2;
+}
+function sanitizeRequestInit(init2, forwardCacheControl) {
+  if (!init2 || typeof init2.body !== "string") {
+    return init2;
+  }
+  try {
+    const parsed = JSON.parse(init2.body);
+    const afterCacheControl = forwardCacheControl ? stripCortexUnsupportedCacheControl(parsed) : stripCacheControl(parsed);
+    const cleaned = stripUnsupportedSchemaKeywords(afterCacheControl);
+    return { ...init2, body: JSON.stringify(cleaned) };
+  } catch {
+    return init2;
+  }
+}
+function createSnowflakeCortexFetch({ forwardCacheControl, onPromptCachingRejected }) {
+  return async (input, init2) => {
+    let response = await globalThis.fetch(input, sanitizeRequestInit(init2, forwardCacheControl));
+    if (forwardCacheControl && response.status === 400) {
+      const text3 = await response.text();
+      if (/cache_control/i.test(text3)) {
+        onPromptCachingRejected?.();
+        response = await globalThis.fetch(input, sanitizeRequestInit(init2, false));
+      } else {
+        return normalizeErrorResponse(new Response(text3, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        }), text3);
+      }
+    }
+    if (!response.ok) {
+      const text3 = await response.text();
+      return normalizeErrorResponse(response, text3);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const text3 = await response.text();
+      return normalizeSuccessResponse(response, text3);
+    }
+    return response;
+  };
+}
+var snowflakeCortexFetch = createSnowflakeCortexFetch({
+  forwardCacheControl: false
+});
+
 // ../../../clark/dist/mcp/index.js
 init_cjs_shims();
 
@@ -520372,7 +520569,7 @@ var MAX_ATTRIBUTE_LENGTH = 64e3;
 var LLMObsSpanWriter = null;
 async function loadLLMObsSpanWriter() {
   if (!LLMObsSpanWriter) {
-    const module = await import("./spans-54HKADTB.js");
+    const module = await import("./spans-GAMVAAT5.js");
     LLMObsSpanWriter = module.default;
   }
   return LLMObsSpanWriter;
@@ -550150,6 +550347,7 @@ ${filteredIntegrations.map((integration) => formatIntegrationForPlanPrompt(integ
             retry: {
               maxAttempts: 0
             },
+            observers: services.streamObservers,
             onError: (error40) => {
               clark.logger.error("[exitPlanMode] LLM stream generation failed", getErrorMeta2(error40));
             }
@@ -550313,8 +550511,9 @@ var PLAN_TIME_ESTIMATES = {
   Large: "3 minutes",
   "Extra Large": "5+ minutes"
 };
+var EXIT_PLAN_MODE_PLAN_GENERATION_PROMPT_PREFIX = "Based on our conversation and the information gathered, create a specific, actionable plan.";
 var PLAN_GENERATION_PROMPT = `
-Based on our conversation and the information gathered, create a specific, actionable plan.
+${EXIT_PLAN_MODE_PLAN_GENERATION_PROMPT_PREFIX}
 
 IMPORTANT: You MUST output a plan. Even for trivial tasks, provide a brief plan describing what will be done.
 
@@ -551575,6 +551774,7 @@ var RpcTimeoutError = class extends Error {
   }
 };
 var DEFAULT_RPC_TIMEOUT_MS = 6e4;
+var FETCH_INTEGRATIONS_TIMEOUT_MS = 15e3;
 async function withRpcTimeout(promise2, timeoutMs = DEFAULT_RPC_TIMEOUT_MS, operationName = "RPC call") {
   let timeoutId;
   const timeoutPromise = new Promise((_4, reject) => {
@@ -552017,7 +552217,7 @@ var IntegrationStore = (() => {
     }
     async fetchIntegrations(editorClient, mentionedIntegrations) {
       getLogger3().info(`[integration-store] Fetching integrations from browser...`);
-      const integrations = await withRpcTimeout(editorClient?.call.aiGetIntegrations(), DEFAULT_RPC_TIMEOUT_MS, "aiGetIntegrations") ?? [];
+      const integrations = await withRpcTimeout(editorClient?.call.aiGetIntegrations(), FETCH_INTEGRATIONS_TIMEOUT_MS, "aiGetIntegrations") ?? [];
       getLogger3().info(`[integration-store] Registering ${integrations.length} integrations`);
       for (const integration of integrations) {
         const pluginId = integration.type;
@@ -561438,6 +561638,11 @@ function wrapError(err, provider) {
     const underlyingError = new LLMProviderError({
       provider,
       message: err.message,
+      // A StallTimeoutError carries no provider ErrorCategory, so the constructor
+      // would default it to "api_error" and surface the generic model-error
+      // string. Classify exhausted stalls as "stall" so the user gets a
+      // stall-specific message and observability can distinguish them (APPS-4389).
+      type: err.cause instanceof StallTimeoutError ? "stall" : void 0,
       cause: err.cause
     });
     underlyingError.isRetryable = false;
@@ -601513,6 +601718,13 @@ init_cjs_shims();
 
 // ../../../vite-plugin-file-sync/dist/ai-service/llm/stream/config.js
 init_cjs_shims();
+var SERVER_CONTEXT_COMPACTION_FIRST_CHUNK_TIMEOUT_MS = 24e4;
+function defaultFirstChunkTimeoutMs(serverSideContextManagement, idleTimeoutMs) {
+  return serverSideContextManagement ? Math.max(idleTimeoutMs, SERVER_CONTEXT_COMPACTION_FIRST_CHUNK_TIMEOUT_MS) : idleTimeoutMs;
+}
+function defaultFallbackStrategy(provider) {
+  return provider === "snowflake" ? "provider-then-model-no-retry" : "model-then-provider";
+}
 var StreamConfig = class _StreamConfig {
   _retry;
   _provider;
@@ -601533,8 +601745,21 @@ var StreamConfig = class _StreamConfig {
     const retry = {
       maxAttempts: options8.retry?.maxAttempts ?? 5,
       maxAttemptsPerProvider: options8.retry?.maxAttemptsPerProvider ?? 2,
+      // Generic default for callers with no server-side context management.
+      // Like firstChunkTimeoutMs below, StreamConfig stays agnostic and does
+      // NOT floor this against the proxy upstream-stall timeout — callers that
+      // run behind the proxy must pass a value >= the proxy stall budget so a
+      // single upstream stall can't exhaust the retry clock (LLMClient does
+      // this via Math.max(..., proxyStallTimeoutMs)). See APPS-4520.
       maxTotalTimeMs: options8.retry?.maxTotalTimeMs ?? 12e4,
       idleTimeoutMs: options8.retry?.idleTimeoutMs ?? 9e4,
+      // Defaults to the inter-chunk idle budget so generic callers see no
+      // behavior change. StreamConfig is context-management-agnostic and does
+      // NOT itself apply the larger server-side first-chunk budget — callers
+      // that opt into server-side context management must pass a value derived
+      // from `defaultFirstChunkTimeoutMs(serverSide, idleTimeoutMs)` (LLMClient
+      // does this). See APPS-4520.
+      firstChunkTimeoutMs: options8.retry?.firstChunkTimeoutMs ?? options8.retry?.idleTimeoutMs ?? 9e4,
       initialDelayMs: options8.retry?.initialDelayMs ?? 500,
       maxDelayMs: options8.retry?.maxDelayMs ?? 1e4,
       backoffMultiplier: options8.retry?.backoffMultiplier ?? 2
@@ -601545,7 +601770,7 @@ var StreamConfig = class _StreamConfig {
     };
     const fallback = {
       enabled: options8.fallback?.enabled ?? false,
-      strategy: options8.fallback?.strategy ?? "model-then-provider",
+      strategy: options8.fallback?.strategy ?? defaultFallbackStrategy(options8.provider),
       fallbackProviders: options8.fallback?.fallbackProviders
     };
     const logging = {
@@ -601581,21 +601806,36 @@ init_cjs_shims();
 var IdleMonitor = class {
   session;
   maxIdleTimeMs;
+  firstChunkTimeoutMs;
   onStallCallback;
+  onServerCompactionStart;
   timer = null;
   stallError = null;
   stallCallbacks = [];
   subscribed = false;
+  hasReceivedChunk = false;
+  compactionTextBlockIds = /* @__PURE__ */ new Set();
   constructor(options8) {
     this.session = options8.session;
     this.maxIdleTimeMs = options8.maxIdleTimeMs;
+    this.firstChunkTimeoutMs = options8.firstChunkTimeoutMs ?? options8.maxIdleTimeMs;
     this.onStallCallback = options8.onStall;
+    this.onServerCompactionStart = options8.onServerCompactionStart;
+  }
+  /**
+   * Active budget: the first-chunk budget until useful output arrives, then
+   * the inter-chunk idle budget.
+   */
+  currentTimeoutMs() {
+    return this.hasReceivedChunk ? this.maxIdleTimeMs : this.firstChunkTimeoutMs;
   }
   /**
    * Start the idle monitor. Arms the timer and subscribes to session events.
    */
   start() {
     this.stallError = null;
+    this.hasReceivedChunk = false;
+    this.compactionTextBlockIds.clear();
     this.session.resetActivityTimer();
     this.subscribeToEvents();
     this.armTimer();
@@ -601637,17 +601877,30 @@ var IdleMonitor = class {
     }
     this.subscribed = true;
     this.session.events.on("chunk", this.handleChunk);
+    this.session.events.on("step:start", this.handleStepStart);
     this.session.events.on("retry", this.handleRetry);
     this.session.events.on("session:complete", this.handleSessionEnd);
     this.session.events.on("session:error", this.handleSessionEnd);
     this.session.events.on("session:abort", this.handleSessionEnd);
   }
-  handleChunk = () => {
+  handleChunk = (chunk) => {
+    if (!this.keepsFirstChunkBudget(chunk)) {
+      this.hasReceivedChunk = true;
+    }
     this.stallError = null;
     this.stallCallbacks = [];
     this.armTimer();
   };
+  handleStepStart = () => {
+    this.hasReceivedChunk = false;
+    this.compactionTextBlockIds.clear();
+    this.stallError = null;
+    this.session.resetActivityTimer();
+    this.armTimer();
+  };
   handleRetry = () => {
+    this.hasReceivedChunk = false;
+    this.compactionTextBlockIds.clear();
     this.stallError = null;
     this.stallCallbacks = [];
     this.session.resetActivityTimer();
@@ -601662,14 +601915,39 @@ var IdleMonitor = class {
     }
     this.timer = setTimeout(() => {
       this.fireStall();
-    }, this.maxIdleTimeMs);
+    }, this.currentTimeoutMs());
+  }
+  keepsFirstChunkBudget(chunk) {
+    if (chunk.type === "raw" && this.compactionTextBlockIds.size > 0) {
+      return true;
+    }
+    if (chunk.type === "text-start") {
+      const id2 = getChunkTextId(chunk);
+      if (id2 && isAnthropicCompactionMetadata(chunk.providerMetadata)) {
+        if (!this.compactionTextBlockIds.has(id2)) {
+          this.compactionTextBlockIds.add(id2);
+          this.onServerCompactionStart?.(id2);
+        }
+        return true;
+      }
+    }
+    if (chunk.type === "text-delta" || chunk.type === "text-end") {
+      const id2 = getChunkTextId(chunk);
+      if (id2 && this.compactionTextBlockIds.has(id2)) {
+        if (chunk.type === "text-end") {
+          this.compactionTextBlockIds.delete(id2);
+        }
+        return true;
+      }
+    }
+    return false;
   }
   fireStall() {
     if (!this.session.isPending()) {
       return;
     }
     const idleTime = this.session.getTimeSinceLastActivity();
-    this.stallError = new StallTimeoutError(idleTime, this.maxIdleTimeMs);
+    this.stallError = new StallTimeoutError(idleTime, this.currentTimeoutMs());
     try {
       this.onStallCallback?.(this.stallError);
     } catch {
@@ -601680,6 +601958,19 @@ var IdleMonitor = class {
     this.stallCallbacks = [];
   }
 };
+function getChunkTextId(chunk) {
+  return "id" in chunk && typeof chunk.id === "string" ? chunk.id : void 0;
+}
+function isAnthropicCompactionMetadata(metadata) {
+  if (!isRecord(metadata)) {
+    return false;
+  }
+  const anthropic3 = metadata.anthropic;
+  return isRecord(anthropic3) && anthropic3.type === "compaction";
+}
+function isRecord(value2) {
+  return typeof value2 === "object" && value2 !== null;
+}
 
 // ../../../vite-plugin-file-sync/dist/ai-service/llm/stream/managed-stream.js
 init_cjs_shims();
@@ -601706,14 +601997,16 @@ function createManagedStream(source2, session, idleMonitor) {
             void session.events.emit("chunk", result.value, session);
             continue;
           }
-          session.recordChunk();
-          void session.events.emit("chunk", result.value, session);
           if (result.value.type === "error") {
             const chunkError = result.value.error;
+            session.resetActivityTimer();
+            void session.events.emit("chunk", result.value, session);
             closed = true;
             controller.error(chunkError);
             return;
           }
+          session.recordChunk();
+          void session.events.emit("chunk", result.value, session);
           controller.enqueue(result.value);
           return;
         } catch (error40) {
@@ -601792,11 +602085,6 @@ var RetryEngine = class {
       }
       return { shouldRetry: false, delayMs: 0, reason: "non-retryable" };
     }
-    const timeSinceActivity = session.getTimeSinceLastActivity();
-    const { maxTotalTimeMs } = this.config.retry;
-    if (timeSinceActivity >= maxTotalTimeMs) {
-      return { shouldRetry: false, delayMs: 0, reason: "max-time" };
-    }
     const { maxAttempts } = this.config.retry;
     if (session.attempt >= maxAttempts) {
       return { shouldRetry: false, delayMs: 0, reason: "max-attempts" };
@@ -601810,6 +602098,11 @@ var RetryEngine = class {
       }
       return { shouldRetry: false, delayMs: 0, reason: "max-attempts" };
     }
+    const timeSinceContent = session.getTimeSinceLastContent();
+    const { maxTotalTimeMs } = this.config.retry;
+    if (timeSinceContent >= maxTotalTimeMs) {
+      return { shouldRetry: false, delayMs: 0, reason: "max-time" };
+    }
     const delayMs = this.calculateDelay(session.attempt);
     return { shouldRetry: true, delayMs };
   }
@@ -602020,12 +602313,17 @@ var StreamSession = class {
   };
   error = null;
   outcome = "pending";
-  // tracks when we last received a chunk or started a retry, used for max-time checks.
+  // tracks when we last received a chunk, keep-alive, or started a retry; used
+  // for IdleMonitor liveness checks. NOT the retry max-time budget — that now
+  // measures getTimeSinceLastContent() so keep-alives can't extend it (APPS-4641).
   lastActivityTime;
+  // tracks when we last received a content chunk (NOT reset by keep-alives or retries).
+  lastContentTime;
   constructor(options8) {
     this.id = crypto.randomUUID();
     this.startTime = Date.now();
     this.lastActivityTime = this.startTime;
+    this.lastContentTime = this.startTime;
     this.config = options8.config;
     this.provider = options8.initialProvider;
     this.organizationId = options8.organizationId;
@@ -602082,6 +602380,7 @@ var StreamSession = class {
     }
     this.metrics.chunkCount++;
     this.lastActivityTime = Date.now();
+    this.lastContentTime = Date.now();
   }
   setTotalTokens(tokens) {
     this.metrics.totalTokens = tokens;
@@ -602092,14 +602391,30 @@ var StreamSession = class {
   getElapsedMs() {
     return Date.now() - this.startTime;
   }
-  // use this for max-time checks, NOT getElapsedMs(). we only want to timeout
-  // if nothing is happening, not if the stream has been running for a while.
+  // Time since the last activity of ANY kind (content, keep-alives, retries).
+  // Reset by resetActivityTimer() and recordRetry(), so it measures liveness,
+  // not real progress. Used by IdleMonitor's stall detection — NOT for the
+  // retry max-time budget (that uses getTimeSinceLastContent()).
   getTimeSinceLastActivity() {
     return Date.now() - this.lastActivityTime;
   }
+  // Time since the last CONTENT chunk. Unlike getTimeSinceLastActivity(), this is
+  // NOT reset by keep-alives (resetActivityTimer) or recordRetry — so it measures
+  // real progress across the whole session. Used by RetryEngine's max-time guard.
+  getTimeSinceLastContent() {
+    return Date.now() - this.lastContentTime;
+  }
   resetActivityTimer() {
     this.lastActivityTime = Date.now();
   }
+  // Advances both the liveness clock and the retry-budget content clock without
+  // touching content metrics (chunkCount / timeToFirstTokenMs). For upstream
+  // chunks that are real model output — proof of progress — but are filtered
+  // out before downstream consumers (server-side compaction deltas).
+  recordContentProgress() {
+    this.lastActivityTime = Date.now();
+    this.lastContentTime = Date.now();
+  }
 };
 
 // ../../../vite-plugin-file-sync/dist/ai-service/llm/stream/orchestrator.js
@@ -602150,6 +602465,7 @@ var StreamOrchestrator = class {
     await session.events.emit("session:start", session, {
       system: options8.system,
       messages: options8.messages ?? [],
+      user: options8.user,
       tools: options8.tools
     });
     internalAbortController.signal.addEventListener("abort", () => {
@@ -602158,14 +602474,30 @@ var StreamOrchestrator = class {
     const idleMonitor = new IdleMonitor({
       session,
       maxIdleTimeMs: this.config.retry.idleTimeoutMs,
+      firstChunkTimeoutMs: this.config.retry.firstChunkTimeoutMs,
+      onServerCompactionStart: (blockId) => {
+        this.logger.debug("[orchestrator] Server-side compaction chunk detected; holding first-chunk idle budget", {
+          sessionId: session.id,
+          provider: session.provider.name,
+          model: session.provider.model,
+          attempt: session.attempt,
+          blockId,
+          firstChunkTimeoutMs: this.config.retry.firstChunkTimeoutMs
+        });
+      },
       onStall: (error40) => {
+        const budgetKind = error40.maxIdleTimeMs === this.config.retry.firstChunkTimeoutMs ? "first-chunk" : "inter-chunk";
         this.logger.warn(`[orchestrator] Idle timeout exceeded, triggering retry`, {
           sessionId: session.id,
           provider: session.provider.name,
           model: session.provider.model,
           attempt: session.attempt,
+          budgetKind,
           idleMs: error40.idleTimeMs,
+          budgetMs: error40.maxIdleTimeMs,
           maxIdleTimeMs: error40.maxIdleTimeMs,
+          firstChunkTimeoutMs: this.config.retry.firstChunkTimeoutMs,
+          idleTimeoutMs: this.config.retry.idleTimeoutMs,
           elapsedMs: session.getElapsedMs(),
           chunksReceived: session.metrics.chunkCount
         });
@@ -604050,14 +604382,20 @@ var LLMClient = class {
       const fallbackEnabled = this.unifiedProviderEnabled && (enableFallback ?? false);
       logger21.info(`[llm-client] provider=${providerConfig.provider} model=${providerConfig.model} unifiedProvider=${this.unifiedProviderEnabled} fallback=${fallbackEnabled} retry=${safeJsonStringify(retryConfig)}`);
       const extendedThinking = usesAdaptiveEffort(providerConfig.model) || providerConfig.model === "claude-opus-4-6";
-      const defaultMaxTotalTimeMs = extendedThinking ? 5 * 60 * 1e3 : 2 * 60 * 1e3;
+      const defaultMaxTotalTimeMs = extendedThinking ? 30 * 60 * 1e3 : 15 * 60 * 1e3;
       const defaultIdleTimeoutMs = extendedThinking ? 18e4 : 9e4;
+      const resolvedIdleTimeoutMs = retryConfig?.idleTimeoutMs ?? this.retryOptions?.idleTimeoutMs ?? defaultIdleTimeoutMs;
+      const serverSideContextManagement = contextConfig?.contextManagement?.type === "server";
+      const resolvedFirstChunkTimeoutMs = retryConfig?.firstChunkTimeoutMs ?? this.retryOptions?.firstChunkTimeoutMs ?? defaultFirstChunkTimeoutMs(serverSideContextManagement, resolvedIdleTimeoutMs);
+      const proxyStallTimeoutMs = extendedThinking ? 9e5 : 45e4;
+      const resolvedMaxTotalTimeMs = Math.max(retryConfig?.maxTotalTimeMs ?? this.retryOptions?.maxTotalTimeMs ?? defaultMaxTotalTimeMs, resolvedFirstChunkTimeoutMs, proxyStallTimeoutMs);
       const config4 = StreamConfig.create({
         retry: {
           ...this.retryOptions,
           ...retryConfig,
-          maxTotalTimeMs: retryConfig?.maxTotalTimeMs ?? this.retryOptions?.maxTotalTimeMs ?? defaultMaxTotalTimeMs,
-          idleTimeoutMs: retryConfig?.idleTimeoutMs ?? this.retryOptions?.idleTimeoutMs ?? defaultIdleTimeoutMs
+          maxTotalTimeMs: resolvedMaxTotalTimeMs,
+          idleTimeoutMs: resolvedIdleTimeoutMs,
+          firstChunkTimeoutMs: resolvedFirstChunkTimeoutMs
         },
         provider: providerConfig.provider,
         model: providerConfig.model,
@@ -609622,7 +609960,7 @@ var PlaywrightMcpServerManager = class {
       this.logger.info(`Starting embedded Playwright MCP server: browser=${options8?.browser || "chromium"}, headless=${options8?.headless !== false}`);
     }
     try {
-      const { startEmbeddedPlaywrightMcpServer } = await import("./embedded-playwright-mcp-server-UGIS3FHL.js");
+      const { startEmbeddedPlaywrightMcpServer } = await import("./embedded-playwright-mcp-server-55KSMVXX.js");
       this.server = await startEmbeddedPlaywrightMcpServer({
         storageStatePath: options8?.storageStatePath,
         jwt: options8?.jwt,
@@ -610000,6 +610338,46 @@ REQUIREMENTS:
 - When referencing integrations, use the @Integration[id=<UUID>] syntax so they render as tags in the UI. For example: "This API connects to @Integration[id=abc-123] to fetch order data."`;
 }
 
+// ../../../vite-plugin-file-sync/dist/ai-service/request-deduplicator.js
+init_cjs_shims();
+var RequestDeduplicator = class {
+  maxSize;
+  seen = /* @__PURE__ */ new Set();
+  constructor(maxSize = 200) {
+    this.maxSize = maxSize;
+  }
+  /** Returns true if the id was already recorded, without recording it. */
+  has(requestId) {
+    return this.seen.has(requestId);
+  }
+  /**
+   * Records the id if it has not been seen before. Returns true when the id is
+   * new (the caller should proceed) and false when it is a duplicate (the
+   * caller should treat the command as already handled).
+   */
+  markIfNew(requestId) {
+    if (this.seen.has(requestId)) {
+      return false;
+    }
+    this.seen.add(requestId);
+    if (this.seen.size > this.maxSize) {
+      const oldest = this.seen.values().next().value;
+      if (oldest !== void 0) {
+        this.seen.delete(oldest);
+      }
+    }
+    return true;
+  }
+  /**
+   * Removes a previously-recorded id. Use when a command was recorded but never
+   * actually started (e.g. it threw during setup), so a legitimate reconnect
+   * re-send of the same command is not mistakenly swallowed as a duplicate.
+   */
+  forget(requestId) {
+    this.seen.delete(requestId);
+  }
+};
+
 // ../../../vite-plugin-file-sync/dist/ai-service/state-machine/handlers/agent-planning.js
 init_cjs_shims();
 
@@ -610763,7 +611141,7 @@ var transitionFrom = (clark) => {
 };
 
 // ../../../vite-plugin-file-sync/dist/ai-service/state-machine/handlers/agent-planning.js
-var FETCH_INTEGRATIONS_RECONNECT_BUDGET_MS = 15e3;
+var FETCH_INTEGRATIONS_RECONNECT_BUDGET_MS = 5e3;
 var MAX_DEBUG_ATTEMPTS = 5;
 function getTerminalErrorMessage(error40) {
   const { type, provider, data: data3 } = error40;
@@ -610787,6 +611165,8 @@ function getTerminalErrorMessage(error40) {
       return "The AI model returned an error. Please retry your prompt below. If the problem persists, the model provider may be experiencing issues.";
     case "timeout":
       return "The request timed out. Please check your connection and try again.";
+    case "stall":
+      return "The AI model stopped responding mid-generation. Please retry your prompt below. If the problem persists, please open a support ticket.";
     case "overloaded":
       return "The model is currently busy. Please retry your prompt below.";
     case "network":
@@ -611134,12 +611514,21 @@ Address the errors and return the fixed code.`;
         try {
           await fetchWithReconnectRetry(clark.context.peer, () => params.integrationStore.fetchIntegrations(clark.context.peer, availableIntegrations ?? []), { reconnectBudgetMs: FETCH_INTEGRATIONS_RECONNECT_BUDGET_MS });
         } catch (error40) {
-          getLogger3().error(`[agent-planning] Failed to fetch integrations`, getErrorMeta2(error40));
-          void transitionTo({
-            type: AGENT_CANCELED,
-            advice: "Failed to fetch integrations from the browser. Please refresh the page and try again."
-          });
-          return;
+          const isTransient = error40 instanceof RpcTimeoutError || isTransportCloseError(error40);
+          if (isTransient) {
+            getLogger3().warn(`[agent-planning] Failed to fetch integrations \u2014 proceeding without full integration metadata`, {
+              ...getErrorMeta2(error40),
+              degradedMode: true,
+              errorType: error40 instanceof Error ? error40.constructor.name : typeof error40
+            });
+          } else {
+            getLogger3().error(`[agent-planning] Failed to fetch integrations`, getErrorMeta2(error40));
+            void transitionTo({
+              type: AGENT_CANCELED,
+              advice: "Failed to fetch integrations from the browser. Please refresh the page and try again."
+            });
+            return;
+          }
         }
         getLogger3().info("Agent planning storing llmConfig in context:", request.llmConfig || {});
         const disabledTools = request.llmConfig?.disabledTools;
@@ -616137,6 +616526,7 @@ var AiService = class extends import_shared48.TracedEventEmitter {
   llmClient;
   stablePeer = new StablePeer();
   toolRegistry = new ToolRegistry();
+  requestDeduplicator = new RequestDeduplicator();
   entityPermissionStore = new SessionEntityPermissionStore();
   _onGenerationCompleteCallback;
   tokenManagerJwt;
@@ -616416,24 +616806,7 @@ var AiService = class extends import_shared48.TracedEventEmitter {
           planApproved: this.clark?.context?.planContext?.approved
         };
       },
-      remoteRestoreFallback: async (id2) => {
-        const jwt2 = this.getJwt();
-        const commitId = this._syncContextProvider?.getLastCommitId() ?? await this.chatSessionStore.getLatestCommitId();
-        const branchName = this._syncContextProvider?.getBranchName();
-        if (!jwt2 || !commitId || !branchName) {
-          return null;
-        }
-        return downloadContextFromBucketeer({
-          applicationId: config4.applicationId,
-          commitId,
-          branchName,
-          superblocksBaseUrl: config4.superblocksBaseUrl,
-          logger: this.getLogger(),
-          jwt: jwt2,
-          contextId: id2,
-          appRootDirPath: config4.appRootDirPath
-        });
-      }
+      remoteRestoreFallback: (id2) => this.remoteRestoreFallback(id2)
     });
     this.llmClient = new LLMClient({
       contextManagerV2: this.contextManagerV2,
@@ -616677,6 +617050,43 @@ var AiService = class extends import_shared48.TracedEventEmitter {
       };
     };
   }
+  /**
+   * Resolves the conversation context for a contextId that is not present
+   * locally, by downloading it from Bucketeer. Wired into ContextManagerV2 as
+   * its `remoteRestoreFallback`, so it runs on a cold/recycled pod where the
+   * editor reconnects and no local context exists.
+   *
+   * The download is keyed by commitId. It prefers `syncService.lastCommitId`
+   * (which `downloadDirectory()` seeds from the server's latest non-draft
+   * commit — the exact key the post-generation context upload uses) and only
+   * falls back to the most recent chat-history commitId when the sync service
+   * has none. Resolving the wrong key here is the context-loss this guards
+   * against, so the resolution is logged.
+   */
+  async remoteRestoreFallback(id2) {
+    const jwt2 = this.getJwt();
+    const lastCommitId = this._syncContextProvider?.getLastCommitId();
+    const commitId = lastCommitId ?? await this.chatSessionStore.getLatestCommitId();
+    const commitIdSource = lastCommitId ? "syncService.lastCommitId" : commitId ? "chatSessionStore.getLatestCommitId" : "unavailable";
+    const branchName = this._syncContextProvider?.getBranchName();
+    if (!jwt2 || !commitId || !branchName) {
+      if (jwt2) {
+        this.getLogger().warn(`[context-restore] remoteRestoreFallback found no restore key: commitId=${commitId ?? "<none>"} source=${commitIdSource} branch=${branchName ?? "<none>"}`);
+      }
+      return null;
+    }
+    this.getLogger().info(`[context-restore] remoteRestoreFallback resolved commitId=${commitId} source=${commitIdSource} branch=${branchName}`);
+    return downloadContextFromBucketeer({
+      applicationId: this.config.applicationId,
+      commitId,
+      branchName,
+      superblocksBaseUrl: this.config.superblocksBaseUrl,
+      logger: this.getLogger(),
+      jwt: jwt2,
+      contextId: id2,
+      appRootDirPath: this.config.appRootDirPath
+    });
+  }
   getJwt() {
     if (this.tokenManagerJwt) {
       return this.tokenManagerJwt;
@@ -616908,53 +617318,68 @@ var AiService = class extends import_shared48.TracedEventEmitter {
     if (this.clark.state === ClarkStateNames.Dead) {
       throw new Error("Service is unavailable");
     }
+    if (request.requestId && this.requestDeduplicator.has(request.requestId)) {
+      this.getLogger().info("[ai-service] Ignoring duplicate aiGenerate re-send", { requestId: request.requestId });
+      return;
+    }
     if (this.isBusy()) {
       this.getLogger().warn("[ai-service] Service is busy. State:", this.clark.state);
       throw new Error("Service is busy");
     }
     await this.ensureAiQuotaAvailable(request.jwt);
-    this.clarkProfiler.startSession();
-    getLogger3().info("AI Service received request with llmConfig:", request.llmConfig || {});
-    getLogger3().info("[ai-service] handleAiGenerate received request", {
-      requestMode: request.mode,
-      currentContextMode: this.clark.context.currentMode,
-      requestPlanContextApproved: request.planContext?.approved,
-      existingPlanContextApproved: this.clark.context.planContext?.approved,
-      responseMetadataType: request.responseMetadata?.type
-    });
-    const promptId = randomUUID3();
-    getLogger3().info("[ai-service] Generated prompt_id for user interaction", {
-      promptId,
-      applicationId: this.config.applicationId
-    });
-    this.clark.updateContext((context2) => {
-      return {
-        ...context2,
+    if (request.requestId && !this.requestDeduplicator.markIfNew(request.requestId)) {
+      this.getLogger().warn("[ai-service] Ignoring duplicate aiGenerate re-send (lost dedup race)", { requestId: request.requestId });
+      return;
+    }
+    try {
+      this.clarkProfiler.startSession();
+      getLogger3().info("AI Service received request with llmConfig:", request.llmConfig || {});
+      getLogger3().info("[ai-service] handleAiGenerate received request", {
+        requestMode: request.mode,
+        currentContextMode: this.clark.context.currentMode,
+        requestPlanContextApproved: request.planContext?.approved,
+        existingPlanContextApproved: this.clark.context.planContext?.approved,
+        responseMetadataType: request.responseMetadata?.type
+      });
+      const promptId = randomUUID3();
+      getLogger3().info("[ai-service] Generated prompt_id for user interaction", {
         promptId,
-        useMockGeneration: request.mockGeneration ?? false,
-        planContext: mergePlanContexts(context2.planContext, request.planContext),
-        browserContext: request.browserContext,
-        // Initialize workflow metrics tracking
-        workflowMetrics: {
-          toolCallCount: 0,
-          stepCount: 0,
-          linesAdded: 0,
-          linesEdited: 0,
-          linesRemoved: 0,
-          llmUsage: [],
-          llmCallCount: 0,
-          workflowStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        llmConfig: request.llmConfig,
-        partialResponse: void 0,
-        userPreferences: request.userPreferences
-      };
-    });
-    const transitionTo = transitionFrom(this.clark);
-    void transitionTo({
-      type: USER_SENT_PROMPT,
-      request
-    });
+        applicationId: this.config.applicationId
+      });
+      this.clark.updateContext((context2) => {
+        return {
+          ...context2,
+          promptId,
+          useMockGeneration: request.mockGeneration ?? false,
+          planContext: mergePlanContexts(context2.planContext, request.planContext),
+          browserContext: request.browserContext,
+          // Initialize workflow metrics tracking
+          workflowMetrics: {
+            toolCallCount: 0,
+            stepCount: 0,
+            linesAdded: 0,
+            linesEdited: 0,
+            linesRemoved: 0,
+            llmUsage: [],
+            llmCallCount: 0,
+            workflowStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          llmConfig: request.llmConfig,
+          partialResponse: void 0,
+          userPreferences: request.userPreferences
+        };
+      });
+      const transitionTo = transitionFrom(this.clark);
+      void transitionTo({
+        type: USER_SENT_PROMPT,
+        request
+      });
+    } catch (error40) {
+      if (request.requestId) {
+        this.requestDeduplicator.forget(request.requestId);
+      }
+      throw error40;
+    }
   }
   async handleAiExplainCode(request) {
     if (this.clark.state === ClarkStateNames.Dead) {
@@ -617508,6 +617933,10 @@ ${normalizedTextAttachment.content}
     if (this.clark.state === ClarkStateNames.Dead) {
       throw new Error("Service is unavailable");
     }
+    if (request.requestId && this.requestDeduplicator.has(request.requestId)) {
+      this.getLogger().info("[ai-service] Ignoring duplicate aiGenerateWithQueue re-send", { requestId: request.requestId, mode });
+      return { status: "started" };
+    }
     if (!this.isBusy()) {
       await this.handleAiGenerate(request);
       return { status: "started" };
@@ -617635,6 +618064,12 @@ ${request.prompt}`;
   async handleAiRespondToToolPermission(request) {
     const logger21 = this.getLogger();
     logger21.info(`[ai-service] handleAiRespondToToolPermission: messageId=${request.messageId}, approved=${request.approved}`);
+    if (request.requestId && this.requestDeduplicator.has(request.requestId)) {
+      logger21.info("[ai-service] Ignoring duplicate tool-permission re-send", {
+        requestId: request.requestId
+      });
+      return;
+    }
     const pendingRequest = this.clark.context.pendingToolPermissionRequest;
     logger21.info(`[ai-service] Pending request: ${JSON.stringify(pendingRequest)}`);
     if (!pendingRequest) {
@@ -617645,6 +618080,10 @@ ${request.prompt}`;
       logger21.warn(`[ai-service] Message ID mismatch: expected=${pendingRequest.messageId}, got=${request.messageId}`);
       throw new Error("Message ID mismatch");
     }
+    if (request.requestId && !this.requestDeduplicator.markIfNew(request.requestId)) {
+      logger21.warn("[ai-service] Ignoring duplicate tool-permission re-send (lost dedup race)", { requestId: request.requestId });
+      return;
+    }
     logger21.info(`[ai-service] Clearing pending request`);
     clearPendingToolPermissionRequest(this.clark, "tool-permission-response");
     const toolCallId = pendingRequest.messageId;
@@ -618779,20 +619218,21 @@ async function getApplicationDirectoryHash(rpcClient, applicationId, branch, loc
     getDraftOrLiveDirectoryHash(rpcClient, applicationId, branch),
     hashLocalDirectory(localDirectoryPath)
   ]);
-  const directoryHash = draftOrLiveEditHash;
+  const directoryHash = draftOrLiveEditHash.hash;
   if (!directoryHash) {
     throw new Error("No live edit hash found");
   }
   return {
     serverDirectoryHash: directoryHash,
+    latestNonDraftCommitId: draftOrLiveEditHash.latestNonDraftCommitId,
     localDirectoryStatePreDownload
   };
 }
 async function downloadApplicationDirectory({ rpcClient, applicationId, branch, localDirectoryPath, hashCache }) {
-  const { serverDirectoryHash, localDirectoryStatePreDownload } = await getApplicationDirectoryHash(rpcClient, applicationId, branch, localDirectoryPath);
+  const { serverDirectoryHash, latestNonDraftCommitId, localDirectoryStatePreDownload } = await getApplicationDirectoryHash(rpcClient, applicationId, branch, localDirectoryPath);
   const directoryState = await doDownloadApplicationDirectory(rpcClient, serverDirectoryHash, localDirectoryStatePreDownload, localDirectoryPath);
   hashCache.add_directory_recursive(directoryState);
-  return serverDirectoryHash;
+  return { directoryHash: serverDirectoryHash, latestNonDraftCommitId };
 }
 async function doDownloadApplicationDirectory(rpcClient, directoryHash, oldLocalDirState, localDirectoryPath) {
   const hashesToGet = {};
@@ -618886,7 +619326,10 @@ async function getDraftOrLiveDirectoryHash(rpcClient, applicationId, branch) {
       branchName: branch,
       viewMode: import_shared51.ExportViewMode.EXPORT_DRAFT
     }));
-    return response.hash;
+    return {
+      hash: response.hash,
+      latestNonDraftCommitId: response.latestNonDraftCommitId
+    };
   } catch (e) {
     if (e instanceof import_shared50.NotFoundError) {
       const response = await (0, import_shared50.unwrapResponseDto)(rpcClient.call.v3.application.directoryContents.get({
@@ -618895,7 +619338,10 @@ async function getDraftOrLiveDirectoryHash(rpcClient, applicationId, branch) {
         viewMode: import_shared51.ExportViewMode.EXPORT_LIVE
       }));
       getLogger3().warn(`Draft state not found, using live edit hash: ${response.hash}`);
-      return response.hash;
+      return {
+        hash: response.hash,
+        latestNonDraftCommitId: response.latestNonDraftCommitId
+      };
     }
     throw e;
   }
@@ -619461,6 +619907,9 @@ function isDevOrLocal() {
   const env2 = process.env.SUPERBLOCKS_SERVER_ENV ?? process.env.SUPERBLOCKS_ENVIRONMENT;
   return env2 === "dev" || env2 === "local";
 }
+function shouldSeedLastCommitId(currentLastCommitId, incomingCommitId) {
+  return Boolean(incomingCommitId) && !currentLastCommitId;
+}
 function getSyncErrorLogLevel(error40) {
   const msg = error40?.message ?? "";
   if (msg.includes("RPC client is shutting down") || msg.includes("Connection closed")) {
@@ -619554,6 +620003,7 @@ var SyncService = class extends import_shared54.TracedEventEmitter {
     this.pendingSyncUp = void 0;
     this.lastSyncedDirectoryHash = void 0;
     this.lastSyncedGenerationNumber = void 0;
+    this.lastCommitId = void 0;
     this.synchronizationStatus = SyncronizationStatus.SERVER_AHEAD;
     this.getLogger().info(`[sync-service] switched branch context from '${previousBranchName}' to '${nextBranchName}'`);
   }
@@ -619599,7 +620049,7 @@ var SyncService = class extends import_shared54.TracedEventEmitter {
     return this.fsOperation(async () => {
       this.status = SyncServiceStatus.DOWNLOADING;
       try {
-        const directoryHash = await this._rpcClient.call(async (rpcClient) => {
+        const { directoryHash, latestNonDraftCommitId } = await this._rpcClient.call(async (rpcClient) => {
           return await downloadApplicationDirectory({
             rpcClient,
             applicationId: this.applicationId,
@@ -619609,6 +620059,19 @@ var SyncService = class extends import_shared54.TracedEventEmitter {
           });
         });
         this.lastSyncedDirectoryHash = directoryHash;
+        if (shouldSeedLastCommitId(this.lastCommitId, latestNonDraftCommitId)) {
+          this.lastCommitId = latestNonDraftCommitId;
+          this.emit("commitIdChanged", latestNonDraftCommitId);
+          this.getLogger().info(`[sync-service] seeded lastCommitId=${latestNonDraftCommitId} appId=${this.applicationId} branch=${this._branchName ?? "<none>"} from server on cold-pod download`);
+        } else if (latestNonDraftCommitId && this.lastCommitId) {
+          if (this.lastCommitId !== latestNonDraftCommitId) {
+            this.getLogger().info(`[sync-service] warm reconnect: kept lastCommitId=${this.lastCommitId}, server returned ${latestNonDraftCommitId} (values differ, not overwriting) appId=${this.applicationId}`);
+          } else {
+            this.getLogger().debug(`[sync-service] warm reconnect: kept lastCommitId=${this.lastCommitId}, server returned matching value appId=${this.applicationId}`);
+          }
+        } else if (!latestNonDraftCommitId && !this.lastCommitId) {
+          this.getLogger().debug(`[sync-service] cold-pod download: server returned no non-draft commitId (new app or draft-only branch), context restore will fall back to chat history appId=${this.applicationId} branch=${this._branchName ?? "<none>"}`);
+        }
         this.synchronizationStatus = SyncronizationStatus.IN_SYNC;
         this.getLogger().info("[sync-service] Synchronization finished");
       } catch (err) {
@@ -620757,6 +621220,10 @@ var LockService = class extends import_shared57.TracedEventEmitter {
       this.getLogger().info("[lock-service] lock release already in progress, skipping duplicate evaluation");
       return;
     }
+    if (this._isRestarting) {
+      this.getLogger().info("[lock-service] restart in progress, skipping lock state evaluation");
+      return;
+    }
     if (this.waitForGenerationCompleteCallback) {
       this.getLogger().debug("[lock-service] waiting for Clark generation to complete before evaluating lock state");
       await this.waitForGenerationCompleteCallback();
@@ -620773,20 +621240,20 @@ var LockService = class extends import_shared57.TracedEventEmitter {
         this.getLogger().debug(`[lock-service] user disconnected but was recently active, waiting for ${this._lockBufferMs}ms buffer period before releasing lock`);
         this._bufferPeriodTimeout = setTimeout(() => {
           this.getLogger().debug("[lock-service] buffer period expired, releasing lock");
-          if (this.lockType === LockType.LOCAL) {
-            void this.shutdownAndExit();
-          } else {
-            void this.shutdown({ serverInitiated: false });
+          if (this._isRestarting) {
+            this.getLogger().info("[lock-service] restart in progress, skipping buffer-period shutdown");
+            return;
           }
+          void this.shutdownAndExit();
         }, this._lockBufferMs);
         this._bufferPeriodTimeout.unref();
       } else {
         this.getLogger().debug("[lock-service] user disconnected and was not recently active, releasing lock immediately");
-        if (this.lockType === LockType.LOCAL) {
-          await this.shutdownAndExit();
-        } else {
-          await this.shutdown({ serverInitiated: false });
+        if (this._isRestarting) {
+          this.getLogger().info("[lock-service] restart in progress, skipping immediate shutdown");
+          return;
         }
+        await this.shutdownAndExit();
       }
     } else {
       this.getLogger().debug("[lock-service] user inactive but still connected, marking lock as ready for takeover");
@@ -620819,9 +621286,16 @@ var LockService = class extends import_shared57.TracedEventEmitter {
   markActivity(isUserActive) {
     this._activityTracker.markActivity(isUserActive);
   }
-  /** when the dev server is restarting, we will use the 5-minute shutdown timer instead of the instant one */
+  /** Mark the dev server as restarting. Prevents evaluateLockState() from calling
+   * shutdownAndExit() (which would fire process.exit(1)) while the restart handler
+   * intends to exit with RESTART_EXIT_CODE. Also cancels any pending buffer timeout. */
   async setIsRestarting() {
     this._isRestarting = true;
+    if (this._bufferPeriodTimeout) {
+      clearTimeout(this._bufferPeriodTimeout);
+      this._bufferPeriodTimeout = void 0;
+      this.getLogger().info("[lock-service] cleared pending buffer timeout on restart");
+    }
   }
 };
 
@@ -644679,7 +645153,7 @@ var parseYaml3;
 async function loadYaml(file2) {
   const content17 = await read_file_default(file2);
   if (!parseYaml3) {
-    ({ __parsePrettierYamlConfig: parseYaml3 } = await import("./yaml-JLRXP2CH.js"));
+    ({ __parsePrettierYamlConfig: parseYaml3 } = await import("./yaml-KLI3RE6K.js"));
   }
   try {
     return parseYaml3(content17);
@@ -650073,7 +650547,7 @@ function createParsersAndPrinters(modules) {
 }
 var estreePlugin = createParsersAndPrinters([
   {
-    importPlugin: () => import("./estree-TCD2UGUS.js"),
+    importPlugin: () => import("./estree-XHRBZXDB.js"),
     printers: ["estree", "estree-json"]
   }
 ]);
@@ -650097,11 +650571,11 @@ var languages = [
 ];
 var { parsers: parsers12, printers } = createParsersAndPrinters([
   {
-    importPlugin: () => import("./acorn-ZN7Q6UDZ.js"),
+    importPlugin: () => import("./acorn-RVXTUPIU.js"),
     parsers: ["acorn", "espree"]
   },
   {
-    importPlugin: () => import("./angular-J2MXKXGC.js"),
+    importPlugin: () => import("./angular-3LHQBAFX.js"),
     parsers: [
       "__ng_action",
       "__ng_binding",
@@ -650110,7 +650584,7 @@ var { parsers: parsers12, printers } = createParsersAndPrinters([
     ]
   },
   {
-    importPlugin: () => import("./babel-O4PIWZ7M.js"),
+    importPlugin: () => import("./babel-EJ6IVCOP.js"),
     parsers: [
       "babel",
       "babel-flow",
@@ -650129,44 +650603,44 @@ var { parsers: parsers12, printers } = createParsersAndPrinters([
     ]
   },
   {
-    importPlugin: () => import("./flow-DTJ5KXYK.js"),
+    importPlugin: () => import("./flow-PO73QWID.js"),
     parsers: ["flow"]
   },
   {
-    importPlugin: () => import("./glimmer-AER7O7UD.js"),
+    importPlugin: () => import("./glimmer-YNVOZBDJ.js"),
     parsers: ["glimmer"],
     printers: ["glimmer"]
   },
   {
-    importPlugin: () => import("./graphql-ZCGKT3ML.js"),
+    importPlugin: () => import("./graphql-HFTLPD2K.js"),
     parsers: ["graphql"],
     printers: ["graphql"]
   },
   {
-    importPlugin: () => import("./html-V3FHSD2D.js"),
+    importPlugin: () => import("./html-EY72FROY.js"),
     parsers: ["html", "angular", "vue", "lwc", "mjml"],
     printers: ["html"]
   },
   {
-    importPlugin: () => import("./markdown-F4OH2TLC.js"),
+    importPlugin: () => import("./markdown-BG67LRMX.js"),
     parsers: ["markdown", "mdx", "remark"],
     printers: ["mdast"]
   },
   {
-    importPlugin: () => import("./meriyah-7WDK4UW6.js"),
+    importPlugin: () => import("./meriyah-3TDTM3WJ.js"),
     parsers: ["meriyah"]
   },
   {
-    importPlugin: () => import("./postcss-DWK3YRY3.js"),
+    importPlugin: () => import("./postcss-YODQYYIW.js"),
     parsers: ["css", "less", "scss"],
     printers: ["postcss"]
   },
   {
-    importPlugin: () => import("./typescript-VF6VJIWL.js"),
+    importPlugin: () => import("./typescript-GS5XECMQ.js"),
     parsers: ["typescript"]
   },
   {
-    importPlugin: () => import("./yaml-JLRXP2CH.js"),
+    importPlugin: () => import("./yaml-KLI3RE6K.js"),
     parsers: ["yaml"],
     printers: ["yaml"]
   }
@@ -667310,7 +667784,7 @@ async function handleLockConflict(error40, lockSvc, span, logger21) {
 }
 async function readPkgJson(cwd) {
   try {
-    const { readPackage } = await import("./read-pkg-DM7BQWMA.js");
+    const { readPackage } = await import("./read-pkg-RLPLKGXT.js");
     return await readPackage({ cwd });
   } catch {
     return null;
@@ -669004,4 +669478,4 @@ serve-static/index.js:
 chokidar/esm/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-NPJMB63E.js.map
+//# sourceMappingURL=chunk-CFDMQXWR.js.map