@schoolai/shipyard 3.25.0 → 3.26.0-nightly.20260814.0

package/dist/{chunk-IRS6HYMU.js → chunk-ALNGADQY.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getDaemonVersion
-} from "./chunk-XNH6FVIX.js";
+} from "./chunk-FU6IF6C2.js";
 import {
   WorkerCommandCodec,
   WorkerReplyCodec
@@ -1116,4 +1116,4 @@ export {
   shutdownFileWatcherGuard,
   guardedSubscribe
 };
-//# sourceMappingURL=chunk-IRS6HYMU.js.map
+//# sourceMappingURL=chunk-ALNGADQY.js.map

package/dist/{chunk-XNH6FVIX.js → chunk-FU6IF6C2.js}

@@ -18,8 +18,8 @@ function getDaemonVersion() {
   return cached;
 }
 function readDaemonVersion() {
-  if ("3.25.0".length > 0) {
-    return "3.25.0";
+  if ("3.26.0".length > 0) {
+    return "3.26.0";
   }
   try {
     const here = dirname(fileURLToPath(import.meta.url));
@@ -48,4 +48,4 @@ function readDaemonVersion() {
 export {
   getDaemonVersion
 };
-//# sourceMappingURL=chunk-XNH6FVIX.js.map
+//# sourceMappingURL=chunk-FU6IF6C2.js.map

package/dist/electron-utility.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getDaemonVersion
-} from "./chunk-XNH6FVIX.js";
+} from "./chunk-FU6IF6C2.js";
 import {
   enableNativeCrashReports
 } from "./chunk-JD4WV327.js";
@@ -71,7 +71,7 @@ async function main() {
   await loadAuthFromConfig(env);
   crumb("post-auth-load");
   crumb("pre-serve-import");
-  const { serve } = await import("./serve-HTQMCHRP.js");
+  const { serve } = await import("./serve-ITJIQJQM.js");
   crumb("post-serve-import");
   const portQueue = [];
   let acceptor = null;

package/dist/index.js

@@ -137,7 +137,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-HOICUTYV.js");
+    const { startCommand } = await import("./start-ISA4ALVS.js");
     await startCommand();
     return true;
   }
@@ -159,7 +159,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-HTQMCHRP.js");
+    const { serve } = await import("./serve-ITJIQJQM.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-HTQMCHRP.js → serve-ITJIQJQM.js}

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-IRS6HYMU.js";
+} from "./chunk-ALNGADQY.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -45,7 +45,7 @@ import {
 } from "./chunk-2UE3TNY7.js";
 import {
   getDaemonVersion
-} from "./chunk-XNH6FVIX.js";
+} from "./chunk-FU6IF6C2.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -6022,7 +6022,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.25.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.26.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -21281,11 +21281,11 @@ function freshOccupancyOrNull(raw) {
 }
 function resolveCompactionThreshold(params) {
   const { taskPrefs, runtimePrefs, runtimeDefaultFraction, maxTokens } = params;
-  const fromPrefs = prefsToFraction(taskPrefs, maxTokens);
-  if (fromPrefs !== void 0) return fromPrefs;
+  const fromTask = prefsToFraction(taskPrefs, maxTokens);
+  if (fromTask !== void 0) return { tier: "task", fraction: fromTask };
   const fromRuntime = prefsToFraction(runtimePrefs, maxTokens);
-  if (fromRuntime !== void 0) return fromRuntime;
-  return runtimeDefaultFraction;
+  if (fromRuntime !== void 0) return { tier: "runtime", fraction: fromRuntime };
+  return runtimeDefaultFraction !== null ? { tier: "default", fraction: runtimeDefaultFraction } : { tier: "none", fraction: null };
 }
 function resolveActiveCompactionPrefs(params) {
   return params.taskPrefs ?? params.runtimePrefs ?? null;
@@ -34388,6 +34388,10 @@ function applyPersistedComposerSettings(orchestrator, settings) {
     patch.disabledMcpServers = normalizedSettings.disabledMcpServers;
   if (normalizedSettings.mcpServerSnapshot != null)
     patch.mcpServerSnapshot = normalizedSettings.mcpServerSnapshot;
+  if (normalizedSettings.compactionPrefs != null)
+    patch.compactionPrefs = normalizedSettings.compactionPrefs;
+  if (normalizedSettings.mutedResources != null)
+    patch.mutedResources = normalizedSettings.mutedResources;
   if (Object.keys(patch).length > 0) orchestrator.applySettings(patch);
 }
 function persistMessageBorneComposerSettings(deps, settings) {
@@ -78817,7 +78821,13 @@ function handleSpawning(snapshot, event) {
   }
   return noop(snapshot);
 }
-function buildStallGiveUpMessage(recoveryAttempts) {
+function buildStallGiveUpMessage(recoveryAttempts, stallPhase) {
+  if (stallPhase === "first_step") {
+    if (recoveryAttempts <= 0) {
+      return "The agent never started running. Send a message to try again.";
+    }
+    return "The agent never started running \u2014 no progress at all, across every automatic retry. Resuming this session will keep failing the same way; start a fresh task instead.";
+  }
   if (recoveryAttempts <= 0) {
     return "The agent stopped responding mid-run. Send a message to try again.";
   }
@@ -78831,7 +78841,11 @@ function runningStallTimeout(sessionId, event) {
   b2.effects.push({ type: "clear_queue" });
   if (!event.recoveryArmed) {
     b2.taskStatus("input_required");
-    b2.emitError(buildStallGiveUpMessage(event.recoveryAttempts), "sdk_error", "run_stall_timeout");
+    b2.emitError(
+      buildStallGiveUpMessage(event.recoveryAttempts, event.stallPhase),
+      "sdk_error",
+      "run_stall_timeout"
+    );
   }
   b2.effects.push({ type: "kill_runner" });
   return {
@@ -79654,11 +79668,19 @@ var AgentSessionManager = class {
       let recoveryArmed = false;
       let recoveryAttempts = 0;
       try {
-        const outcome = this.#config.onStallTimeout?.() ?? { armed: false, recoveryAttempts: 0 };
+        const outcome = this.#config.onStallTimeout?.(decision.phase) ?? {
+          armed: false,
+          recoveryAttempts: 0
+        };
         recoveryArmed = outcome.armed;
         recoveryAttempts = outcome.recoveryAttempts;
       } finally {
-        this.#dispatch({ type: "run_stall_timeout", recoveryArmed, recoveryAttempts });
+        this.#dispatch({
+          type: "run_stall_timeout",
+          recoveryArmed,
+          recoveryAttempts,
+          stallPhase: decision.phase
+        });
       }
     }, timeoutMs);
   }
@@ -79687,17 +79709,34 @@ var AgentSessionManager = class {
 // src/services/conversation/cursor-recovery-controller.ts
 var MAX_SIGNAL_DEATH_RETRIES = 1;
 var MAX_STALL_RESUME_RETRIES = 3;
+var MAX_COLD_START_RESUME_RETRIES = 1;
 var STALL_RESUME_BASE_DELAY_MS = 3e3;
 var STALL_RESUME_BACKOFF_MULTIPLIER = 3;
 function stallResumeDelayMs(attempt) {
   return STALL_RESUME_BASE_DELAY_MS * STALL_RESUME_BACKOFF_MULTIPLIER ** (attempt - 1);
 }
 var MAX_CRASH_DEATH_RETRIES = 1;
+function decideStallResume(input) {
+  if (input.state !== "running") return { kind: "decline" };
+  if (input.agentSystem !== AGENT_SYSTEM_CURSOR) return { kind: "decline" };
+  const isColdStart = input.phase === "first_step";
+  const next = (isColdStart ? input.coldStartRetries : input.midRunRetries) + 1;
+  const max = isColdStart ? MAX_COLD_START_RESUME_RETRIES : MAX_STALL_RESUME_RETRIES;
+  return next > max ? { kind: "give_up", recoveryAttempts: next - 1 } : { kind: "arm", retries: next };
+}
 var CursorRecoveryController = class {
   #signalDeathRetries = 0;
   #stallResumeRetries = 0;
   #stallResumeArmed = false;
   #crashDeathRetries = 0;
+  /**
+   * Consecutive silent resumes attempted for stalls in which the run never
+   * produced a first step. Deliberately NOT cleared by `reset()` — see
+   * `decideStallResume`. `noteFirstStep()` is its only reset.
+   */
+  #coldStartResumeRetries = 0;
+  /** Which budget armed the pending resume, so the backoff reads the right counter. */
+  #armedPhase = null;
   /**
    * Pending timer for the settle-delay before an armed stall resume fires.
    * Cleared at every call site that supersedes the in-flight resume (new
@@ -79723,14 +79762,37 @@ var CursorRecoveryController = class {
       this.#stallResumeTimer = null;
     }
   }
-  /** Reset every budget. Call on each new user turn and on turn_complete. */
+  /**
+   * Reset every turn-scoped budget. Call on each new user turn and on
+   * turn_complete.
+   *
+   * `#coldStartResumeRetries` is deliberately excluded: it is scoped to "has
+   * this session ever started a run", not to the current turn, and only
+   * `noteFirstStep()` clears it. Adding it here would restore the #5298
+   * livelock, where each human nudge bought another full futile round.
+   */
   reset() {
     this.cancelPendingResume();
     this.#signalDeathRetries = 0;
     this.#stallResumeRetries = 0;
     this.#stallResumeArmed = false;
+    this.#armedPhase = null;
     this.#crashDeathRetries = 0;
   }
+  /**
+   * Call on every `step_progress`. A completed step is the only evidence that
+   * this session can actually run, so it is the only thing that may forgive
+   * the cold-start budget. Cheap and idempotent — fires on every step.
+   */
+  noteFirstStep() {
+    if (this.#coldStartResumeRetries === 0) return;
+    this.#deps.log({
+      event: "thread_cursor_cold_start_budget_cleared",
+      threadId: this.#deps.threadId,
+      clearedRetries: this.#coldStartResumeRetries
+    });
+    this.#coldStartResumeRetries = 0;
+  }
   /**
    * Call on `turn_complete` instead of `reset()`. A successful auto-recovery
    * otherwise leaves no trace that the daemon self-healed rather than the
@@ -79762,30 +79824,43 @@ var CursorRecoveryController = class {
    * (see `StallTimeoutOutcome`), letting the FSM distinguish "never
    * attempted" from "tried N times".
    */
-  onStallTimeout() {
-    if (this.#deps.getState() !== "running") return { armed: false, recoveryAttempts: 0 };
-    if (this.#deps.getAgentSystem() !== AGENT_SYSTEM_CURSOR) {
-      return { armed: false, recoveryAttempts: 0 };
-    }
-    this.#stallResumeRetries++;
-    if (this.#stallResumeRetries > MAX_STALL_RESUME_RETRIES) {
-      const recoveryAttempts = this.#stallResumeRetries - 1;
-      this.#deps.log({
-        event: "thread_cursor_stall_resume_cap_exceeded",
-        threadId: this.#deps.threadId,
-        retries: this.#stallResumeRetries,
-        maxRetries: MAX_STALL_RESUME_RETRIES
-      });
-      this.#stallResumeRetries = 0;
-      return { armed: false, recoveryAttempts };
-    }
-    this.#deps.log({
-      event: "thread_cursor_stall_resume_armed",
-      threadId: this.#deps.threadId,
-      retries: this.#stallResumeRetries
+  onStallTimeout(phase) {
+    const decision = decideStallResume({
+      state: this.#deps.getState(),
+      agentSystem: this.#deps.getAgentSystem(),
+      phase,
+      midRunRetries: this.#stallResumeRetries,
+      coldStartRetries: this.#coldStartResumeRetries
     });
-    this.#stallResumeArmed = true;
-    return { armed: true, recoveryAttempts: 0 };
+    const isColdStart = phase === "first_step";
+    switch (decision.kind) {
+      case "decline":
+        return { armed: false, recoveryAttempts: 0, phase };
+      case "give_up":
+        this.#deps.log({
+          event: "thread_cursor_stall_resume_cap_exceeded",
+          threadId: this.#deps.threadId,
+          phase,
+          retries: decision.recoveryAttempts + 1,
+          maxRetries: isColdStart ? MAX_COLD_START_RESUME_RETRIES : MAX_STALL_RESUME_RETRIES
+        });
+        this.#stallResumeRetries = 0;
+        return { armed: false, recoveryAttempts: decision.recoveryAttempts, phase };
+      case "arm":
+        if (isColdStart) this.#coldStartResumeRetries = decision.retries;
+        else this.#stallResumeRetries = decision.retries;
+        this.#deps.log({
+          event: "thread_cursor_stall_resume_armed",
+          threadId: this.#deps.threadId,
+          phase,
+          retries: decision.retries
+        });
+        this.#stallResumeArmed = true;
+        this.#armedPhase = phase;
+        return { armed: true, recoveryAttempts: 0, phase };
+      default:
+        return assertNever(decision);
+    }
   }
   /**
    * Consume an armed stall resume on the `kill_runner` death. By now the FSM
@@ -79801,7 +79876,8 @@ var CursorRecoveryController = class {
     if (!this.#stallResumeArmed) return false;
     this.#stallResumeArmed = false;
     this.cancelPendingResume();
-    const attempt = this.#stallResumeRetries;
+    const attempt = this.#armedPhase === "first_step" ? this.#coldStartResumeRetries : this.#stallResumeRetries;
+    this.#armedPhase = null;
     const delayMs = stallResumeDelayMs(attempt);
     this.#deps.log({
       event: "thread_cursor_stall_auto_resume_scheduled",
@@ -80917,7 +80993,7 @@ var Thread = class {
         onClose: () => this.#handleClose(),
         onForceKill: () => this.#handleForceKill(),
         onKillRunner: () => this.#handleForceKill(),
-        onStallTimeout: () => this.#cursorRecovery.onStallTimeout(),
+        onStallTimeout: (phase) => this.#cursorRecovery.onStallTimeout(phase),
         log: config.log,
         onSessionStateChange: (newState, prevState) => this.#notifyStateChange(newState, prevState),
         stallTimeoutMs: config.stallTimeoutMs ?? null,
@@ -82068,6 +82144,7 @@ var Thread = class {
         break;
       case "step_progress":
         this.#manager.notifyStepProgress();
+        this.#cursorRecovery.noteFirstStep();
         break;
       /** Handled in #enqueueSubprocessEvent (off-queue heartbeat); unreachable here. */
       case "stream_activity":
@@ -87723,7 +87800,7 @@ function computeTelemetryTokenContext(params) {
   const usedTokens = params.lastWindowOccupancyEvent ? resolveLiveContextTokens(params.lastWindowOccupancyEvent).liveContextTokens : void 0;
   const window = resolveContextWindow(params.currentModel, 0);
   const windowTokens = window > 0 ? window : void 0;
-  const fraction = resolveCompactionThreshold({
+  const { fraction } = resolveCompactionThreshold({
     taskPrefs: params.taskPrefs,
     runtimePrefs: params.runtimePrefs,
     runtimeDefaultFraction: params.compactionThreshold,
@@ -87861,7 +87938,7 @@ function decideByRatio(params) {
   }
   if (params.isCompacting || params.hasPendingTimer) return { kind: "noop" };
   if (params.threshold !== null && usageRatio >= params.threshold) {
-    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS };
+    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS, decisionPath: "ratio" };
   }
   return { kind: "noop" };
 }
@@ -87871,7 +87948,11 @@ function decideByMessageCount(params) {
   if (params.liveMessageCount === void 0) return { kind: "noop" };
   const baseline = params.backstopBaselineSeq ?? 0;
   if (params.liveMessageCount - baseline >= AUTO_COMPACTION_MESSAGE_CEILING) {
-    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS };
+    return {
+      kind: "schedule",
+      delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS,
+      decisionPath: "message_count"
+    };
   }
   return { kind: "noop" };
 }
@@ -88435,8 +88516,14 @@ function priorOccupancyFromTurnStats(prior) {
 }
 function handleAutoCompactionSnapshot(ctx, event, contextWindow, occupancyStale = false) {
   const { liveContextTokens } = resolveLiveContextTokens(event);
+  const resolution = resolveCompactionThreshold({
+    taskPrefs: ctx.getTaskPrefs(),
+    runtimePrefs: ctx.getCompactionByRuntimePrefs(),
+    runtimeDefaultFraction: ctx.getCompactionThreshold(),
+    maxTokens: contextWindow
+  });
   const decision = decideAutoCompaction({
-    threshold: resolveEffectiveThresholdFraction(ctx, contextWindow),
+    threshold: resolution.fraction,
     liveContextTokens,
     contextWindow,
     isCompacting: ctx.isCompactionActive(),
@@ -88461,7 +88548,13 @@ function handleAutoCompactionSnapshot(ctx, event, contextWindow, occupancyStale
     case "schedule":
       ctx.setBackstopBaselineSeq(ctx.getLiveMessageCount());
       ctx.dispatchCompactionEvent({ kind: "threshold_reached", now: Date.now() });
-      ctx.scheduleAutoCompaction(decision.delayMs, liveContextTokens, contextWindow);
+      ctx.scheduleAutoCompaction(decision.delayMs, liveContextTokens, contextWindow, {
+        effectiveThreshold: resolution.fraction,
+        thresholdTier: resolution.tier,
+        runtimeDefaultFraction: ctx.getCompactionThreshold(),
+        decisionPath: decision.decisionPath,
+        occupancyStale
+      });
       return;
     default:
       assertNever(decision);
@@ -88491,14 +88584,6 @@ function logCumulativeFallback(ctx, liveContextTokens) {
     });
   }
 }
-function resolveEffectiveThresholdFraction(ctx, contextWindow) {
-  return resolveCompactionThreshold({
-    taskPrefs: ctx.getTaskPrefs(),
-    runtimePrefs: ctx.getCompactionByRuntimePrefs(),
-    runtimeDefaultFraction: ctx.getCompactionThreshold(),
-    maxTokens: contextWindow
-  });
-}
 
 // src/services/task/orchestrator/compaction-controller.ts
 var CompactionController = class {
@@ -88963,7 +89048,7 @@ var CompactionController = class {
    * Schedule the auto-compaction timer (called by the auto-compaction
    * decision from task-event-dispatch via the eventCtx).
    */
-  scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow) {
+  scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow, decisionContext) {
     if (this.#pendingAutoCompactionTimer !== null) return;
     const cancelDeadline = Date.now() + delayMs;
     this.#pendingAutoCompactionTimer = setTimeout(() => {
@@ -88980,7 +89065,11 @@ var CompactionController = class {
     this.#deps.log({
       event: "auto_compaction_pending",
       taskId: this.#deps.taskId,
-      threshold: this.#compactionThreshold,
+      effectiveThreshold: decisionContext.effectiveThreshold,
+      thresholdTier: decisionContext.thresholdTier,
+      runtimeDefaultFraction: decisionContext.runtimeDefaultFraction,
+      decisionPath: decisionContext.decisionPath,
+      occupancyStale: decisionContext.occupancyStale,
       liveContextTokens,
       contextWindow,
       cancelDeadline
@@ -94523,7 +94612,12 @@ var Task = class {
       setAutoCompactionSuppressedUntilBelow: (value) => {
         this.#compaction.setAutoCompactionSuppressedUntilBelow(value);
       },
-      scheduleAutoCompaction: (delayMs, liveContextTokens, contextWindow) => this.#compaction.scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow),
+      scheduleAutoCompaction: (delayMs, liveContextTokens, contextWindow, decisionContext) => this.#compaction.scheduleAutoCompaction(
+        delayMs,
+        liveContextTokens,
+        contextWindow,
+        decisionContext
+      ),
       getCompactionThreshold: () => this.#compaction.getCompactionThreshold(),
       getCompactionByRuntimePrefs: () => this.#compaction.getCompactionByRuntimePrefs(),
       getTaskPrefs: () => this.#deps.taskStateStore.getTaskSync(this.#taskIdRef.current)?.composerSettings?.compactionPrefs ?? null,
@@ -103626,4 +103720,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-HTQMCHRP.js.map
+//# sourceMappingURL=serve-ITJIQJQM.js.map