@muggleai/works 5.27.0 → 5.28.0-staging.250

package/dist/{chunk-6BAB7IVG.js → chunk-HBCASFGN.js}

@@ -85,6 +85,7 @@ __export(src_exports, {
   SCREENSHOT_FILE_EXTENSION: () => SCREENSHOT_FILE_EXTENSION,
   StackCheckVerdict: () => StackCheckVerdict,
   StackClaimVerdict: () => StackClaimVerdict,
+  StackLeaseEndReason: () => StackLeaseEndReason,
   StackMismatchKind: () => StackMismatchKind,
   StackPortAction: () => StackPortAction,
   WATCHER_LIFETIME_SECONDS: () => WATCHER_LIFETIME_SECONDS,
@@ -102,6 +103,7 @@ __export(src_exports, {
   calculateFileChecksum: () => calculateFileChecksum,
   checkServiceStack: () => checkServiceStack,
   claimServiceStack: () => claimServiceStack,
+  compareQueuePlaces: () => compareQueuePlaces,
   completeOnboarding: () => completeOnboarding,
   createApiKeyWithToken: () => createApiKeyWithToken,
   createChildLogger: () => createChildLogger,
@@ -157,6 +159,7 @@ __export(src_exports, {
   loadApiKeyData: () => loadApiKeyData,
   loadCredentials: () => loadCredentials,
   localQa: () => local_exports2,
+  lookUpCheckoutPullRequest: () => lookUpCheckoutPullRequest,
   markOnboardingCompleted: () => markOnboardingCompleted,
   maskLlmApiKey: () => maskLlmApiKey,
   mcp: () => mcp_exports,
@@ -3326,6 +3329,57 @@ function describeStoppedRun(params) {
   return `Run stopped: it exceeded its ${params.timeoutMs}ms time limit.`;
 }
 
+// packages/mcps/src/mcp/local/services/execution-timeout-constants.ts
+var DEFAULT_GENERATION_TIMEOUT_MS = 3e5;
+var DEFAULT_REPLAY_TIMEOUT_MS = 18e4;
+
+// packages/mcps/src/shared/queue-priority/queue-priority-constants.ts
+var PR_LOOKUP_TIMEOUT_MS = 1e4;
+var PR_LOOKUP_CACHE_MS = 2 * 6e4;
+var PR_LOOKUP_ENV = "MUGGLE_PR_LOOKUP";
+
+// packages/mcps/src/shared/queue-priority/pull-request-lookup.ts
+var lookupsByCwd = /* @__PURE__ */ new Map();
+var lookUpCheckoutPullRequest = async (cwd) => {
+  if (process.env[PR_LOOKUP_ENV] === "off") return null;
+  const cached = lookupsByCwd.get(cwd);
+  if (cached !== void 0 && Date.now() - cached.lookedUpAt < PR_LOOKUP_CACHE_MS) return cached.pullRequest;
+  const pullRequest = parseOpenPullRequest(await runGhPrView(cwd));
+  lookupsByCwd.set(cwd, { pullRequest, lookedUpAt: Date.now() });
+  return pullRequest;
+};
+function runGhPrView(cwd) {
+  return new Promise((resolve7) => {
+    execFile(
+      "gh",
+      ["pr", "view", "--json", "number,url,createdAt,state"],
+      { cwd, timeout: PR_LOOKUP_TIMEOUT_MS, windowsHide: true, encoding: "utf-8" },
+      (error, stdout) => {
+        resolve7(error ? null : stdout);
+      }
+    );
+  });
+}
+function parseOpenPullRequest(output) {
+  if (output === null) return null;
+  try {
+    const parsed = JSON.parse(output);
+    const createdAt = typeof parsed.createdAt === "string" ? Date.parse(parsed.createdAt) : Number.NaN;
+    if (parsed.state !== "OPEN" || typeof parsed.number !== "number" || Number.isNaN(createdAt)) return null;
+    return { number: parsed.number, url: typeof parsed.url === "string" ? parsed.url : "", createdAt };
+  } catch {
+    return null;
+  }
+}
+
+// packages/mcps/src/shared/queue-priority/queue-priority.ts
+function compareQueuePlaces(left, right) {
+  const leftOpenedAt = left.pullRequest?.createdAt ?? Number.POSITIVE_INFINITY;
+  const rightOpenedAt = right.pullRequest?.createdAt ?? Number.POSITIVE_INFINITY;
+  if (leftOpenedAt !== rightOpenedAt) return leftOpenedAt < rightOpenedAt ? -1 : 1;
+  return left.enqueuedAt - right.enqueuedAt;
+}
+
 // packages/mcps/src/mcp/local/services/local-execution-lock-constants.ts
 var LOCK_FILE_NAME = "local-execution.lock";
 var MODIFY_LOCK_SUFFIX = ".modify";
@@ -3333,6 +3387,8 @@ var POLL_INTERVAL_MS = 2e3;
 var WAIT_LOG_INTERVAL_MS = 1e4;
 var MODIFY_LOCK_RETRY_MS = 50;
 var MODIFY_LOCK_STALE_MS = 5e3;
+var WAITER_ABANDON_MS = 5 * POLL_INTERVAL_MS;
+var HOLD_OVERRUN_GRACE_MS = STOP_REQUEST_GRACE_MS + 3 * 6e4;
 
 // packages/mcps/src/mcp/local/services/local-execution-lock.ts
 function lockFilePath() {
@@ -3385,8 +3441,8 @@ async function withModifyLock(fn) {
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       try {
-        const stat3 = await fs14.stat(modifyPath);
-        if (Date.now() - stat3.mtimeMs > MODIFY_LOCK_STALE_MS) {
+        const stat4 = await fs14.stat(modifyPath);
+        if (Date.now() - stat4.mtimeMs > MODIFY_LOCK_STALE_MS) {
           await fs14.unlink(modifyPath).catch(() => void 0);
           continue;
         }
@@ -3405,74 +3461,95 @@ async function withModifyLock(fn) {
 }
 async function tryAcquireOnce(params) {
   return await withModifyLock(async () => {
+    const now = Date.now();
     const existing = await readState();
-    if (existing === null) {
-      await writeState({
-        holderCwd: params.normalizedCwd,
-        holderPids: [params.pid],
-        acquiredAt: Date.now()
-      });
-      return { acquired: true };
-    }
-    const liveHolderPids = existing.holderPids.filter((pid) => pidIsAlive(pid));
-    if (liveHolderPids.length === 0) {
-      getLogger().warn("Breaking stale local-execution lock", {
-        staleCwd: existing.holderCwd,
-        stalePids: existing.holderPids
-      });
+    const isCaller = (waiter) => waiter.cwd === params.caller.cwd && waiter.pid === params.caller.pid;
+    const previousPlace = existing?.waiters?.find(isCaller);
+    const caller = {
+      ...params.caller,
+      enqueuedAt: Math.min(params.caller.enqueuedAt, previousPlace?.enqueuedAt ?? Number.POSITIVE_INFINITY),
+      lastPolledAt: now
+    };
+    const otherWaiters = (existing?.waiters ?? []).filter(
+      (waiter) => !isCaller(waiter) && pidIsAlive(waiter.pid) && now - waiter.lastPolledAt <= WAITER_ABANDON_MS
+    );
+    const holderPids = existing === null ? [] : findResponsiveHolderPids({ state: existing, now });
+    const isHeldByPeer = holderPids.length > 0 && existing?.holderCwd !== caller.cwd;
+    const isPeerAhead = otherWaiters.some((waiter) => waiter.cwd !== caller.cwd && compareQueuePlaces(waiter, caller) < 0);
+    if (!isHeldByPeer && !isPeerAhead) {
+      const isJoining = existing !== null && holderPids.length > 0;
       await writeState({
-        holderCwd: params.normalizedCwd,
-        holderPids: [params.pid],
-        acquiredAt: Date.now()
+        holderCwd: caller.cwd,
+        holderPids: [...holderPids, caller.pid],
+        acquiredAt: isJoining ? existing.acquiredAt : now,
+        holdDeadlineAt: Math.max(isJoining ? existing.holdDeadlineAt ?? 0 : 0, now + params.holdLimitMs),
+        waiters: otherWaiters
       });
       return { acquired: true };
     }
-    if (existing.holderCwd === params.normalizedCwd) {
-      const updated = {
-        holderCwd: existing.holderCwd,
-        holderPids: [...liveHolderPids, params.pid],
-        acquiredAt: existing.acquiredAt
-      };
-      await writeState(updated);
-      return { acquired: true };
-    }
-    return {
-      acquired: false,
-      blockingState: { ...existing, holderPids: liveHolderPids }
-    };
+    const line = [...otherWaiters, caller].sort(compareQueuePlaces);
+    const blockingState = existing === null || holderPids.length === 0 ? { holderCwd: "", holderPids: [], acquiredAt: 0, waiters: line } : { ...existing, holderPids, waiters: line };
+    await writeState(blockingState);
+    return { acquired: false, blockingState, position: line.findIndex(isCaller) + 1 };
   });
 }
+function findResponsiveHolderPids(params) {
+  const liveHolderPids = params.state.holderPids.filter((pid) => pidIsAlive(pid));
+  if (liveHolderPids.length < params.state.holderPids.length) {
+    getLogger().warn("Dropping exited local-execution lock holders", {
+      holderCwd: params.state.holderCwd,
+      exitedPids: params.state.holderPids.filter((pid) => !liveHolderPids.includes(pid))
+    });
+  }
+  const isStuck = params.state.holdDeadlineAt !== void 0 && params.now > params.state.holdDeadlineAt;
+  if (liveHolderPids.length > 0 && isStuck) {
+    getLogger().warn("Breaking stuck local-execution lock \u2014 its holder outran its run timeout", {
+      stuckCwd: params.state.holderCwd,
+      stuckPids: liveHolderPids,
+      overrunSec: Math.round((params.now - params.state.holdDeadlineAt) / 1e3)
+    });
+    return [];
+  }
+  return liveHolderPids;
+}
 async function decrementHolder(params) {
   await withModifyLock(async () => {
     const existing = await readState();
     if (existing === null) return;
-    if (existing.holderCwd !== params.normalizedCwd) {
-      getLogger().warn("Release skipped \u2014 holder cwd no longer matches", {
+    const removalIndex = existing.holderPids.indexOf(params.pid);
+    if (existing.holderCwd !== params.normalizedCwd || removalIndex < 0) {
+      getLogger().warn("Release skipped \u2014 no longer a holder; the lock passed on", {
         ourCwd: params.normalizedCwd,
         holderCwd: existing.holderCwd
       });
       return;
     }
-    const removalIndex = existing.holderPids.indexOf(params.pid);
-    const remainingPids = removalIndex >= 0 ? [...existing.holderPids.slice(0, removalIndex), ...existing.holderPids.slice(removalIndex + 1)] : existing.holderPids;
-    if (remainingPids.length === 0) {
+    const remainingPids = [...existing.holderPids.slice(0, removalIndex), ...existing.holderPids.slice(removalIndex + 1)];
+    if (remainingPids.length > 0) {
+      await writeState({ ...existing, holderPids: remainingPids });
+      return;
+    }
+    if ((existing.waiters ?? []).length === 0) {
       await deleteStateFile();
       return;
     }
-    await writeState({
-      holderCwd: existing.holderCwd,
-      holderPids: remainingPids,
-      acquiredAt: existing.acquiredAt
-    });
+    await writeState({ holderCwd: "", holderPids: [], acquiredAt: 0, waiters: existing.waiters });
   });
 }
 async function acquireLocalExecutionLock(params) {
   const normalizedCwd = normalizeCwd(params.cwd);
   const pid = process.pid;
   const startWaitAt = Date.now();
+  const caller = {
+    cwd: normalizedCwd,
+    pid,
+    pullRequest: await (params.lookUpPullRequest ?? lookUpCheckoutPullRequest)(normalizedCwd),
+    enqueuedAt: startWaitAt,
+    lastPolledAt: startWaitAt
+  };
   let lastWaitLogAt = 0;
   while (true) {
-    const outcome = await tryAcquireOnce({ normalizedCwd, pid });
+    const outcome = await tryAcquireOnce({ caller, holdLimitMs: params.runTimeoutMs + HOLD_OVERRUN_GRACE_MS });
     if (outcome.acquired) {
       return {
         release: () => decrementHolder({ normalizedCwd, pid })
@@ -3485,6 +3562,8 @@ async function acquireLocalExecutionLock(params) {
         ourCwd: normalizedCwd,
         heldBy: outcome.blockingState?.holderCwd,
         heldByPids: outcome.blockingState?.holderPids,
+        position: outcome.position,
+        lineLength: outcome.blockingState?.waiters?.length,
         waitedSec
       });
       lastWaitLogAt = now;
@@ -3733,10 +3812,10 @@ async function scanForRuntimeDirByMtime(params) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const fullPath = path16.join(runtimeRoot, entry.name);
-      const stat3 = await fs14.stat(fullPath);
-      if (stat3.mtimeMs < params.spawnAtMs) continue;
-      if (bestCandidate === null || stat3.mtimeMs > bestCandidate.mtimeMs) {
-        bestCandidate = { path: fullPath, mtimeMs: stat3.mtimeMs };
+      const stat4 = await fs14.stat(fullPath);
+      if (stat4.mtimeMs < params.spawnAtMs) continue;
+      if (bestCandidate === null || stat4.mtimeMs > bestCandidate.mtimeMs) {
+        bestCandidate = { path: fullPath, mtimeMs: stat4.mtimeMs };
       }
     }
     return bestCandidate?.path ?? null;
@@ -3923,7 +4002,10 @@ ${processInfo.capturedStderr}`
   });
 }
 async function executeTestGeneration(params) {
-  const lockHandle = await acquireLocalExecutionLock({ cwd: params.cwd });
+  const lockHandle = await acquireLocalExecutionLock({
+    cwd: params.cwd,
+    runTimeoutMs: params.timeoutMs ?? DEFAULT_GENERATION_TIMEOUT_MS
+  });
   try {
     return await runTestGenerationLocked(params);
   } finally {
@@ -3932,7 +4014,7 @@ async function executeTestGeneration(params) {
 }
 async function runTestGenerationLocked(params) {
   const { testCase, localUrl } = params;
-  const timeoutMs = params.timeoutMs ?? 3e5;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_GENERATION_TIMEOUT_MS;
   const userId = getAuthenticatedUserId();
   const authContent = buildStudioAuthContent();
   if (!testCase.url) {
@@ -4119,7 +4201,10 @@ async function runTestGenerationLocked(params) {
   }
 }
 async function executeReplay(params) {
-  const lockHandle = await acquireLocalExecutionLock({ cwd: params.cwd });
+  const lockHandle = await acquireLocalExecutionLock({
+    cwd: params.cwd,
+    runTimeoutMs: params.timeoutMs ?? DEFAULT_REPLAY_TIMEOUT_MS
+  });
   try {
     return await runReplayLocked(params);
   } finally {
@@ -4128,7 +4213,7 @@ async function executeReplay(params) {
 }
 async function runReplayLocked(params) {
   const { testScript, actionScript, localUrl } = params;
-  const timeoutMs = params.timeoutMs ?? 18e4;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_REPLAY_TIMEOUT_MS;
   const userId = getAuthenticatedUserId();
   const authContent = buildStudioAuthContent();
   if (!testScript.url) {
@@ -5188,6 +5273,13 @@ function toolRequiresAuth(toolName) {
 }
 
 // packages/mcps/src/shared/service-stack/service-stack-types.ts
+var StackLeaseEndReason = /* @__PURE__ */ ((StackLeaseEndReason2) => {
+  StackLeaseEndReason2["NeverServed"] = "NEVER_SERVED";
+  StackLeaseEndReason2["NoRunAfterServed"] = "NO_RUN_AFTER_SERVED";
+  StackLeaseEndReason2["Idle"] = "IDLE";
+  StackLeaseEndReason2["HolderExited"] = "HOLDER_EXITED";
+  return StackLeaseEndReason2;
+})(StackLeaseEndReason || {});
 var StackClaimVerdict = /* @__PURE__ */ ((StackClaimVerdict2) => {
   StackClaimVerdict2["Granted"] = "GRANTED";
   StackClaimVerdict2["Busy"] = "BUSY";
@@ -5204,6 +5296,7 @@ var StackCheckVerdict = /* @__PURE__ */ ((StackCheckVerdict2) => {
   StackCheckVerdict2["NoLease"] = "NO_LEASE";
   StackCheckVerdict2["Stale"] = "STALE";
   StackCheckVerdict2["PeerLease"] = "PEER_LEASE";
+  StackCheckVerdict2["Ended"] = "ENDED";
   return StackCheckVerdict2;
 })(StackCheckVerdict || {});
 var StackMismatchKind = /* @__PURE__ */ ((StackMismatchKind2) => {
@@ -5216,7 +5309,9 @@ var StackMismatchKind = /* @__PURE__ */ ((StackMismatchKind2) => {
 // packages/mcps/src/shared/service-stack/service-stack-constants.ts
 var STACK_LEDGER_DIR_NAME = "service-stack";
 var PREPARE_TRACKING_DIR_SEGMENTS = ["prepare", "running"];
-var STARTUP_WINDOW_MS = 15 * 6e4;
+var SERVE_WINDOW_MS = 8 * 6e4;
+var FIRST_RUN_WINDOW_MS = 4 * 6e4;
+var ENDED_LEASE_MEMORY_MS = 30 * 6e4;
 var IDLE_RELEASE_MS = 2 * 6e4;
 var MAX_RUN_MS = 2 * 60 * 6e4;
 var DEAD_HOLDER_GRACE_MS = 6e4;
@@ -5230,6 +5325,12 @@ var OWED_RETRY_AFTER_MS = 5e3;
 var CLAIM_POLL_INTERVAL_MS = 1e3;
 var BUSY_EXIT_CODE = 75;
 var LISTENER_COMMAND_MAX_CHARS = 120;
+var LEASE_END_REASON_TEXT = {
+  ["NEVER_SERVED" /* NeverServed */]: `its ports did not serve the claimed code within ${SERVE_WINDOW_MS / 6e4} minutes of the grant`,
+  ["NO_RUN_AFTER_SERVED" /* NoRunAfterServed */]: `no run started within ${FIRST_RUN_WINDOW_MS / 6e4} minutes of its services coming up`,
+  ["IDLE" /* Idle */]: `no run started within ${IDLE_RELEASE_MS / 6e4} minutes of the last one`,
+  ["HOLDER_EXITED" /* HolderExited */]: "every MCP server that ran under it exited"
+};
 var DEFAULT_PORT_BY_PROTOCOL = { "http:": 80, "https:": 443 };
 
 // packages/mcps/src/shared/service-stack/generation-store-constants.ts
@@ -5461,22 +5562,34 @@ function needsConflict(left, right) {
 }
 function sweepStackRecord(params) {
   const { record, now } = params;
-  const isLive = (lease) => !hasLeaseEnded({ lease, now, isAlive: params.isAlive });
-  const liveLeases = record.leases.filter(isLive);
-  const expiredLeases = record.leases.filter((lease) => !isLive(lease));
+  const servedSince = params.servedSince ?? isServedByNothing;
+  const endings = record.leases.map((lease) => ({
+    lease,
+    reason: findLeaseEndReason({ lease, now, isAlive: params.isAlive, servedSince })
+  }));
+  const liveLeases = endings.filter((ending) => ending.reason === null).map((ending) => ending.lease);
+  const endedNow = endings.flatMap(
+    ({ lease, reason }) => reason === null ? [] : [{ cwd: lease.cwd, label: lease.label, endedAt: now, reason }]
+  );
   return {
     leases: liveLeases,
-    queue: record.queue.filter((ticket) => now - ticket.lastSeenAt <= TICKET_ABANDON_MS),
+    queue: record.queue.filter((ticket) => now - ticket.lastSeenAt <= TICKET_ABANDON_MS).sort(compareQueuePlaces),
     portFreedAt: markFreedPorts({
       portFreedAt: forgetSettledPorts({ portFreedAt: record.portFreedAt, now }),
-      releasedNeeds: expiredLeases.flatMap((lease) => lease.needs),
+      releasedNeeds: endings.filter((ending) => ending.reason !== null).flatMap((ending) => ending.lease.needs),
       remainingLeases: liveLeases,
       now
+    }),
+    endedLeases: rememberEndedLeases({
+      endedLeases: record.endedLeases ?? [],
+      endedNow,
+      liveLeases,
+      now
     })
   };
 }
 function decideStackClaim(params) {
-  const swept = sweepStackRecord({ record: params.record, now: params.now, isAlive: params.isAlive });
+  const swept = sweepStackRecord(params);
   const peerLeases = swept.leases.filter((lease) => lease.cwd !== params.cwd);
   const leaseBlockers = peerLeases.flatMap((lease) => leaseBlockersFor({ lease, needs: params.needs, now: params.now }));
   const queueWithCaller = upsertTicket({
@@ -5484,6 +5597,7 @@ function decideStackClaim(params) {
     cwd: params.cwd,
     label: params.label,
     needs: params.needs,
+    pullRequest: params.pullRequest,
     now: params.now
   });
   const position = queueWithCaller.findIndex((ticket) => ticket.cwd === params.cwd) + 1;
@@ -5512,7 +5626,8 @@ function decideStackClaim(params) {
         releasedNeeds: ownLease?.needs ?? [],
         remainingLeases: leases,
         now: params.now
-      })
+      }),
+      endedLeases: (swept.endedLeases ?? []).filter((ended) => ended.cwd !== params.cwd)
     },
     blockers: [],
     sharedWith: peerLeases.filter((lease) => lease.needs.some((need) => params.needs.some((own) => own.port === need.port))).map((lease) => lease.cwd),
@@ -5523,7 +5638,7 @@ function decideStackClaim(params) {
 }
 function decideStackRelease(params) {
   const isReleased = params.record.leases.some((lease) => lease.cwd === params.cwd) || params.record.queue.some((ticket) => ticket.cwd === params.cwd);
-  const swept = sweepStackRecord({ record: params.record, now: params.now, isAlive: params.isAlive });
+  const swept = sweepStackRecord(params);
   if (!isReleased) return { next: hasSweepDropped({ record: params.record, swept }) ? swept : null, isReleased: false };
   const ownLease = swept.leases.find((lease) => lease.cwd === params.cwd);
   const leases = swept.leases.filter((lease) => lease.cwd !== params.cwd);
@@ -5535,7 +5650,8 @@ function decideStackRelease(params) {
       releasedNeeds: ownLease?.needs ?? [],
       remainingLeases: leases,
       now: params.now
-    })
+    }),
+    endedLeases: (swept.endedLeases ?? []).filter((ended) => ended.cwd !== params.cwd)
   };
   return { next, isReleased: true };
 }
@@ -5544,7 +5660,7 @@ function decideStackReap(params) {
   return hasSweepDropped({ record: params.record, swept }) ? swept : null;
 }
 function decideStackRunStart(params) {
-  const swept = sweepStackRecord({ record: params.record, now: params.now, isAlive: params.isAlive });
+  const swept = sweepStackRecord(params);
   if (!swept.leases.some((lease) => lease.cwd === params.cwd)) return decideStackReap(params);
   const start = (lease) => {
     const liveHolders = (lease.holderPids ?? []).filter((pid) => params.isAlive(pid));
@@ -5560,7 +5676,7 @@ function decideStackRunStart(params) {
   return { ...swept, leases: swept.leases.map((lease) => lease.cwd === params.cwd ? start(lease) : lease) };
 }
 function decideStackRunEnd(params) {
-  const swept = sweepStackRecord({ record: params.record, now: params.now, isAlive: params.isAlive });
+  const swept = sweepStackRecord(params);
   if (!swept.leases.some((lease) => lease.cwd === params.cwd)) return decideStackReap(params);
   const finish = (lease) => {
     const activeRuns = liveRuns({ lease, now: params.now, isAlive: params.isAlive }).filter(
@@ -5585,13 +5701,31 @@ function findVacatedNeeds(params) {
   }
   return vacated;
 }
-function hasLeaseEnded(params) {
-  if (liveRuns(params).length > 0) return false;
+function findLeaseEndReason(params) {
+  if (liveRuns(params).length > 0) return null;
   const holderPids = params.lease.holderPids ?? [];
   const isHolderGone = holderPids.length > 0 && !holderPids.some((pid) => params.isAlive(pid));
-  if (isHolderGone && params.now - params.lease.lastSeenAt > DEAD_HOLDER_GRACE_MS) return true;
+  if (isHolderGone && params.now - params.lease.lastSeenAt > DEAD_HOLDER_GRACE_MS) return "HOLDER_EXITED" /* HolderExited */;
   const lastRunEndedAt = params.lease.lastRunEndedAt;
-  return lastRunEndedAt === void 0 ? params.now - params.lease.lastSeenAt > STARTUP_WINDOW_MS : params.now - lastRunEndedAt > IDLE_RELEASE_MS;
+  if (lastRunEndedAt !== void 0) return params.now - lastRunEndedAt > IDLE_RELEASE_MS ? "IDLE" /* Idle */ : null;
+  const servedAt = findLeaseServedAt({ lease: params.lease, servedSince: params.servedSince });
+  if (servedAt === null) return params.now - params.lease.lastSeenAt > SERVE_WINDOW_MS ? "NEVER_SERVED" /* NeverServed */ : null;
+  return params.now - Math.max(servedAt, params.lease.lastSeenAt) > FIRST_RUN_WINDOW_MS ? "NO_RUN_AFTER_SERVED" /* NoRunAfterServed */ : null;
+}
+function findLeaseServedAt(params) {
+  const servedTimes = params.lease.needs.map((need) => params.servedSince(need));
+  if (servedTimes.some((servedAt) => servedAt === null)) return null;
+  return Math.max(params.lease.grantedAt, ...servedTimes);
+}
+function isServedByNothing() {
+  return null;
+}
+function rememberEndedLeases(params) {
+  const isSuperseded = (ended) => params.endedNow.some((latest) => latest.cwd === ended.cwd) || params.liveLeases.some((lease) => lease.cwd === ended.cwd);
+  const remembered = params.endedLeases.filter(
+    (ended) => params.now - ended.endedAt <= ENDED_LEASE_MEMORY_MS && !isSuperseded(ended)
+  );
+  return [...remembered, ...params.endedNow];
 }
 function isSameNeed(left, right) {
   return left.port === right.port && left.runDir === right.runDir && left.headSha === right.headSha;
@@ -5627,16 +5761,23 @@ function ticketBlockersFor(params) {
   }));
 }
 function upsertTicket(params) {
-  const existing = params.queue.find((ticket) => ticket.cwd === params.cwd);
-  if (existing === void 0) {
-    return [
-      ...params.queue,
-      { cwd: params.cwd, label: params.label, needs: params.needs, enqueuedAt: params.now, lastSeenAt: params.now }
-    ];
-  }
-  return params.queue.map(
-    (ticket) => ticket.cwd === params.cwd ? { ...ticket, label: params.label ?? ticket.label, needs: params.needs, lastSeenAt: params.now } : ticket
-  );
+  const existing = params.queue.find((ticket2) => ticket2.cwd === params.cwd);
+  const ticket = existing === void 0 ? {
+    cwd: params.cwd,
+    label: params.label,
+    needs: params.needs,
+    pullRequest: params.pullRequest ?? void 0,
+    enqueuedAt: params.now,
+    lastSeenAt: params.now
+  } : {
+    ...existing,
+    label: params.label ?? existing.label,
+    needs: params.needs,
+    pullRequest: params.pullRequest ?? existing.pullRequest,
+    lastSeenAt: params.now
+  };
+  const queue = existing === void 0 ? [...params.queue, ticket] : params.queue.map((queued) => queued.cwd === params.cwd ? ticket : queued);
+  return queue.sort(compareQueuePlaces);
 }
 function isOwedTurn(params) {
   if (params.now - params.ticket.lastSeenAt < CLAIM_GRACE_MS) return true;
@@ -5692,9 +5833,10 @@ async function claimServiceStack(params) {
   const runGit = params.runGit ?? runGitCommand;
   const cwd = await resolveCheckoutRoot({ cwd: params.cwd, runGit });
   const needs = await resolveNeeds({ needs: params.needs, runGit });
+  const pullRequest = await (params.lookUpPullRequest ?? lookUpCheckoutPullRequest)(cwd);
   const startedAt = Date.now();
   for (; ; ) {
-    const report = await claimOnce({ cwd, label: params.label, needs });
+    const report = await claimOnce({ cwd, label: params.label, needs, pullRequest });
     const hasWaitLeft = params.waitMs !== void 0 && Date.now() - startedAt < params.waitMs;
     if (report.verdict === "GRANTED" /* Granted */ || !hasWaitLeft) return report;
     await sleep3(CLAIM_POLL_INTERVAL_MS);
@@ -5703,7 +5845,13 @@ async function claimServiceStack(params) {
 async function checkServiceStack(params) {
   const cwd = await resolveCheckoutRoot({ cwd: params.cwd, runGit: params.runGit ?? runGitCommand });
   const snapshot = await readGenerationStore({ directory: ledgerDir(), emptyRecord: EMPTY_STACK_RECORD });
-  const swept = sweepStackRecord({ record: snapshot.record, now: Date.now(), isAlive: isProcessAlive });
+  const services = await readTrackedServices();
+  const swept = sweepStackRecord({
+    record: snapshot.record,
+    now: Date.now(),
+    isAlive: isProcessAlive,
+    servedSince: servedSinceFrom(services)
+  });
   const ownLease = swept.leases.find((lease) => lease.cwd === cwd) ?? null;
   const base = { cwd, generation: snapshot.generation, mismatches: [], peerLease: null, servedNeeds: [] };
   const isClaimedByCaller = ownLease?.needs.some((need) => need.port === params.port) ?? false;
@@ -5717,10 +5865,17 @@ async function checkServiceStack(params) {
       peerLease
     };
   }
+  const endedLease = ownLease === null ? swept.endedLeases?.find((ended) => ended.cwd === cwd) : void 0;
+  if (endedLease !== void 0) {
+    return {
+      ...base,
+      verdict: "ENDED" /* Ended */,
+      reason: `this checkout's lease ended ${Math.round((Date.now() - endedLease.endedAt) / 1e3)}s ago: ${LEASE_END_REASON_TEXT[endedLease.reason]}`
+    };
+  }
   if (ownLease === null) {
     return { ...base, verdict: "NO_LEASE" /* NoLease */, reason: "this checkout holds no stack lease" };
   }
-  const services = await readTrackedServices();
   const readListener = params.readListener ?? readPortListener;
   const mismatches = (await Promise.all(
     ownLease.needs.map((need) => findPortMismatch({ need, services, readListener }))
@@ -5743,48 +5898,68 @@ async function checkServiceStack(params) {
 }
 async function startStackRun(params) {
   const cwd = await resolveCheckoutRoot({ cwd: params.cwd, runGit: params.runGit ?? runGitCommand });
-  await updateLedger((record) => ({
+  await updateLedger((record, servedSince) => ({
     next: decideStackRunStart({
       record,
       cwd,
       runId: params.runId,
       holderPid: params.holderPid,
       now: Date.now(),
-      isAlive: isProcessAlive
+      isAlive: isProcessAlive,
+      servedSince
     }),
     result: null
   }));
 }
 async function finishStackRun(params) {
   const cwd = await resolveCheckoutRoot({ cwd: params.cwd, runGit: params.runGit ?? runGitCommand });
-  await updateLedger((record) => ({
-    next: decideStackRunEnd({ record, cwd, runId: params.runId, now: Date.now(), isAlive: isProcessAlive }),
+  await updateLedger((record, servedSince) => ({
+    next: decideStackRunEnd({
+      record,
+      cwd,
+      runId: params.runId,
+      now: Date.now(),
+      isAlive: isProcessAlive,
+      servedSince
+    }),
     result: null
   }));
 }
 async function reapServiceStack() {
-  const update = await updateLedger((record) => ({
-    next: decideStackReap({ record, now: Date.now(), isAlive: isProcessAlive }),
+  const update = await updateLedger((record, servedSince) => ({
+    next: decideStackReap({ record, now: Date.now(), isAlive: isProcessAlive, servedSince }),
     result: null
   }));
   return update.stoppedServices;
 }
 async function releaseServiceStack(params) {
   const cwd = await resolveCheckoutRoot({ cwd: params.cwd, runGit: params.runGit ?? runGitCommand });
-  const update = await updateLedger((record) => {
-    const decision = decideStackRelease({ record, cwd, now: Date.now(), isAlive: isProcessAlive });
+  const update = await updateLedger((record, servedSince) => {
+    const decision = decideStackRelease({
+      record,
+      cwd,
+      now: Date.now(),
+      isAlive: isProcessAlive,
+      servedSince
+    });
     return { next: decision.next, result: decision.isReleased };
   });
   return { isReleased: update.result, stoppedServices: update.stoppedServices };
 }
 async function readServiceStackStatus() {
   const snapshot = await readGenerationStore({ directory: ledgerDir(), emptyRecord: EMPTY_STACK_RECORD });
-  const swept = sweepStackRecord({ record: snapshot.record, now: Date.now(), isAlive: isProcessAlive });
+  const services = await readTrackedServices();
+  const swept = sweepStackRecord({
+    record: snapshot.record,
+    now: Date.now(),
+    isAlive: isProcessAlive,
+    servedSince: servedSinceFrom(services)
+  });
   return {
     generation: snapshot.generation,
     leases: swept.leases,
     queue: swept.queue,
-    services: await readTrackedServices()
+    services
   };
 }
 function portOfUrl(url) {
@@ -5797,14 +5972,16 @@ function portOfUrl(url) {
   }
 }
 async function claimOnce(params) {
-  const update = await updateLedger((record) => {
+  const update = await updateLedger((record, servedSince) => {
     const decision2 = decideStackClaim({
       record,
       cwd: params.cwd,
       label: params.label,
       needs: params.needs,
+      pullRequest: params.pullRequest,
       now: Date.now(),
-      isAlive: isProcessAlive
+      isAlive: isProcessAlive,
+      servedSince
     });
     return { next: decision2.next, result: decision2 };
   });
@@ -5825,11 +6002,12 @@ async function claimOnce(params) {
   };
 }
 async function updateLedger(decide) {
+  const servedSince = servedSinceFrom(await readTrackedServices());
   const outcome = await updateGenerationStore({
     directory: ledgerDir(),
     emptyRecord: EMPTY_STACK_RECORD,
     decide: (snapshot) => {
-      const update = decide(snapshot.record);
+      const update = decide(snapshot.record, servedSince);
       const vacatedNeeds = update.next === null ? [] : findVacatedNeeds({ before: snapshot.record, after: update.next });
       return {
         next: update.next,
@@ -5874,6 +6052,12 @@ async function findPortMismatch(params) {
   if (isTrackedListener) return null;
   return { need: params.need, kind: "UNTRACKED_LISTENER" /* UntrackedListener */, actual: tracked, listener: reading.listener };
 }
+function servedSinceFrom(services) {
+  return (need) => {
+    const service = trackedServiceOnPort({ services, port: need.port });
+    return service !== null && servesNeed({ service, need }) ? service.startedAt : null;
+  };
+}
 function servesNeed(params) {
   return params.service.dir === params.need.runDir && params.service.headSha === params.need.headSha;
 }
@@ -5886,7 +6070,9 @@ async function readTrackedServices() {
   const perFile = await Promise.all(
     fileNames.filter((fileName) => fileName.endsWith(".json")).map(async (fileName) => {
       try {
-        const parsed = JSON.parse(await fs14.readFile(path16.join(directory, fileName), "utf-8"));
+        const filePath = path16.join(directory, fileName);
+        const [content, stat4] = await Promise.all([fs14.readFile(filePath, "utf-8"), fs14.stat(filePath)]);
+        const parsed = JSON.parse(content);
         return (parsed.services ?? []).filter((service) => typeof service.port === "number" && typeof service.pid === "number").filter((service) => isProcessAlive(service.pid)).map(
           (service) => ({
             name: service.name ?? "",
@@ -5895,7 +6081,8 @@ async function readTrackedServices() {
             pid: service.pid,
             headSha: service.headSha ?? null,
             source: normalizePath(parsed.source ?? ""),
-            isExternal: service.external === true
+            isExternal: service.external === true,
+            startedAt: parseStartedAt(service.startedAt) ?? stat4.mtimeMs
           })
         );
       } catch {
@@ -5905,6 +6092,10 @@ async function readTrackedServices() {
   );
   return perFile.flat();
 }
+function parseStartedAt(startedAt) {
+  const parsed = startedAt === void 0 ? Number.NaN : Date.parse(startedAt);
+  return Number.isNaN(parsed) ? null : parsed;
+}
 async function resolveNeeds(params) {
   return await Promise.all(
     params.needs.map(async (need) => {
@@ -9588,7 +9779,11 @@ function writeLastHost(cwd, host) {
 function clearLastHost(cwd) {
   clearCwdEntry(LAST_HOST_CACHE, cwd);
 }
-var REFUSING_VERDICTS = /* @__PURE__ */ new Set(["PEER_LEASE" /* PeerLease */, "STALE" /* Stale */]);
+var REFUSING_VERDICTS = /* @__PURE__ */ new Set([
+  "PEER_LEASE" /* PeerLease */,
+  "STALE" /* Stale */,
+  "ENDED" /* Ended */
+]);
 var idleReapTimer = null;
 async function findRunStackRefusal(params) {
   if (!isLoopbackUrl(params.localUrl)) return null;
@@ -9709,11 +9904,17 @@ function formatRunCheckoutRefusal(report, cwd) {
 }
 
 // packages/mcps/src/mcp/tools/local/run-stack-refusal.ts
+var RE_PREPARE_REMEDY = "Re-run muggle-test-prepare from this checkout: it re-claims the stack and restarts what moved.";
+var REFUSAL_HEADING_BY_VERDICT = {
+  ["PEER_LEASE" /* PeerLease */]: "## Run refused \u2014 the target port is leased to another checkout",
+  ["STALE" /* Stale */]: "## Run refused \u2014 the service stack changed since this checkout claimed it",
+  ["ENDED" /* Ended */]: "## Run refused \u2014 this checkout's stack lease ended and its services were stopped"
+};
 function formatRunStackRefusal(report, cwd) {
   const mismatchLines = report.mismatches.map((mismatch) => `- ${describeStackMismatch(mismatch)}`);
-  const remedy = report.verdict === "PEER_LEASE" /* PeerLease */ ? `Claim the stack for this checkout \u2014 \`muggle stack claim --cwd "${cwd}" --need <port>=<run-dir>\` \u2014 then wait your turn or re-run prepare once it is granted.` : `Re-run muggle-test-prepare from this checkout: it re-claims the stack and restarts what moved.`;
+  const remedy = report.verdict === "PEER_LEASE" /* PeerLease */ ? `Claim the stack for this checkout \u2014 \`muggle stack claim --cwd "${cwd}" --need <port>=<run-dir>\` \u2014 then wait your turn or re-run prepare once it is granted.` : report.verdict === "ENDED" /* Ended */ ? `${RE_PREPARE_REMEDY} Ask any question before invoking it: a lease ends when its first run does not follow soon after its services come up.` : RE_PREPARE_REMEDY;
   return [
-    report.verdict === "PEER_LEASE" /* PeerLease */ ? "## Run refused \u2014 the target port is leased to another checkout" : "## Run refused \u2014 the service stack changed since this checkout claimed it",
+    REFUSAL_HEADING_BY_VERDICT[report.verdict] ?? `## Run refused \u2014 ${report.verdict}`,
     "",
     `**Verdict:** ${report.verdict}`,
     `**Checkout:** ${report.cwd}`,
@@ -11069,4 +11270,4 @@ function applyLlmSourceSelection(selection, dataDirOverride2) {
   return resolveLlmSourceStatus(dataDirOverride2);
 }
 
-export { ACTION_SCRIPT_FILE_NAME, BASE_REMOTE_NAME, BLOCKING_FRESHNESS_VERDICTS, BRANCH_CREATION_REFLOG_PREFIX, BUSY_EXIT_CODE, CLAUDE_CODE_AUTH_STATUS_ARGS, CLAUDE_CODE_CHECK_TIMEOUT_MS, CLAUDE_CODE_EXECUTABLE, CLAUDE_CODE_EXECUTABLE_NOT_FOUND_CODE, CLAUDE_CODE_SESSION_LINK_ENV_VARS, CLAUDE_CODE_VERSION_ARGS, CheckoutFreshnessVerdict, ClaudeCodeReadiness, DEFAULT_LOCAL_LLM_BASE_URL, DEFAULT_PREFERENCES, ELECTRON_APP_EXECUTABLE_PATH_SEGMENTS, ElectronAppPlatform, ElectronAppReleaseStream, EventName, HTML_VIEW_OFFER_LINE, LLM_CREDENTIALS_FILE_MODE, LLM_CREDENTIALS_FILE_NAME, LLM_SOURCE_HEADER, LLM_SOURCE_OPTIONS, LLM_SOURCE_OWNED_ENV_NAMES, LLM_SOURCE_PROMPT, LLM_SOURCE_SCOPE_NOTE, LlmSource, MASKED_API_KEY_PREFIX, MASKED_API_KEY_VISIBLE_CHARS, MAX_LISTED_INHERITED_COMMITS, ONBOARDING_BLANKET_OPTIONS, ONBOARDING_CHOICE_GROUPS, ONBOARDING_MAX_OFFERS, ONBOARDING_PRIMER_BULLETS, ONBOARDING_PRIMER_HEADLINE, ONBOARDING_TOGGLE_GROUPS, ONBOARDING_TOGGLE_PROMPT, ONBOARDING_UNSELECTED_TOGGLE_VALUE, OnboardingBlanketChoice, OnboardingGroupKind, PREFERENCES_FILE_NAME, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_SCHEMA, PREFERENCES_VERSION, PREFERENCE_ALLOWED_VALUES, PreferenceKey, PreferenceValue, ProjectPreferencesReconcileOutcome, RUN_SESSIONS_DIR_NAME, RUN_VIEW_DASHBOARD_LINK_LABEL, RunViewError, RuntimeTarget, SCREENSHOT_DIR_RELATIVE_PATH, SCREENSHOT_FILE_EXTENSION, ServiceName, StackCheckVerdict, StackClaimVerdict, StackMismatchKind, StackPortAction, Surface, WATCHER_LIFETIME_SECONDS, WATCHER_LIFETIME_UNBOUNDED_SECONDS, __export, __require, applyLlmSourceSelection, applyOnboardingAnswers, assertDeviceCodeClientProvisioned, buildElectronAppChecksumsUrl, buildElectronAppDirName, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, buildLlmSourcePlan, buildOnboardingPlan, buildToolInputJsonSchema, calculateFileChecksum, checkServiceStack, claimServiceStack, completeOnboarding, createApiKeyWithToken, createChildLogger, decideStackClaim, decideStackReap, decideStackRelease, decideStackRunEnd, decideStackRunStart, deleteApiKeyData, deleteCredentials, describeLlmSourceStatus, describeStackMismatch, e2e_exports2 as e2e_exports, evaluateCheckoutFreshness, findVacatedNeeds, finishStackRun, formatPreferencesOneLiner, getActiveElectronAppReleaseStream, getActiveRuntimeTarget, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDashboardBaseUrl, getDataDir, getDataDir2, getDisclosureCopy, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppReleaseTagPrefix, getElectronAppSignedFromVersion, getElectronAppVersion, getElectronAppVersionSource, getLlmSourceOption, getLocalQaTools, getLogger, getOnboardingToggleKeys, getPlatformKey, getQaTools, getReleaseSignerIdentityUri, getRunSessionsDir, getValidApiKeyData, getValidCredentials, hasApiKey, hasShownDisclosure, initTelemetry, isElectronAppInstalled, isElectronAppPlatform, isFirstRun, isValidLocalBaseUrl, loadApiKeyData, loadCredentials, local_exports2 as local_exports, markDisclosureShown, markOnboardingCompleted, maskLlmApiKey, mcp_exports, needsConflict, needsOnboarding, openBrowserUrl, parseElectronAppDirName, performLogin, performLogout, pollDeviceCode, portOfUrl, readPreferencesMetadata, readRunView, readServiceStackStatus, reapServiceStack, reconcileProjectPreferences, recordOnboardingSkip, releaseServiceStack, renderRunViewHtml, renderRunViewText, resetConfig, resetLogger, resetPreference, resolveActiveProfile, resolveActiveReleaseStream, resolveActiveReleaseTagPrefix, resolveBlanketPreferences, resolveElectronAppExecutablePath, resolveElectronAppPathOrNull, resolveLlmSourceStatus, resolveOnboardingAnswers, resolvePreferences, resolveRunSessionPath, resolveRuntimeTarget, resolveTogglePreferences, runGitCommand, saveApiKey, saveApiKeyData, saveCredentials, src_exports, startDeviceCodeFlow, startStackRun, stopVacatedServices, toDisplayRef, toolRequiresAuth, track, validatePreference, verifyFileChecksum, writeLlmEnvBlock, writePreferences, writePreferencesWithMetadata, writeRunViewHtml };
+export { ACTION_SCRIPT_FILE_NAME, BASE_REMOTE_NAME, BLOCKING_FRESHNESS_VERDICTS, BRANCH_CREATION_REFLOG_PREFIX, BUSY_EXIT_CODE, CLAUDE_CODE_AUTH_STATUS_ARGS, CLAUDE_CODE_CHECK_TIMEOUT_MS, CLAUDE_CODE_EXECUTABLE, CLAUDE_CODE_EXECUTABLE_NOT_FOUND_CODE, CLAUDE_CODE_SESSION_LINK_ENV_VARS, CLAUDE_CODE_VERSION_ARGS, CheckoutFreshnessVerdict, ClaudeCodeReadiness, DEFAULT_LOCAL_LLM_BASE_URL, DEFAULT_PREFERENCES, ELECTRON_APP_EXECUTABLE_PATH_SEGMENTS, ElectronAppPlatform, ElectronAppReleaseStream, EventName, HTML_VIEW_OFFER_LINE, LLM_CREDENTIALS_FILE_MODE, LLM_CREDENTIALS_FILE_NAME, LLM_SOURCE_HEADER, LLM_SOURCE_OPTIONS, LLM_SOURCE_OWNED_ENV_NAMES, LLM_SOURCE_PROMPT, LLM_SOURCE_SCOPE_NOTE, LlmSource, MASKED_API_KEY_PREFIX, MASKED_API_KEY_VISIBLE_CHARS, MAX_LISTED_INHERITED_COMMITS, ONBOARDING_BLANKET_OPTIONS, ONBOARDING_CHOICE_GROUPS, ONBOARDING_MAX_OFFERS, ONBOARDING_PRIMER_BULLETS, ONBOARDING_PRIMER_HEADLINE, ONBOARDING_TOGGLE_GROUPS, ONBOARDING_TOGGLE_PROMPT, ONBOARDING_UNSELECTED_TOGGLE_VALUE, OnboardingBlanketChoice, OnboardingGroupKind, PREFERENCES_FILE_NAME, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_SCHEMA, PREFERENCES_VERSION, PREFERENCE_ALLOWED_VALUES, PreferenceKey, PreferenceValue, ProjectPreferencesReconcileOutcome, RUN_SESSIONS_DIR_NAME, RUN_VIEW_DASHBOARD_LINK_LABEL, RunViewError, RuntimeTarget, SCREENSHOT_DIR_RELATIVE_PATH, SCREENSHOT_FILE_EXTENSION, ServiceName, StackCheckVerdict, StackClaimVerdict, StackLeaseEndReason, StackMismatchKind, StackPortAction, Surface, WATCHER_LIFETIME_SECONDS, WATCHER_LIFETIME_UNBOUNDED_SECONDS, __export, __require, applyLlmSourceSelection, applyOnboardingAnswers, assertDeviceCodeClientProvisioned, buildElectronAppChecksumsUrl, buildElectronAppDirName, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, buildLlmSourcePlan, buildOnboardingPlan, buildToolInputJsonSchema, calculateFileChecksum, checkServiceStack, claimServiceStack, compareQueuePlaces, completeOnboarding, createApiKeyWithToken, createChildLogger, decideStackClaim, decideStackReap, decideStackRelease, decideStackRunEnd, decideStackRunStart, deleteApiKeyData, deleteCredentials, describeLlmSourceStatus, describeStackMismatch, e2e_exports2 as e2e_exports, evaluateCheckoutFreshness, findVacatedNeeds, finishStackRun, formatPreferencesOneLiner, getActiveElectronAppReleaseStream, getActiveRuntimeTarget, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDashboardBaseUrl, getDataDir, getDataDir2, getDisclosureCopy, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppReleaseTagPrefix, getElectronAppSignedFromVersion, getElectronAppVersion, getElectronAppVersionSource, getLlmSourceOption, getLocalQaTools, getLogger, getOnboardingToggleKeys, getPlatformKey, getQaTools, getReleaseSignerIdentityUri, getRunSessionsDir, getValidApiKeyData, getValidCredentials, hasApiKey, hasShownDisclosure, initTelemetry, isElectronAppInstalled, isElectronAppPlatform, isFirstRun, isValidLocalBaseUrl, loadApiKeyData, loadCredentials, local_exports2 as local_exports, lookUpCheckoutPullRequest, markDisclosureShown, markOnboardingCompleted, maskLlmApiKey, mcp_exports, needsConflict, needsOnboarding, openBrowserUrl, parseElectronAppDirName, performLogin, performLogout, pollDeviceCode, portOfUrl, readPreferencesMetadata, readRunView, readServiceStackStatus, reapServiceStack, reconcileProjectPreferences, recordOnboardingSkip, releaseServiceStack, renderRunViewHtml, renderRunViewText, resetConfig, resetLogger, resetPreference, resolveActiveProfile, resolveActiveReleaseStream, resolveActiveReleaseTagPrefix, resolveBlanketPreferences, resolveElectronAppExecutablePath, resolveElectronAppPathOrNull, resolveLlmSourceStatus, resolveOnboardingAnswers, resolvePreferences, resolveRunSessionPath, resolveRuntimeTarget, resolveTogglePreferences, runGitCommand, saveApiKey, saveApiKeyData, saveCredentials, src_exports, startDeviceCodeFlow, startStackRun, stopVacatedServices, toDisplayRef, toolRequiresAuth, track, validatePreference, verifyFileChecksum, writeLlmEnvBlock, writePreferences, writePreferencesWithMetadata, writeRunViewHtml };