@skaile/workspaces 3.13.0 → 3.14.1

package/dist/{chunk-YIPVMBCG.js → chunk-ZPCHTTD7.js}

@@ -1,9 +1,9 @@
-import { WorkspacePlugin } from './chunk-SVCJ5WRP.js';
+import { WorkspacePlugin } from './chunk-UTW6YKAC.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
-import { resolveFlowPath } from './chunk-I7G3ZNYE.js';
+import { resolveFlowPath } from './chunk-VW6RUT7X.js';
 import { findAiAssetsRoot, deployCatalogEntry, undeployCatalogEntry } from './chunk-GHWJHOYX.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-YSAYNSML.js';
+import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-KKMRT6GU.js';
 import { loadConnectorDeclarations, SecretProviderChain, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-3UU3D2Q3.js';
 import { EventNormalizer } from './chunk-2A7BV6WT.js';
 import { SUPPORTED_CLOUDS, probeResumeTranscript, CLOUD_SECRET_ENV_KEYS } from './chunk-RUFTB7QN.js';
@@ -3123,6 +3123,108 @@ function cleanupCloudCredentialFiles(projectDir) {
   }
 }
 
+// runner/src/compaction-gate.ts
+var CompactionGate = class {
+  /**
+   * Every compaction currently holding the driver.
+   *
+   * A set rather than a boolean because holds can overlap: a driver swap
+   * rebuilds the orchestrator, and the new instance carries its own
+   * `_isCompacting`, so it can start a compaction while the previous
+   * instance's call is still unwinding. Keyed by handle so the older one
+   * settling cannot open the gate under the newer one — the same identity
+   * check `DriverSwapGate.beginSwap` makes for swaps.
+   */
+  held = /* @__PURE__ */ new Set();
+  /** Resolves when the last hold is released. Null whenever the driver is free. */
+  opened = null;
+  release = null;
+  /**
+   * Mark a compaction as occupying the driver. The returned handle is the only
+   * thing that can release it.
+   */
+  begin() {
+    const hold = /* @__PURE__ */ Symbol("compaction");
+    if (this.held.size === 0) {
+      this.opened = new Promise((resolve4) => {
+        this.release = resolve4;
+      });
+    }
+    this.held.add(hold);
+    return hold;
+  }
+  /**
+   * Release one hold, opening the gate once none remain. Unknown and null
+   * handles are ignored, so a settle signal that fires without a matching
+   * `begin()` is harmless.
+   *
+   * Call this from a signal the orchestrator emits unconditionally. A `begin()`
+   * whose `settle()` can be skipped holds user turns forever, which is a worse
+   * failure than the discarded reply this gate exists to prevent.
+   */
+  settle(hold) {
+    if (hold == null || !this.held.delete(hold)) return;
+    if (this.held.size > 0) return;
+    const release = this.release;
+    this.opened = null;
+    this.release = null;
+    release?.();
+  }
+  /**
+   * Wait for the driver to be free.
+   *
+   * Returns `idle` when nothing was in flight, `waited` when every compaction
+   * settled within the bound, and `timeout` when they did not. A caller that
+   * gets `timeout` must surface it rather than dispatch: a compaction still
+   * holding the driver past this bound is stuck, and dispatching into it
+   * reproduces the silent loss.
+   *
+   * Re-checks in a loop, as `DriverSwapGate.awaitSwap` does, so a compaction
+   * armed while this turn was already waiting is also awaited. `timeoutMs`
+   * bounds the whole wait, not each iteration.
+   */
+  async awaitIdle(timeoutMs) {
+    if (this.held.size === 0) return "idle";
+    const deadline = Date.now() + timeoutMs;
+    let waited = false;
+    while (this.held.size > 0) {
+      const opened = this.opened;
+      if (!opened) break;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return "timeout";
+      if (await raceDeadline(opened, remaining) === "timeout") return "timeout";
+      waited = true;
+    }
+    return waited ? "waited" : "idle";
+  }
+};
+async function raceDeadline(opened, ms) {
+  let timer;
+  const expired = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4("timeout"), ms);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([opened.then(() => "opened"), expired]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var DEFAULT_COMPACTION_GATE_TIMEOUT_MS = 60 * 6e4;
+function compactionGateTimeoutMs() {
+  const raw = Number(process.env.SKAILE_COMPACTION_GATE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_GATE_TIMEOUT_MS;
+}
+var COMPACTION_GATE_TIMEOUT_MESSAGE = "The session is still compacting its history and could not take this message. Send it again in a moment.";
+async function guardTurnAgainstCompaction(deps) {
+  const outcome = await deps.gate.awaitIdle(deps.timeoutMs ?? compactionGateTimeoutMs());
+  if (outcome === "waited") deps.log(`[serve] ${deps.what} released after compaction settled`);
+  if (outcome !== "timeout") return true;
+  deps.log(`[serve] ${deps.what} abandoned: a compaction has held the driver past its bound`);
+  deps.sendEvent({ type: "error", message: COMPACTION_GATE_TIMEOUT_MESSAGE, fatal: false });
+  return false;
+}
+
 // runner/src/driver-swap-gate.ts
 var DriverSwapGate = class {
   /** Resolves when the in-flight driver recreate settles (resolve or reject). */
@@ -3244,6 +3346,14 @@ What still needs to be done or is waiting on user input.
 
 ### Context
 User preferences, constraints, or instructions that must carry forward.`;
+var RE_COMPACTION_MERGE_INSTRUCTION = `This conversation has already been compacted once. The summary below replaced
+everything that came before it, and your reply will in turn replace this
+summary -- anything you leave out is lost for good.
+
+Your reply must be the COMPLETE merged summary in the section format above:
+restate everything from the previous summary that still matters, then fold in
+what has happened since. Do NOT reply with a delta, a diff, a list of changes,
+or a note that the previous summary still applies.`;
 function buildCompactionPrompt(opts) {
   const base = opts.agentPrompt ?? DEFAULT_COMPACTION_PROMPT;
   const parts = [base];
@@ -3256,6 +3366,19 @@ function buildCompactionPrompt(opts) {
 ${allDirectives.map((d) => `- ${d}`).join("\n")}`
     );
   }
+  if (opts.previousSummary) {
+    parts.push(
+      `
+
+## Previous Summary
+
+<previous_summary>
+${opts.previousSummary}
+</previous_summary>
+
+${RE_COMPACTION_MERGE_INSTRUCTION}`
+    );
+  }
   if (opts.focus) {
     parts.push(`
 
@@ -3287,6 +3410,31 @@ var TokenThresholdStrategy = class {
 var MIN_SUMMARY_CHARS = 200;
 var MAX_COMPRESSION_RATIO = 0.9;
 var DEFAULT_CONTEXT_WINDOW = 2e5;
+var ONE_MILLION_CONTEXT_WINDOW = 1e6;
+var ONE_MILLION_ALIAS_PATTERN = /\[1m\]|-1m$/i;
+var DEFAULT_COMPACTION_TIMEOUT_MS = 10 * 6e4;
+function compactionTimeoutMs() {
+  const raw = Number(process.env.SKAILE_COMPACTION_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_TIMEOUT_MS;
+}
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set(["timeout", "unknown"]);
+var RETRY_FOCUS_DIRECTIVE = `The previous attempt to write this summary did not finish in time, most likely
+because it ran long. Be economical: compress aggressively, and drop low-value
+detail rather than exceeding a few hundred words.
+
+Cover exactly the same ground as before -- if a previous summary appears above,
+still restate everything in it that still matters. The saving comes from
+tighter prose, never from leaving material out.`;
+var ABORT_SETTLE_GRACE_MS = 5e3;
+var MAX_CARRIED_SUMMARY_CHARS = 24e3;
+var MAX_FAILURE_DIAGNOSTIC_CHARS = 4e3;
+function truncateTo(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}... [truncated]`;
+}
+function truncateDiagnostic(text) {
+  return truncateTo(text, MAX_FAILURE_DIAGNOSTIC_CHARS);
+}
 var RATE_LIMIT_TEXT_MAX_CHARS = 1500;
 var RATE_LIMIT_TEXT_PATTERNS = [
   /you('?| ha)ve hit your (rate |usage )?limit/i,
@@ -3303,6 +3451,12 @@ function contextTokens(usage) {
   const cacheCreation = usage?.cacheCreationTokens ?? 0;
   return Math.max(input, cacheRead) + cacheCreation;
 }
+function resolveContextWindow(driverWindow, model) {
+  if (model && ONE_MILLION_ALIAS_PATTERN.test(model)) {
+    return Math.max(driverWindow ?? 0, ONE_MILLION_CONTEXT_WINDOW);
+  }
+  return driverWindow || DEFAULT_CONTEXT_WINDOW;
+}
 function detectRateLimitInSummary(text) {
   if (text.length > RATE_LIMIT_TEXT_MAX_CHARS) return false;
   return RATE_LIMIT_TEXT_PATTERNS.some((p) => p.test(text));
@@ -3322,8 +3476,18 @@ var CompactionOrchestrator = class {
   config;
   opts;
   _isCompacting = false;
+  /** Whether {@link CompactionOrchestratorOptions.onCompactionStart} has fired for the current call. */
+  _startFired = false;
+  /** Whether {@link CompactionOrchestratorOptions.onCompactionEnd} has fired for the current call. */
+  _endFired = false;
   lastCompactionSeq = null;
   lastCompactionTime = null;
+  /**
+   * Summary of the last successful compaction, carried into the next one.
+   * Per-instance, in step with `lastCompactionSeq`: a driver rebuild resets
+   * both, so the first compaction after one is not treated as a re-compaction.
+   */
+  lastSummary = null;
   currentSeq = 0;
   messagesSinceCompaction = 0;
   constructor(opts) {
@@ -3353,7 +3517,10 @@ var CompactionOrchestrator = class {
   shouldCompact() {
     if (!this.config.enabled) return false;
     const usage = this.driver.getTokenUsage();
-    const contextWindow = this.driver.getContextWindow() || DEFAULT_CONTEXT_WINDOW;
+    const contextWindow = resolveContextWindow(
+      this.driver.getContextWindow(),
+      this.driver.getModel() ?? null
+    );
     const estimatedTokens = this.contextFill(usage);
     if (estimatedTokens <= 0) return false;
     return this.strategy.shouldCompact({
@@ -3367,14 +3534,45 @@ var CompactionOrchestrator = class {
   async compact(trigger, focus) {
     if (this._isCompacting) return null;
     this._isCompacting = true;
+    this._startFired = false;
+    this._endFired = false;
     try {
       return await this._doCompact(trigger, focus);
     } finally {
       this._isCompacting = false;
+      try {
+        this._endCompaction();
+      } catch (err) {
+        this.opts.onLog?.(
+          `[compaction] onCompactionEnd threw while unwinding: ${err instanceof Error ? err.message : String(err)}`
+        );
+      } finally {
+        this.opts.onCompactionSettled?.();
+      }
     }
   }
-  async _doCompact(trigger, focus) {
-    const tokensBefore = this.contextFill(this.driver.getTokenUsage());
+  /**
+   * Fire {@link CompactionOrchestratorOptions.onCompactionEnd} once per
+   * compaction. The host stops suppressing forwarded events here, so a second
+   * call would emit a stray idle status over the injection turn that follows
+   * it on the success path.
+   */
+  _endCompaction() {
+    if (!this._startFired || this._endFired) return;
+    this._endFired = true;
+    this.opts.onCompactionEnd?.();
+  }
+  /**
+   * One compaction attempt, plus at most one narrowed retry.
+   *
+   * @param retryOf Set only by the retry path. It suppresses a second
+   *   `onCompactionStart` (the retry continues the same compaction phase),
+   *   guarantees the retry can never itself retry, and carries the first
+   *   attempt's context reading forward.
+   */
+  async _doCompact(trigger, focus, retryOf) {
+    const isRetry = retryOf !== void 0;
+    const tokensBefore = retryOf?.tokensBefore ?? this.contextFill(this.driver.getTokenUsage());
     const driverSessionId = this.driver.runtimeSessionId ?? null;
     const driverModel = this.driver.getModel() ?? null;
     const driverProvider = this.driver.driverInfo?.id ?? null;
@@ -3391,25 +3589,40 @@ var CompactionOrchestrator = class {
       modelAtCompaction: driverModel,
       capabilitySignatureAtCompaction
     };
-    this.opts.onCompactionStart?.(trigger);
-    this.opts.onLog?.(`[compaction] Starting (trigger=${trigger}, tokens=${tokensBefore})`);
+    if (!isRetry) {
+      this._startFired = true;
+      this.opts.onCompactionStart?.(trigger);
+    }
+    this.opts.onLog?.(
+      `[compaction] ${isRetry ? "Retrying" : "Starting"} (trigger=${trigger}, tokens=${tokensBefore})`
+    );
     const prompt = buildCompactionPrompt({
       agentPrompt: this.opts.agentCompactionPrompt,
       skillDirectives: this.opts.skillDirectives,
       mcpDirectives: this.opts.mcpDirectives,
-      focus
+      focus,
+      // A re-compaction's reply replaces the previous summary, so the model has
+      // to see it — otherwise it answers with a delta that fails validation.
+      previousSummary: coversFromSeq > 0 ? this._carriedSummary() : void 0
     });
-    const { summaryText, promptError, elapsedMs } = await this._runCompactionPrompt(prompt);
+    const { summaryText, promptError, elapsedMs, timedOut } = await this._runCompactionPrompt(prompt);
     const attempt = { ...attemptBase, elapsedMs };
     if (promptError !== null) {
-      this._emitThrownFailure(attempt, promptError);
+      const errorCode = this._emitThrownFailure(attempt, promptError, timedOut);
+      this._beginCooldown();
+      if (this._shouldRetry(trigger, errorCode, focus, isRetry)) {
+        return await this._doCompact(trigger, RETRY_FOCUS_DIRECTIVE, { tokensBefore });
+      }
+      this._endCompaction();
       return null;
     }
     const actualUsage = this.driver.getTokenUsage();
     const tokensAfter = actualUsage?.outputTokens ?? Math.ceil(summaryText.length / 4);
     const validation = validateCompactionOutput(summaryText, tokensBefore, tokensAfter);
     if (!validation.ok) {
-      this._emitValidationFailure(attempt, validation.errorCode, tokensAfter);
+      this._emitValidationFailure(attempt, validation.errorCode, tokensAfter, summaryText);
+      this._beginCooldown();
+      this._endCompaction();
       return null;
     }
     return await this._completeCompaction(
@@ -3421,6 +3634,40 @@ var CompactionOrchestrator = class {
       coversFromSeq
     );
   }
+  /**
+   * The previous summary as it goes into a re-compaction prompt, capped so the
+   * prompt cannot grow without bound. Truncating loses context the model is
+   * being asked to restate, so it is logged when it happens.
+   */
+  _carriedSummary() {
+    const summary = this.lastSummary;
+    if (!summary) return void 0;
+    if (summary.length <= MAX_CARRIED_SUMMARY_CHARS) return summary;
+    this.opts.onLog?.(
+      `[compaction] Previous summary truncated to ${MAX_CARRIED_SUMMARY_CHARS} of ${summary.length} chars`
+    );
+    return truncateTo(summary, MAX_CARRIED_SUMMARY_CHARS);
+  }
+  /**
+   * Start the anti-thrash cooldown after a failed attempt.
+   *
+   * `TokenThresholdStrategy` skips its cooldown gate entirely while
+   * `lastCompactionTime` is null, and only success used to set it — so any
+   * failing session re-ran a full-context compaction on every single turn.
+   */
+  _beginCooldown() {
+    this.lastCompactionTime = Date.now();
+  }
+  /**
+   * Whether a failed attempt earns the one narrowed retry.
+   *
+   * Only automatic (threshold) compactions retry: a `manual` or `hibernate`
+   * caller owns the decision to try again, and a caller-supplied `focus` would
+   * be discarded by the retry's own directive.
+   */
+  _shouldRetry(trigger, errorCode, focus, isRetry) {
+    return !isRetry && trigger === "threshold" && focus === void 0 && RETRYABLE_ERROR_CODES.has(errorCode);
+  }
   /**
    * Drive the compaction `prompt()` call, capturing summary text from the
    * driver's raw bridge-level events and any thrown error. The listener is
@@ -3429,6 +3676,10 @@ var CompactionOrchestrator = class {
    * `elapsedMs` is the wall-clock cost of the `prompt()` call. It is the only
    * thing that separates a genuinely empty model response from a turn that was
    * settled by something other than the model, which resolves in milliseconds.
+   *
+   * The call is bounded by {@link compactionTimeoutMs}; on expiry the turn is
+   * aborted and `timedOut` is returned so the caller can record a classified
+   * `timeout` rather than wait out the driver's much longer stall watchdog.
    */
   async _runCompactionPrompt(prompt) {
     let summaryText = "";
@@ -3464,58 +3715,103 @@ var CompactionOrchestrator = class {
       }
     };
     let promptError = null;
+    let timedOut = false;
+    let timer;
     const startedAt = Date.now();
+    const timeoutMs = compactionTimeoutMs();
     try {
       this.driver.on("agent-event", captureHandler);
-      await this.driver.prompt(prompt);
+      const running = this.driver.prompt(prompt);
+      const expiry = new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4("expired"), timeoutMs);
+      });
+      const outcome = await Promise.race([running.then(() => "settled"), expiry]);
+      if (outcome === "expired") {
+        timedOut = true;
+        const settled = running.then(
+          () => void 0,
+          () => void 0
+        );
+        promptError = new Error(
+          `Compaction prompt did not complete within ${timeoutMs}ms; the turn was aborted.`
+        );
+        const aborted = this.driver.abort().catch((abortErr) => {
+          this.opts.onLog?.(`[compaction] abort after timeout failed: ${String(abortErr)}`);
+        });
+        let settleTimer;
+        const graceExpired = new Promise((resolve4) => {
+          settleTimer = setTimeout(resolve4, ABORT_SETTLE_GRACE_MS);
+          settleTimer.unref?.();
+        });
+        await Promise.race([Promise.all([aborted, settled]), graceExpired]);
+        clearTimeout(settleTimer);
+      }
     } catch (err) {
       promptError = err;
     } finally {
+      clearTimeout(timer);
       this.driver.removeListener("agent-event", captureHandler);
     }
-    return { summaryText, promptError, elapsedMs: Date.now() - startedAt };
+    return { summaryText, promptError, elapsedMs: Date.now() - startedAt, timedOut };
   }
   /**
    * Record a `failed` attempt for a thrown `prompt()` error: classify the
-   * error, map it to an error code, log, emit the attempt event, and signal
-   * compaction end.
+   * error, map it to an error code, log the raw text, and emit the attempt
+   * event. Signalling compaction end is the caller's job — a retry continues
+   * the same phase.
+   *
+   * @param timedOut Set when the bound in {@link _runCompactionPrompt} expired.
+   *   The synthetic message carries none of the classifier's keywords, so
+   *   round-tripping it would report the opaque `unknown` this bound replaces.
+   * @returns The error code recorded, so the caller can decide about a retry.
    */
-  _emitThrownFailure(attemptBase, promptError) {
-    const classified = classifyClaudeSdkError(
-      promptError instanceof Error ? promptError.message : String(promptError)
-    );
-    const errorCode = classified.category === "rate_limit" ? "rate_limit" : classified.category === "auth" ? "auth" : classified.category === "network" ? "timeout" : classified.category === "validation" ? "parse_error" : classified.category;
+  _emitThrownFailure(attemptBase, promptError, timedOut = false) {
+    const rawMessage = promptError instanceof Error ? promptError.message : String(promptError);
+    const classified = classifyClaudeSdkError(rawMessage);
+    const classifiedCode = classified.category === "rate_limit" ? "rate_limit" : classified.category === "auth" ? "auth" : classified.category === "network" ? "timeout" : classified.category === "validation" ? "parse_error" : classified.category;
+    const errorCode = timedOut ? "timeout" : classifiedCode;
+    const diagnostic = truncateDiagnostic(classified.message);
     this.opts.onLog?.(`[compaction] Failed: ${classified.message} (${errorCode})`);
     this.opts.onCompactionAttempt?.({
+      // Spread first: `status`/`validatedAt` below are load-bearing (see the
+      // summary comment) and must not be override-able from the base object.
+      ...attemptBase,
       type: "compaction_attempt",
       status: "failed",
       errorCode,
-      summary: "",
+      errorMessage: diagnostic,
+      // Mirrored so the platform's existing `summary` column explains the
+      // failure with no schema change. Safe: a failed attempt is never
+      // restored — restoration needs `success` plus a `validatedAt` stamp.
+      summary: diagnostic,
       outputTokens: 0,
-      validatedAt: null,
-      ...attemptBase
+      validatedAt: null
     });
-    this.opts.onCompactionEnd?.();
+    return errorCode;
   }
   /**
    * Record a `failed` attempt for output that passed `prompt()` but failed
-   * structural validation. Logs, emits the attempt event, and signals
-   * compaction end.
+   * structural validation. The rejected text is persisted so the next
+   * occurrence is diagnosable from the row alone; signalling compaction end is
+   * the caller's job.
    */
-  _emitValidationFailure(attemptBase, errorCode, tokensAfter) {
+  _emitValidationFailure(attemptBase, errorCode, tokensAfter, rejectedText) {
     this.opts.onLog?.(
       `[compaction] Output failed validation (${errorCode}); recording failed attempt`
     );
     this.opts.onCompactionAttempt?.({
+      // Spread first — see _emitThrownFailure.
+      ...attemptBase,
       type: "compaction_attempt",
       status: "failed",
       errorCode,
-      summary: "",
+      errorMessage: `Compaction output rejected by validation (${errorCode}): ${rejectedText.length} chars, ${tokensAfter} output tokens`,
+      // The rejected text itself, not a summary — see _emitThrownFailure on
+      // why persisting it here cannot leak into a restored session.
+      summary: truncateDiagnostic(rejectedText),
       outputTokens: tokensAfter,
-      validatedAt: null,
-      ...attemptBase
+      validatedAt: null
     });
-    this.opts.onCompactionEnd?.();
   }
   /**
    * Success path: emit the attempt + snapshot events, update internal state,
@@ -3533,19 +3829,20 @@ var CompactionOrchestrator = class {
       tokensAfter
     };
     this.opts.onCompactionAttempt?.({
+      ...attemptBase,
       type: "compaction_attempt",
       status: "success",
       errorCode: null,
       summary: summaryText,
       outputTokens: tokensAfter,
-      validatedAt,
-      ...attemptBase
+      validatedAt
     });
     this.opts.onSnapshot?.(snapshot);
     this.lastCompactionSeq = this.currentSeq + 1;
     this.lastCompactionTime = Date.now();
+    this.lastSummary = summaryText;
     this.messagesSinceCompaction = 0;
-    this.opts.onCompactionEnd?.();
+    this._endCompaction();
     if (trigger !== "hibernate") {
       this.opts.onLog?.("[compaction] Resetting driver session");
       await this.driver.resetSession();
@@ -5571,6 +5868,7 @@ async function startAgentServer(opts) {
   let driverStarted = false;
   let driverStartInFlight = null;
   const driverSwapGate = new DriverSwapGate();
+  const compactionGate = new CompactionGate();
   let driverRestartChain = Promise.resolve();
   let driver = secretsMode === "env" ? agentSession.driver : void 0;
   let secretsProvisioned = secretsMode === "env";
@@ -5595,15 +5893,19 @@ async function startAgentServer(opts) {
   let eventSeq = 0;
   let lastEmittedRuntimeSession;
   let compacting = false;
+  let suppressedBy = null;
   let compactionOrchestrator = null;
   const compactionConfig = wsConfig.compaction;
   function rebuildCompactionOrchestrator() {
     if (!driver) return;
+    let gateHold = null;
     compactionOrchestrator = new CompactionOrchestrator({
       driver,
       config: compactionConfig,
       onCompactionStart: (trigger) => {
         compacting = true;
+        gateHold = compactionGate.begin();
+        suppressedBy = gateHold;
         sendEvent({ type: "status", phase: "compacting" });
         log(`[serve] compaction started (trigger=${trigger})`);
       },
@@ -5614,9 +5916,15 @@ async function startAgentServer(opts) {
         sendEvent(event);
       },
       onCompactionEnd: () => {
+        if (suppressedBy !== gateHold) return;
         compacting = false;
+        suppressedBy = null;
         sendEvent({ type: "status", phase: "idle" });
       },
+      onCompactionSettled: () => {
+        compactionGate.settle(gateHold);
+        gateHold = null;
+      },
       onLog: (line) => log(`[serve] ${line}`),
       // Phase 3: stamp every CompactionAttemptEvent with the registry's
       // current signature so wake-time tier-1 selection has the input it
@@ -6421,6 +6729,7 @@ async function startAgentServer(opts) {
       rejectSessionReady(err instanceof Error ? err : new Error(errMsg));
     });
   }
+  const awaitCompactionIdle = (what) => guardTurnAgainstCompaction({ gate: compactionGate, what, log, sendEvent });
   async function handlePrompt(cmd) {
     if (cmd.messageId) sendEvent({ type: "prompt_ack", messageId: cmd.messageId });
     if (!await awaitSessionReadyOrFail()) return;
@@ -6435,6 +6744,7 @@ async function startAgentServer(opts) {
     }
     log(`[serve] prompt: ${cmd.prompt.slice(0, 80)}...`);
     await driverSwapGate.awaitSwap();
+    if (!await awaitCompactionIdle("prompt")) return;
     await restageMaterializedSkills(true);
     const activeFlow = getOnlyActiveFlow();
     if (activeFlow) {
@@ -6487,6 +6797,7 @@ async function startAgentServer(opts) {
     log(`[serve] reply: ${cmd.answer.slice(0, 80)}...`);
     await driverSwapGate.awaitSwap();
     if (driver.hasPendingQuestion() && driver.answerQuestion(cmd.answer, cmd.question)) return;
+    if (!await awaitCompactionIdle("reply")) return;
     const endTurn = driverSwapGate.beginTurn();
     try {
       await driver.prompt(cmd.answer);
@@ -7028,5 +7339,5 @@ function touchSession(state) {
 }
 
 export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickRepointedManager, planFlowMutate, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-YIPVMBCG.js.map
-//# sourceMappingURL=chunk-YIPVMBCG.js.map
+//# sourceMappingURL=chunk-ZPCHTTD7.js.map
+//# sourceMappingURL=chunk-ZPCHTTD7.js.map