@schoolai/shipyard 3.5.0-rc.20260504.0 → 3.5.0

package/dist/{serve-E7CHPJD4.js → serve-IVUGCBEE.js}

@@ -1,4 +1,20 @@
 #!/usr/bin/env node
+import {
+  addWorktreeToCache,
+  detectEnvironments,
+  findProjectRoot,
+  getGitTopLevel,
+  getRepoDefaultBranch,
+  getRepoMetadata,
+  isAncestor,
+  isCorruptionError,
+  isEexist,
+  isEnoent,
+  isGhAvailable,
+  isGitRepo,
+  parseOwnerRepo,
+  removeWorktreeFromCache
+} from "./chunk-BNEE7ZPW.js";
 import {
   DiscoveryStateSchema,
   detectMCPServers,
@@ -9,10 +25,16 @@ import {
   redactEnv,
   resolveEnabledMcpServers,
   resolveStdioEnv
-} from "./chunk-5LIPEC7P.js";
+} from "./chunk-GIFN3IPT.js";
 import {
   detectSkills
-} from "./chunk-XXTIKBCU.js";
+} from "./chunk-VBPHGPBR.js";
+import {
+  configureFileWatcherGuard,
+  createMetricsCollector,
+  guardedSubscribe,
+  shutdownFileWatcherGuard
+} from "./chunk-3MNPDCO5.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -26,6 +48,9 @@ import {
 import {
   getRecentWasmPanicMessages
 } from "./chunk-7H34LI75.js";
+import {
+  assertNever
+} from "./chunk-SNYEQHUK.js";
 import {
   AuthGitHubCallbackRequestSchema,
   AuthGitHubCallbackResponseSchema,
@@ -72,37 +97,23 @@ import {
   classifyClaudeCodeCompatibility
 } from "./chunk-6TYNQ5KQ.js";
 import "./chunk-EHQITHQX.js";
-import {
-  loadAuthToken
-} from "./chunk-GLH3V7NG.js";
-import {
-  addWorktreeToCache,
-  detectEnvironments,
-  findProjectRoot,
-  getGitTopLevel,
-  getRepoDefaultBranch,
-  getRepoMetadata,
-  isAncestor,
-  isCorruptionError,
-  isEexist,
-  isEnoent,
-  isGhAvailable,
-  isGitRepo,
-  parseOwnerRepo,
-  removeWorktreeFromCache
-} from "./chunk-JQ7HCEFS.js";
 import {
   createChildLogger,
   flushLogger,
   logger
-} from "./chunk-YUG27SAR.js";
+} from "./chunk-2UN5AR7V.js";
+import {
+  loadAuthToken
+} from "./chunk-2J3WSIAF.js";
 import {
-  external_exports,
   getShipyardHome,
   isVanillaAgentMode,
-  toJSONSchema,
   validateEnv
-} from "./chunk-M5M6VC5F.js";
+} from "./chunk-PI77CUEP.js";
+import {
+  external_exports,
+  toJSONSchema
+} from "./chunk-VPMN47TL.js";
 import {
   AUTH_STATUS_TIMEOUT_MS,
   BUFFER_OVERFLOW_MSG,
@@ -33510,371 +33521,6 @@ var FileStorageAdapter = class _FileStorageAdapter extends StorageAdapter {
   }
 };
 
-// src/shared/assert-never.ts
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${JSON.stringify(value)}`);
-}
-
-// src/shared/file-watcher-guard.ts
-var DEFAULT_MAX_ACTIVE_WATCHERS = 450;
-var ENV_MAX = process.env.SHIPYARD_FILE_WATCHER_MAX;
-var PARSED_ENV_MAX = ENV_MAX ? Number.parseInt(ENV_MAX, 10) : Number.NaN;
-var MAX_ACTIVE_WATCHERS = Number.isFinite(PARSED_ENV_MAX) && PARSED_ENV_MAX > 0 ? PARSED_ENV_MAX : DEFAULT_MAX_ACTIVE_WATCHERS;
-var STARTING_BACKOFF_MS_INITIAL = 250;
-var STARTING_BACKOFF_MS_ESCALATION = 1e3;
-var MAX_BACKOFF_MS = 3e4;
-var BACKOFF_RESET_AFTER_MS = 5 * 6e4;
-var CIRCUIT_FAILURES = 5;
-var CIRCUIT_WINDOW_MS = 6e4;
-var CIRCUIT_OPEN_MS = 5 * 6e4;
-var CIRCUIT_OPEN_MAX_MS = 30 * 6e4;
-var ESSENTIAL_RESUBSCRIBE_DELAY_MS = 1e3;
-function makeInitialAttemptState() {
-  return {
-    failureCount: 0,
-    backoffMs: 0,
-    lastFailureAt: 0,
-    circuitOpenedAt: null,
-    circuitCooldownMs: CIRCUIT_OPEN_MS,
-    recentFailures: [],
-    halfOpenAt: null
-  };
-}
-function isCleanAttemptState(state) {
-  return state.circuitOpenedAt === null && state.failureCount === 0 && state.backoffMs === 0 && state.recentFailures.length === 0 && state.halfOpenAt === null;
-}
-function decideAction(state, event, now) {
-  switch (event.kind) {
-    case "request_subscribe":
-      return decideRequest(state, event, now);
-    case "subscribe_success":
-      return decideSuccess(state, now);
-    case "subscribe_failure":
-      return decideFailure(state, now);
-    default:
-      return assertNever(event);
-  }
-}
-function decideRequest(state, event, now) {
-  const decayed = decayBackoff(state, now);
-  if (decayed.circuitOpenedAt !== null) {
-    const cooldownEnd = decayed.circuitOpenedAt + decayed.circuitCooldownMs;
-    if (now < cooldownEnd) {
-      return {
-        state: decayed,
-        action: { kind: "reject_stub", reason: "circuit_open" },
-        signals: []
-      };
-    }
-    return {
-      state: { ...decayed, halfOpenAt: now },
-      action: event.activeCount >= MAX_ACTIVE_WATCHERS ? { kind: "evict_and_subscribe" } : { kind: "subscribe" },
-      signals: [{ kind: "circuit_probe" }]
-    };
-  }
-  if (decayed.backoffMs > 0 && now < decayed.lastFailureAt + decayed.backoffMs) {
-    const remaining = decayed.lastFailureAt + decayed.backoffMs - now;
-    return { state: decayed, action: { kind: "wait", ms: remaining }, signals: [] };
-  }
-  let nextState = decayed;
-  if (decayed.backoffMs === 0 && event.reason === "escalation") {
-    nextState = { ...decayed, backoffMs: STARTING_BACKOFF_MS_ESCALATION };
-  }
-  if (event.activeCount >= MAX_ACTIVE_WATCHERS) {
-    return { state: nextState, action: { kind: "evict_and_subscribe" }, signals: [] };
-  }
-  return { state: nextState, action: { kind: "subscribe" }, signals: [] };
-}
-function decideSuccess(state, _now) {
-  const wasHalfOpen = state.halfOpenAt !== null;
-  const next = {
-    failureCount: 0,
-    backoffMs: 0,
-    lastFailureAt: 0,
-    circuitOpenedAt: null,
-    circuitCooldownMs: CIRCUIT_OPEN_MS,
-    recentFailures: [],
-    halfOpenAt: null
-  };
-  return {
-    state: next,
-    action: { kind: "noop" },
-    signals: wasHalfOpen ? [{ kind: "circuit_closed" }] : []
-  };
-}
-function decideFailure(state, now) {
-  const recent = [...state.recentFailures.filter((t) => now - t < CIRCUIT_WINDOW_MS), now];
-  const baseBackoff = state.backoffMs === 0 ? STARTING_BACKOFF_MS_INITIAL : Math.min(state.backoffMs * 2, MAX_BACKOFF_MS);
-  if (state.halfOpenAt !== null) {
-    const nextCooldown = Math.min(state.circuitCooldownMs * 2, CIRCUIT_OPEN_MAX_MS);
-    return {
-      state: {
-        ...state,
-        failureCount: state.failureCount + 1,
-        backoffMs: baseBackoff,
-        lastFailureAt: now,
-        recentFailures: recent,
-        circuitOpenedAt: now,
-        circuitCooldownMs: nextCooldown,
-        halfOpenAt: null
-      },
-      action: { kind: "noop" },
-      signals: [{ kind: "circuit_opened" }]
-    };
-  }
-  if (recent.length >= CIRCUIT_FAILURES && state.circuitOpenedAt === null) {
-    return {
-      state: {
-        ...state,
-        failureCount: state.failureCount + 1,
-        backoffMs: baseBackoff,
-        lastFailureAt: now,
-        recentFailures: recent,
-        circuitOpenedAt: now,
-        circuitCooldownMs: CIRCUIT_OPEN_MS,
-        halfOpenAt: null
-      },
-      action: { kind: "noop" },
-      signals: [{ kind: "circuit_opened" }]
-    };
-  }
-  return {
-    state: {
-      ...state,
-      failureCount: state.failureCount + 1,
-      backoffMs: baseBackoff,
-      lastFailureAt: now,
-      recentFailures: recent
-    },
-    action: { kind: "noop" },
-    signals: []
-  };
-}
-function decayBackoff(state, now) {
-  if (state.lastFailureAt === 0 || state.backoffMs === 0) return state;
-  const sinceLast = now - state.lastFailureAt;
-  if (sinceLast >= BACKOFF_RESET_AFTER_MS) {
-    return { ...state, backoffMs: 0, failureCount: 0, recentFailures: [] };
-  }
-  const halvings = Math.floor(sinceLast / 6e4);
-  if (halvings === 0) return state;
-  const next = Math.max(STARTING_BACKOFF_MS_INITIAL, state.backoffMs >> halvings);
-  return { ...state, backoffMs: next };
-}
-var moduleState = makeModuleState();
-function makeModuleState() {
-  return {
-    active: /* @__PURE__ */ new Set(),
-    reservations: /* @__PURE__ */ new Set(),
-    perPath: /* @__PURE__ */ new Map(),
-    /** Cache of circuit-open log emission so we log only once per opening. */
-    loggedOpenAt: /* @__PURE__ */ new Map(),
-    /** Live deps; overridden in tests via _resetGuardForTesting / configureFileWatcherGuard. */
-    deps: defaultDeps()
-  };
-}
-function defaultDeps() {
-  return {
-    subscribe: async (path2, fn, opts) => {
-      const mod = await import("@parcel/watcher");
-      return mod.subscribe(path2, fn, opts);
-    },
-    log: () => {
-    },
-    now: () => Date.now(),
-    setTimeout: (fn, ms) => setTimeout(fn, ms)
-  };
-}
-function occupancy() {
-  return moduleState.active.size + moduleState.reservations.size;
-}
-function configureFileWatcherGuard(deps) {
-  moduleState.deps = { ...moduleState.deps, log: deps.log };
-}
-async function guardedSubscribe(path2, callback, opts, tier, reason) {
-  const { deps } = moduleState;
-  const now = deps.now();
-  const priorState = moduleState.perPath.get(path2) ?? makeInitialAttemptState();
-  const decision = decideAction(
-    priorState,
-    { kind: "request_subscribe", reason, activeCount: occupancy() },
-    now
-  );
-  moduleState.perPath.set(path2, decision.state);
-  emitSignals(path2, decision.signals);
-  switch (decision.action.kind) {
-    case "reject_stub":
-      return makeStubSubscription();
-    case "wait": {
-      const waitMs = decision.action.ms;
-      await new Promise((resolve5) => deps.setTimeout(() => resolve5(), waitMs));
-      return guardedSubscribe(path2, callback, opts, tier, "escalation");
-    }
-    case "evict_and_subscribe":
-      evictOne(path2);
-      return performSubscribe(path2, callback, opts, tier);
-    case "subscribe":
-      return performSubscribe(path2, callback, opts, tier);
-    case "noop":
-      throw new Error("guardedSubscribe: unexpected noop on request");
-    default:
-      return assertNever(decision.action);
-  }
-}
-async function performSubscribe(path2, consumerCallback, opts, tier) {
-  const { deps } = moduleState;
-  let entry = null;
-  const reservation = { path: path2, tier, reservedAt: deps.now() };
-  moduleState.reservations.add(reservation);
-  const wrapped = (err, events) => {
-    if (entry) entry.lastUsedAt = deps.now();
-    consumerCallback(err, events);
-  };
-  try {
-    const sub = await deps.subscribe(path2, wrapped, opts);
-    moduleState.reservations.delete(reservation);
-    const now = deps.now();
-    const priorState = moduleState.perPath.get(path2) ?? makeInitialAttemptState();
-    const successDecision = decideAction(priorState, { kind: "subscribe_success" }, now);
-    if (isCleanAttemptState(successDecision.state)) {
-      moduleState.perPath.delete(path2);
-    } else {
-      moduleState.perPath.set(path2, successDecision.state);
-    }
-    emitSignals(path2, successDecision.signals);
-    entry = {
-      path: path2,
-      tier,
-      lastUsedAt: now,
-      unsubscribe: () => sub.unsubscribe(),
-      consumerCallback
-    };
-    moduleState.active.add(entry);
-    deps.log({ event: "file_watcher_active_count", count: moduleState.active.size });
-    return {
-      unsubscribe: async () => {
-        if (entry && moduleState.active.has(entry)) {
-          moduleState.active.delete(entry);
-        }
-        const current2 = moduleState.perPath.get(path2);
-        if (current2 && isCleanAttemptState(current2)) {
-          moduleState.perPath.delete(path2);
-        }
-        await sub.unsubscribe();
-      }
-    };
-  } catch (err) {
-    moduleState.reservations.delete(reservation);
-    const now = deps.now();
-    const priorState = moduleState.perPath.get(path2) ?? makeInitialAttemptState();
-    const failureDecision = decideAction(priorState, { kind: "subscribe_failure" }, now);
-    moduleState.perPath.set(path2, failureDecision.state);
-    deps.log({
-      event: "file_watcher_subscribe_failed",
-      path: path2,
-      err: err instanceof Error ? err.message : String(err)
-    });
-    emitSignals(path2, failureDecision.signals);
-    if (failureDecision.state.circuitOpenedAt !== null) {
-      return makeStubSubscription();
-    }
-    throw err;
-  }
-}
-function pickOldest(entries, tier) {
-  let target = null;
-  for (const entry of entries) {
-    if (tier !== null && entry.tier !== tier) continue;
-    if (target === null || entry.lastUsedAt < target.lastUsedAt) target = entry;
-  }
-  return target;
-}
-function selectEvictionVictim(entries) {
-  const lazy = pickOldest(entries, "lazy");
-  if (lazy !== null) return { victim: lazy, evictingEssential: false };
-  const any = pickOldest(entries, null);
-  if (any !== null) return { victim: any, evictingEssential: true };
-  return null;
-}
-function evictOne(incomingPath) {
-  const { deps } = moduleState;
-  if (moduleState.active.size === 0) {
-    throw new Error("file-watcher-guard: cannot evict \u2014 active set is empty (counter is broken)");
-  }
-  const selection = selectEvictionVictim(moduleState.active);
-  if (selection === null) {
-    throw new Error("file-watcher-guard: eviction selection failed");
-  }
-  const { victim, evictingEssential } = selection;
-  moduleState.active.delete(victim);
-  deps.log({
-    event: evictingEssential ? "file_watcher_essential_evicted" : "file_watcher_evicted",
-    path: victim.path,
-    tier: victim.tier,
-    incomingPath
-  });
-  queueMicrotask(() => {
-    victim.consumerCallback(null, [{ type: "evicted", path: victim.path }]);
-  });
-  victim.unsubscribe().catch((err) => {
-    deps.log({
-      event: "file_watcher_unsubscribe_failed_during_eviction",
-      path: victim.path,
-      err: err instanceof Error ? err.message : String(err)
-    });
-  });
-  if (evictingEssential) {
-    scheduleEssentialResubscribe(victim);
-  }
-}
-function scheduleEssentialResubscribe(victim) {
-  const { deps } = moduleState;
-  deps.log({
-    event: "file_watcher_essential_re_subscribe_scheduled",
-    path: victim.path,
-    delayMs: ESSENTIAL_RESUBSCRIBE_DELAY_MS
-  });
-  deps.setTimeout(() => {
-    void retryEssentialSubscribe(victim);
-  }, ESSENTIAL_RESUBSCRIBE_DELAY_MS);
-}
-async function retryEssentialSubscribe(victim) {
-  const { deps } = moduleState;
-  try {
-    await guardedSubscribe(victim.path, victim.consumerCallback, {}, "essential", "rescan");
-    deps.log({ event: "file_watcher_essential_re_subscribed", path: victim.path });
-  } catch (err) {
-    deps.log({
-      event: "file_watcher_essential_re_subscribe_failed",
-      path: victim.path,
-      err: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function emitSignals(path2, signals) {
-  const { deps } = moduleState;
-  for (const sig of signals) {
-    switch (sig.kind) {
-      case "circuit_opened":
-        deps.log({ event: "file_watcher_circuit_open", path: path2 });
-        moduleState.loggedOpenAt.set(path2, deps.now());
-        break;
-      case "circuit_closed":
-        deps.log({ event: "file_watcher_circuit_closed", path: path2 });
-        moduleState.loggedOpenAt.delete(path2);
-        break;
-      case "circuit_probe":
-        break;
-      default:
-        assertNever(sig);
-    }
-  }
-}
-function makeStubSubscription() {
-  return { unsubscribe: async () => {
-  } };
-}
-
 // src/shared/log-instruments.ts
 function logChannelSent(log, channel, opts) {
   const msgId = opts?.msgId ?? crypto.randomUUID();
@@ -34770,6 +34416,20 @@ var LifecycleManager = class {
     const intHandler = () => void this.#shutdown("SIGINT");
     process.on("SIGTERM", termHandler);
     process.on("SIGINT", intHandler);
+    const isForkedChild = typeof process.send === "function";
+    const isShutdownMessage = (msg) => {
+      if (msg === null || typeof msg !== "object") return false;
+      const cmd = Reflect.get(msg, "cmd");
+      return cmd === "shutdown";
+    };
+    const messageHandler = (msg) => {
+      if (isShutdownMessage(msg)) {
+        void this.#shutdown("ipc-shutdown");
+      }
+    };
+    if (isForkedChild) {
+      process.on("message", messageHandler);
+    }
     const exceptionHandler = (error2) => {
       const severity = classifyUncaughtError(error2);
       if (severity === "recoverable") {
@@ -34809,6 +34469,9 @@ var LifecycleManager = class {
       () => process.removeListener("unhandledRejection", rejectionHandler),
       () => process.removeListener("exit", exitHandler)
     ];
+    if (isForkedChild) {
+      this.#cleanupFns.push(() => process.removeListener("message", messageHandler));
+    }
     void getSupportedEfforts().catch(() => void 0);
   }
   destroy() {
@@ -43030,10 +42693,10 @@ function friendlyExecError(err) {
 async function refreshPluginCapabilities(daemon, tokenStore) {
   const [updatedMarketplace, updatedMcp, updatedSkills] = await Promise.all([
     detectMarketplacePlugins(),
-    import("./mcp-servers-3SHS2PEJ.js").then(
+    import("./mcp-servers-FZV2P2ZO.js").then(
       (m2) => m2.detectMCPServers(daemon.capabilities.environments, tokenStore)
     ),
-    import("./skills-OMDIMU7D.js").then(
+    import("./skills-GPGRNV4R.js").then(
       (m2) => m2.detectSkills(daemon.capabilities.environments)
     )
   ]);
@@ -49153,72 +48816,6 @@ async function setupLocalDirect(deps) {
   };
 }
 
-// src/services/metrics/metrics-collector.ts
-var NOOP_METRICS = {
-  capture() {
-  },
-  dispose() {
-  }
-};
-var MetricsCollector = class {
-  #workerUrl;
-  #authToken;
-  #maxBatchSize;
-  #buffer = [];
-  #timer = null;
-  #disposed = false;
-  constructor(workerUrl, authToken, opts) {
-    this.#workerUrl = workerUrl.replace(/\/$/, "");
-    this.#authToken = authToken;
-    this.#maxBatchSize = opts?.maxBatchSize ?? 50;
-    const intervalMs = opts?.flushIntervalMs ?? 3e4;
-    this.#timer = setInterval(() => {
-      this.flush();
-    }, intervalMs);
-    this.#timer.unref();
-  }
-  capture(eventType, properties) {
-    if (this.#disposed) return;
-    const taskId = typeof properties?.taskId === "string" ? properties.taskId : void 0;
-    this.#buffer.push({
-      eventType,
-      taskId,
-      payload: properties ?? {},
-      clientTimestamp: Date.now()
-    });
-    if (this.#buffer.length >= this.#maxBatchSize) {
-      this.flush();
-    }
-  }
-  flush() {
-    if (this.#buffer.length === 0) return;
-    const events = this.#buffer;
-    this.#buffer = [];
-    const body = { events };
-    fetch(`${this.#workerUrl}/ingest`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.#authToken}`
-      },
-      body: JSON.stringify(body)
-    }).catch(() => {
-    });
-  }
-  dispose() {
-    this.#disposed = true;
-    if (this.#timer) {
-      clearInterval(this.#timer);
-      this.#timer = null;
-    }
-    this.flush();
-  }
-};
-function createMetricsCollector(workerUrl, authToken, telemetryEnabled) {
-  if (!telemetryEnabled || !workerUrl || !authToken) return NOOP_METRICS;
-  return new MetricsCollector(workerUrl, authToken);
-}
-
 // src/services/plugins/plugin-event-bus.ts
 var MAX_HANDLERS_PER_PLUGIN = 32;
 var PluginEventBus = class {
@@ -121956,7 +121553,7 @@ async function createDaemon(deps) {
     if (!cwd) return null;
     try {
       const { run: run4 } = await import("./shell-JINTQUIR.js");
-      const { getRepoDefaultBranch: getRepoDefaultBranch2 } = await import("./git-repo-CNIKBYPB.js");
+      const { getRepoDefaultBranch: getRepoDefaultBranch2 } = await import("./git-repo-364VANDM.js");
       const branch = (await run4("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd)).trim();
       if (!branch || branch === "HEAD") return null;
       const pr = branchPrStateCache.get(taskId)?.currentBranchPR;
@@ -124426,7 +124023,12 @@ async function serve(options = {}) {
     "file_watcher_subscribe_failed",
     "file_watcher_active_count",
     "file_watcher_essential_re_subscribed",
-    "file_watcher_essential_re_subscribe_failed"
+    "file_watcher_essential_re_subscribe_failed",
+    /** Watcher worker supervisor (Commit 2): restart-class telemetry. */
+    "watcher_worker_started",
+    "watcher_worker_died",
+    "watcher_worker_circuit_open",
+    "watcher_worker_circuit_closed"
   ]);
   configureFileWatcherGuard({
     log: (entry) => {
@@ -124435,7 +124037,8 @@ async function serve(options = {}) {
         const { event, ...payload } = entry;
         metricsCollector.capture(event, payload);
       }
-    }
+    },
+    metrics: metricsCollector
   });
   const sessionServerUrl = new URL(resolvedSignalingUrl).origin;
   const detectedPortsRef = {
@@ -124981,6 +124584,14 @@ async function serve(options = {}) {
         fileWatcherPool.dispose().catch((err) => {
           log.warn({ event: "shutdown_step_failed", step: "file_watcher_pool", err: String(err) });
         }),
+        /** Watcher worker supervisor: cooperative shutdown then SIGTERM/SIGKILL escalation. */
+        shutdownFileWatcherGuard().catch((err) => {
+          log.warn({
+            event: "shutdown_step_failed",
+            step: "file_watcher_supervisor",
+            err: String(err)
+          });
+        }),
         collabRoomManager?.destroy().catch((err) => {
           log.warn({
             event: "shutdown_step_failed",
@@ -125018,4 +124629,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-E7CHPJD4.js.map
+//# sourceMappingURL=serve-IVUGCBEE.js.map