@muggleai/works 5.31.0-staging.269 → 5.31.0-staging.271

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "muggleai",
       "source": "./plugin",
       "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-      "version": "5.31.0-staging.269"
+      "version": "5.31.0-staging.271"
     }
   ]
 }

package/README.md

@@ -273,7 +273,7 @@ so the result carries a viewUrl straight to the dashboard
 
 ## MCP tool reference
 
-108 tools across authentication, projects, use cases, test cases, scripts, workflows, local execution, reporting, secrets, billing, and administration. Call them directly from any MCP client to build your own pipeline.
+125 tools across authentication, projects, use cases, test cases, test states, scripts, workflows, local execution, reporting, secrets, billing, and administration. Call them directly from any MCP client to build your own pipeline.
 
 **Authentication** — `muggle-remote-auth-status`, `-login`, `-poll`, `-logout`, plus `-api-key-create`, `-list`, `-get`, `-revoke`.
 
@@ -301,6 +301,13 @@ so the result carries a viewUrl straight to the dashboard
 | `muggle-remote-test-case-bulk-preview-submit` | Async batch preview (~50% cheaper) |
 | `muggle-remote-test-plan-graph-rebuild` | Rebuild the prerequisite graph |
 
+| Test states | Purpose |
+| :---------- | :------ |
+| `muggle-remote-test-chaining-catalog-get` / `-settings-update` | Read a project's states and roles; set its fresh account set state and parallel account set limit |
+| `muggle-remote-test-state-create` / `-update` / `-delete` | Manage states: facts about one account set's data, plus a check |
+| `muggle-remote-test-role-create` / `-update` / `-delete` | Manage roles: created or supplied accounts a test acts as |
+| `muggle-remote-test-chaining-plan-get` | Preview the account set plan without running anything |
+
 Bulk-preview submissions return a `jobId` immediately. Poll `muggle-remote-bulk-preview-job-get` until terminal, then persist with the matching `-create` tool. `-list` and `-cancel` round out the set.
 
 | Scripts and workflows | Purpose |

package/dist/{chunk-J2DEXYH7.js → chunk-RQ43IPVN.js}

@@ -1,4 +1,4 @@
-import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getActiveRuntimeTarget, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, reconcileProjectPreferences, getDataDir2, PREFERENCES_FILE_NAME, isFirstRun, writePreferences, DEFAULT_PREFERENCES, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, getElectronAppSignedFromVersion, getReleaseSignerIdentityUri, verifyFileChecksum, resolveElectronAppExecutablePath, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, assertDeviceCodeClientProvisioned, performLogin, getActiveElectronAppReleaseStream, buildToolInputJsonSchema, toolRequiresAuth, getCallerCredentials, parseElectronAppDirName, getElectronAppReleaseTagPrefix, hasShownDisclosure, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, ElectronAppReleaseStream, buildElectronAppChecksumsUrl, __require, getDisclosureCopy, buildOnboardingPlan, applyOnboardingAnswers, needsOnboarding, buildLlmSourcePlan, describeLlmSourceStatus, resolveLlmSourceStatus, readRunView, RunViewError, renderRunViewText, writeRunViewHtml, openBrowserUrl, evaluateCheckoutFreshness, runGitCommand, BLOCKING_FRESHNESS_VERDICTS, claimServiceStack, BUSY_EXIT_CODE, checkServiceStack, releaseServiceStack, readServiceStackStatus, resolvePreferences, OnboardingBlanketChoice, PreferenceKey, LlmSource, applyLlmSourceSelection, describeStackMismatch, getDataDir, DEFAULT_LOCAL_LLM_BASE_URL, isValidLocalBaseUrl, local_exports } from './chunk-YLQSNSSM.js';
+import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getActiveRuntimeTarget, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, reconcileProjectPreferences, getDataDir2, PREFERENCES_FILE_NAME, isFirstRun, writePreferences, DEFAULT_PREFERENCES, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, getElectronAppSignedFromVersion, getReleaseSignerIdentityUri, verifyFileChecksum, resolveElectronAppExecutablePath, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, assertDeviceCodeClientProvisioned, performLogin, getActiveElectronAppReleaseStream, buildToolInputJsonSchema, toolRequiresAuth, getCallerCredentials, parseElectronAppDirName, getElectronAppReleaseTagPrefix, hasShownDisclosure, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, ElectronAppReleaseStream, buildElectronAppChecksumsUrl, __require, getDisclosureCopy, buildOnboardingPlan, applyOnboardingAnswers, needsOnboarding, buildLlmSourcePlan, describeLlmSourceStatus, resolveLlmSourceStatus, readRunView, RunViewError, renderRunViewText, writeRunViewHtml, openBrowserUrl, evaluateCheckoutFreshness, runGitCommand, BLOCKING_FRESHNESS_VERDICTS, claimServiceStack, BUSY_EXIT_CODE, checkServiceStack, releaseServiceStack, readServiceStackStatus, resolvePreferences, OnboardingBlanketChoice, PreferenceKey, LlmSource, applyLlmSourceSelection, describeStackMismatch, getDataDir, DEFAULT_LOCAL_LLM_BASE_URL, isValidLocalBaseUrl, local_exports } from './chunk-XUANXZ2O.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { v4 } from 'uuid';
@@ -1165,7 +1165,7 @@ async function resolveGsScreenshotUrls(report, opts) {
     if (gsUrls.length === 0) {
       return report;
     }
-    const mcps = await import('./src-7OY7H63R.js');
+    const mcps = await import('./src-J6AIYTLA.js');
     const credentials = await mcps.getCallerCredentialsAsync();
     if (!credentials.bearerToken && !credentials.apiKey) {
       stderrWrite(
@@ -2830,6 +2830,13 @@ var ClaudeTurnStatus = /* @__PURE__ */ ((ClaudeTurnStatus2) => {
   ClaudeTurnStatus2["Waiting"] = "waiting";
   return ClaudeTurnStatus2;
 })(ClaudeTurnStatus || {});
+var ClaudeProcessStatus = /* @__PURE__ */ ((ClaudeProcessStatus2) => {
+  ClaudeProcessStatus2["Idle"] = "idle";
+  ClaudeProcessStatus2["Busy"] = "busy";
+  ClaudeProcessStatus2["Shell"] = "shell";
+  ClaudeProcessStatus2["Waiting"] = "waiting";
+  return ClaudeProcessStatus2;
+})(ClaudeProcessStatus || {});
 var ClaudeJobState = /* @__PURE__ */ ((ClaudeJobState2) => {
   ClaudeJobState2["Working"] = "working";
   ClaudeJobState2["Blocked"] = "blocked";
@@ -2932,6 +2939,12 @@ var CLAUDE_SESSION_REGISTRY_DIR_NAME = "sessions";
 var CLAUDE_PROJECTS_DIR_NAME = "projects";
 var CLAUDE_INSTALLED_PLUGINS_RELATIVE_PATH = ["plugins", "installed_plugins.json"];
 var CLAUDE_GLOBAL_CONFIG_FILE_NAME = ".claude.json";
+var CLAUDE_SETTINGS_FILE_NAME = "settings.json";
+var CLAUDE_CREDENTIALS_FILE_NAME = ".credentials.json";
+var REMOTE_CONTROL_MAX_RESTARTS = 2;
+var REMOTE_CONTROL_RESTART_WINDOW_MS = 24 * 60 * 6e4;
+var REMOTE_CONTROL_RESTART_COOLDOWN_MS = 30 * 6e4;
+var REMOTE_CONTROL_NAME_COLUMN_WIDTH = 32;
 var USAGE_WINDOW_EXHAUSTED_PERCENT = 100;
 var RELOAD_PLUGIN_SCOPE = "user";
 var MUGGLE_PLUGIN_ID = "muggleai@muggle-works";
@@ -2987,6 +3000,8 @@ function resolveWatchPaths(env = process.env) {
     claudeProjectsDir: join(claudeConfigDir, CLAUDE_PROJECTS_DIR_NAME),
     claudeInstalledPluginsFile: join(claudeConfigDir, ...CLAUDE_INSTALLED_PLUGINS_RELATIVE_PATH),
     claudeGlobalConfigFile: join(env.CLAUDE_CONFIG_DIR || homedir(), CLAUDE_GLOBAL_CONFIG_FILE_NAME),
+    claudeSettingsFile: join(claudeConfigDir, CLAUDE_SETTINGS_FILE_NAME),
+    claudeCredentialsFile: join(claudeConfigDir, CLAUDE_CREDENTIALS_FILE_NAME),
     codexSessionsDir: join(codexHome, "sessions"),
     muggleInstallLogFile: join(muggleDataDir, MUGGLE_INSTALL_LOG_FILE)
   };
@@ -4841,6 +4856,9 @@ function processSummary(snapshot) {
     `${countOf("pr-watch-loop" /* PrWatchLoop */)} PR watch loop processes`
   ].join(", ");
 }
+function countDecisions(report, action) {
+  return report.decisions.filter((decision) => decision.action === action).length;
+}
 function renderWatchStatus(snapshot, nowMs) {
   const lines = [];
   const snapshotAgeMs = nowMs - Date.parse(snapshot.takenAt);
@@ -4883,12 +4901,24 @@ function renderWatchStatus(snapshot, nowMs) {
     }
   }
   if (snapshot.reload) {
-    const countOf = (action) => snapshot.reload?.decisions.filter((decision) => decision.action === action).length ?? 0;
+    const reload = snapshot.reload;
     lines.push(
       "",
-      `Plugin reload: ${snapshot.reload.respawnedSessionIds.length} restarted, ${snapshot.reload.failedSessionIds.length} failed, ${countOf("defer" /* Defer */)} deferred, ${countOf("notify-manual" /* NotifyManual */) + (snapshot.reload.untrustedSessionIds?.length ?? 0)} need /reload-plugins by hand`
+      `Plugin reload: ${reload.respawnedSessionIds.length} restarted, ${reload.failedSessionIds.length} failed, ${countDecisions(reload, "defer" /* Defer */)} deferred, ${countDecisions(reload, "notify-manual" /* NotifyManual */) + (reload.untrustedSessionIds?.length ?? 0)} need /reload-plugins by hand`
     );
   }
+  if (snapshot.remoteControl) {
+    const remoteControl = snapshot.remoteControl;
+    lines.push(
+      "",
+      `Remote Control: ${remoteControl.connectedSessionIds.length} connected, ${remoteControl.respawnedSessionIds.length} restarted, ${remoteControl.failedSessionIds.length} failed, ${remoteControl.untrustedSessionIds.length} refused, ${countDecisions(remoteControl, "defer" /* Defer */)} waiting, ${countDecisions(remoteControl, "skip" /* Skip */) + countDecisions(remoteControl, "notify-manual" /* NotifyManual */)} skipped`
+    );
+    for (const decision of remoteControl.decisions) {
+      const outcome = remoteControl.untrustedSessionIds.includes(decision.sessionId) ? " \u2014 refused: its workspace takes no background restart, run /remote-control in it" : remoteControl.failedSessionIds.includes(decision.sessionId) ? " \u2014 restart failed" : "";
+      const label = (decision.name ?? "").slice(0, REMOTE_CONTROL_NAME_COLUMN_WIDTH).padEnd(REMOTE_CONTROL_NAME_COLUMN_WIDTH);
+      lines.push(`  ${decision.action.padEnd(14)} ${shortSessionId(decision.sessionId)} ${label} ${decision.reason}${outcome}`);
+    }
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -4921,6 +4951,32 @@ function cwdFromSessionHead(head) {
   }
 }
 
+// src/watch/claude-account.ts
+function isRemoteControlAtStartup(claudeSettingsFile) {
+  try {
+    const settings = JSON.parse(readFileSync(claudeSettingsFile, "utf-8"));
+    return settings.remoteControlAtStartup === true;
+  } catch {
+    return false;
+  }
+}
+function readClaudeLogin(claudeGlobalConfigFile, claudeCredentialsFile) {
+  let accountUuid;
+  try {
+    const config = JSON.parse(readFileSync(claudeGlobalConfigFile, "utf-8"));
+    accountUuid = optionalString(config.oauthAccount?.accountUuid);
+  } catch {
+    accountUuid = void 0;
+  }
+  let credentialsWrittenAtMs;
+  try {
+    credentialsWrittenAtMs = statSync(claudeCredentialsFile).mtimeMs;
+  } catch {
+    credentialsWrittenAtMs = void 0;
+  }
+  return { accountUuid, credentialsWrittenAtMs };
+}
+
 // src/watch/session-liveness.ts
 function hasLiveProcess(session) {
   if (session.agent !== "claude" /* Claude */) return true;
@@ -4931,25 +4987,30 @@ function isIdleBackgroundSession(session) {
 }
 
 // src/watch/claude-sessions.ts
-function readPidsBySessionId(registryDir) {
-  const pidsBySessionId = /* @__PURE__ */ new Map();
+function readRegistryBySessionId(registryDir) {
+  const entriesBySessionId = /* @__PURE__ */ new Map();
   let fileNames;
   try {
     fileNames = readdirSync(registryDir).filter((fileName) => fileName.endsWith(".json"));
   } catch {
-    return pidsBySessionId;
+    return entriesBySessionId;
   }
   for (const fileName of fileNames) {
     try {
       const entry = JSON.parse(readFileSync(join(registryDir, fileName), "utf-8"));
       if (typeof entry.pid === "number" && typeof entry.sessionId === "string") {
-        pidsBySessionId.set(entry.sessionId, entry.pid);
+        entriesBySessionId.set(entry.sessionId, {
+          pid: entry.pid,
+          processStatus: enumValueOf(ClaudeProcessStatus, entry.status),
+          processStatusSinceMs: typeof entry.statusUpdatedAt === "number" ? entry.statusUpdatedAt : void 0,
+          remoteControlSessionId: optionalString(entry.bridgeSessionId)
+        });
       }
     } catch {
       continue;
     }
   }
-  return pidsBySessionId;
+  return entriesBySessionId;
 }
 function waitForSessionExit(runCommand, registryDir, sessionId, sleep2 = blockFor) {
   for (let waitedMs = 0; ; waitedMs += SESSION_EXIT_POLL_MS) {
@@ -4971,11 +5032,12 @@ function readClaudeSessions(runCommand, registryDir) {
   } catch {
     return null;
   }
-  const pidsBySessionId = readPidsBySessionId(registryDir);
+  const registryBySessionId = readRegistryBySessionId(registryDir);
   const sessions = [];
   for (const listing of listings) {
     const sessionId = optionalString(listing.sessionId);
     if (!sessionId) continue;
+    const registryEntry = registryBySessionId.get(sessionId);
     sessions.push({
       agent: "claude" /* Claude */,
       sessionId,
@@ -4986,7 +5048,10 @@ function readClaudeSessions(runCommand, registryDir) {
       turnStatus: enumValueOf(ClaudeTurnStatus, listing.status),
       jobState: enumValueOf(ClaudeJobState, listing.state),
       startedAtMs: typeof listing.startedAt === "number" ? listing.startedAt : void 0,
-      pid: typeof listing.pid === "number" ? listing.pid : pidsBySessionId.get(sessionId)
+      pid: typeof listing.pid === "number" ? listing.pid : registryEntry?.pid,
+      processStatus: registryEntry?.processStatus,
+      processStatusSinceMs: registryEntry?.processStatusSinceMs,
+      remoteControlSessionId: registryEntry?.remoteControlSessionId
     });
   }
   return sessions;
@@ -5381,26 +5446,29 @@ function executeWatcherRecoveries(planned, attemptsByOwner, deps) {
 }
 
 // src/watch/findings.ts
-function resolveWatcherLiveness(loop, heartbeatAgeMs, isOwnerSessionActive, isProcessTableKnown, isHeardByService = false) {
+function resolveWatcherLiveness(loop, heartbeatAgeMs, isOwnerSessionActive, isProcessTableKnown, isHeardByService = false, isLoopDroppedByOwner = false) {
   const isHeartbeatWithin = (windowMs) => heartbeatAgeMs !== void 0 && heartbeatAgeMs <= windowMs;
   if (!isProcessTableKnown) {
     return isHeartbeatWithin(WATCH_HEARTBEAT_STALE_MS) ? "polling" /* Polling */ : "dead" /* Dead */;
   }
   if (loop) {
-    return isOwnerSessionActive === false && !isHeardByService ? "deaf" /* Deaf */ : "polling" /* Polling */;
+    const isUnheard = !isHeardByService && (isOwnerSessionActive === false || isLoopDroppedByOwner);
+    return isUnheard ? "deaf" /* Deaf */ : "polling" /* Polling */;
   }
   return isHeartbeatWithin(WATCHER_REARM_GRACE_MS) ? "rearming" /* Rearming */ : "dead" /* Dead */;
 }
 function oldestLoopFor(slug, processes) {
   return processes.filter((tracked) => tracked.kind === "pr-watch-loop" /* PrWatchLoop */ && tracked.watchSlotSlug === slug).sort((left, right) => (right.ageMs ?? 0) - (left.ageMs ?? 0))[0];
 }
-function assessWatchSlots(slots, processes, activeSessionIds, liveStatusesByUrl, nowMs) {
+function assessWatchSlots(slots, processes, activeSessionIds, liveStatusesByUrl, nowMs, idleSinceBySessionId2 = /* @__PURE__ */ new Map()) {
   const assessments = [];
   for (const slot of slots) {
     const loop = processes ? oldestLoopFor(slot.slug, processes) : void 0;
     const heartbeatAgeMs = slot.heartbeatMtimeMs === void 0 ? void 0 : Math.max(0, nowMs - slot.heartbeatMtimeMs);
     const isOwnerSessionActive = slot.ownerSessionId === void 0 || activeSessionIds === null ? void 0 : activeSessionIds.has(slot.ownerSessionId);
-    const watcher = resolveWatcherLiveness(loop, heartbeatAgeMs, isOwnerSessionActive, processes !== null, slot.isHeardByService);
+    const ownerIdleSinceMs = slot.ownerSessionId === void 0 ? void 0 : idleSinceBySessionId2.get(slot.ownerSessionId);
+    const isLoopDroppedByOwner = ownerIdleSinceMs !== void 0 && loop?.ageMs !== void 0 && ownerIdleSinceMs >= nowMs - loop.ageMs;
+    const watcher = resolveWatcherLiveness(loop, heartbeatAgeMs, isOwnerSessionActive, processes !== null, slot.isHeardByService, isLoopDroppedByOwner);
     const reportAgeMs = slot.serviceLoopReport === void 0 ? void 0 : Math.max(0, nowMs - slot.serviceLoopReport.writtenAtMs);
     for (const pr of slot.openPrs) {
       const live = liveStatusesByUrl.get(pr.url);
@@ -5415,6 +5483,7 @@ function assessWatchSlots(slots, processes, activeSessionIds, liveStatusesByUrl,
         heartbeatAgeMs,
         ownerSessionId: slot.ownerSessionId,
         isOwnerSessionActive,
+        isLoopDroppedByOwner,
         live,
         ownerEscalation: resolveOwnerEscalation(slot.lastSeenJson, slot.followupLogLines, pr, live?.headSha),
         isHeardByService: slot.isHeardByService,
@@ -5461,11 +5530,12 @@ function watcherFinding(assessment, subject) {
     );
   }
   if (assessment.watcher === "deaf" /* Deaf */) {
+    const ownerState = assessment.isLoopDroppedByOwner ? "is running but no longer holds it" : "has ended";
     return finding(
       "WATCHER_DEAF" /* WatcherDeaf */,
       [assessment.pr.url, assessment.loopPid],
       subject,
-      `watch loop pid ${assessment.loopPid} reports to no session: its owner session ${shortSessionId(assessment.ownerSessionId ?? "")} has ended`
+      `watch loop pid ${assessment.loopPid} reports to no session: its owner session ${shortSessionId(assessment.ownerSessionId ?? "")} ${ownerState}`
     );
   }
   return void 0;
@@ -5906,6 +5976,75 @@ function advancePendingReload(pending, report) {
     skippedSessionIds: [...pending.skippedSessionIds, ...report.untrustedSessionIds]
   };
 }
+
+// src/watch/remote-control.ts
+function advanceClaudeLogin(previous, observed, nowMs) {
+  if (observed.accountUuid === void 0) return previous;
+  if (previous === void 0) return { accountUuid: observed.accountUuid, observedAtMs: nowMs };
+  if (previous.accountUuid === observed.accountUuid) return { ...previous, observedAtMs: nowMs };
+  const writtenAtMs = Math.min(observed.credentialsWrittenAtMs ?? nowMs, nowMs);
+  return { accountUuid: observed.accountUuid, effectiveAtMs: Math.max(previous.observedAtMs, writtenAtMs), observedAtMs: nowMs };
+}
+function remoteControlGapOf(session, login) {
+  if (session.remoteControlSessionId === void 0) return "no Remote Control link";
+  const isStartedBeforeLogin = login.effectiveAtMs !== void 0 && session.startedAtMs !== void 0 && session.startedAtMs < login.effectiveAtMs;
+  return isStartedBeforeLogin ? "linked under an earlier login" : void 0;
+}
+function isTurnOver(session) {
+  if (session.processStatus !== void 0) {
+    return session.processStatus === "idle" /* Idle */ || session.processStatus === "shell" /* Shell */;
+  }
+  return session.turnStatus === "idle" /* Idle */;
+}
+function recentRestartsMs(restartsBySession, sessionId, nowMs) {
+  return (restartsBySession[sessionId] ?? []).map((restartedAt) => Date.parse(restartedAt)).filter((restartedAtMs) => !Number.isNaN(restartedAtMs) && nowMs - restartedAtMs < REMOTE_CONTROL_RESTART_WINDOW_MS);
+}
+function decide2(session, action, reason) {
+  return { sessionId: session.sessionId, shortId: session.shortId, name: session.name, cwd: session.cwd, action, reason };
+}
+function planRemoteControlRestarts(sessions, login, restartsBySession, nowMs, maxRestarts) {
+  let restartsPlanned = 0;
+  const connectedSessionIds = [];
+  const decisions = [];
+  for (const session of sessions) {
+    if (session.agent !== "claude" /* Claude */ || !hasLiveProcess(session)) continue;
+    const gap = remoteControlGapOf(session, login);
+    if (gap === void 0) {
+      connectedSessionIds.push(session.sessionId);
+      continue;
+    }
+    const restartsMs = recentRestartsMs(restartsBySession, session.sessionId, nowMs);
+    if (session.kind === "interactive" /* Interactive */) {
+      decisions.push(decide2(session, "notify-manual" /* NotifyManual */, `${gap} \u2014 terminal session, run /remote-control in it`));
+    } else if (session.kind !== "background" /* Background */ || !session.shortId) {
+      decisions.push(decide2(session, "skip" /* Skip */, `${gap} \u2014 not a background session the watch can restart`));
+    } else if (restartsMs.length >= REMOTE_CONTROL_MAX_RESTARTS) {
+      decisions.push(decide2(session, "skip" /* Skip */, `${gap} after ${restartsMs.length} restarts today`));
+    } else if (nowMs - Math.max(-Infinity, ...restartsMs) < REMOTE_CONTROL_RESTART_COOLDOWN_MS) {
+      decisions.push(decide2(session, "skip" /* Skip */, `${gap} \u2014 restarted recently, waiting for it to link`));
+    } else if (!isTurnOver(session)) {
+      decisions.push(decide2(session, "defer" /* Defer */, `${gap} \u2014 turn in flight (${session.processStatus ?? session.turnStatus ?? "unknown"})`));
+    } else if (restartsPlanned >= maxRestarts) {
+      decisions.push(decide2(session, "defer" /* Defer */, `${gap} \u2014 restart cap reached this pass`));
+    } else {
+      restartsPlanned++;
+      decisions.push(decide2(session, "respawn" /* Respawn */, gap));
+    }
+  }
+  return { connectedSessionIds, decisions };
+}
+function recordRemoteControlRestarts(restartsBySession, report, nowMs) {
+  const nowIso = new Date(nowMs).toISOString();
+  const nextRestartsBySession = {};
+  for (const sessionId of Object.keys(restartsBySession)) {
+    const recent = recentRestartsMs(restartsBySession, sessionId, nowMs).map((restartedAtMs) => new Date(restartedAtMs).toISOString());
+    if (recent.length > 0) nextRestartsBySession[sessionId] = recent;
+  }
+  for (const sessionId of [...report.respawnedSessionIds, ...report.failedSessionIds, ...report.untrustedSessionIds]) {
+    nextRestartsBySession[sessionId] = [...nextRestartsBySession[sessionId] ?? [], nowIso];
+  }
+  return nextRestartsBySession;
+}
 function resolvePluginRoot(env = process.env) {
   return env.CLAUDE_PLUGIN_ROOT || env.CURSOR_PLUGIN_ROOT || dirname(dirname(fileURLToPath(import.meta.url)));
 }
@@ -6273,6 +6412,7 @@ function createDefaultWatchTickDeps(options) {
     notify: createDesktopNotifier(process.platform, defaultCommandRunner),
     isAutoReloadEnabled: options.isAutoReloadEnabled,
     isRecoveryEnabled: options.isRecoveryEnabled,
+    isRemoteControlKeptOn: options.isRemoteControlKeptOn,
     launchServiceLoop: createServiceLoopLauncher(process.platform, defaultCommandRunner)
   };
 }
@@ -6292,18 +6432,26 @@ function observeSessions(deps, installs) {
   const sessions = [...claudeSessions ?? [], ...readCodexSessions(deps.paths.codexSessionsDir, deps.nowMs)];
   return { processes, claudeSessions, sessions };
 }
+function idleSinceBySessionId(runningSessions) {
+  return new Map(
+    runningSessions.flatMap(
+      (session) => session.processStatus === "idle" /* Idle */ && session.processStatusSinceMs !== void 0 ? [[session.sessionId, session.processStatusSinceMs]] : []
+    )
+  );
+}
 function isRestartAttempted(recovery) {
   return recovery.outcome === "resumed" /* Resumed */ || recovery.outcome === "resume-failed" /* ResumeFailed */;
 }
 function watchOwnersOf(slots) {
   return new Set(slots.flatMap((slot) => !isTerminalPrState(slot.live?.state) && slot.ownerSessionId ? [slot.ownerSessionId] : []));
 }
-function reloadEvents(report, at) {
+function reloadEvents(report, at, restartPurpose) {
   const decisionById = new Map(report.decisions.map((decision) => [decision.sessionId, decision]));
   const describe = (sessionId) => `session ${decisionById.get(sessionId)?.name ?? shortSessionId(sessionId)}`;
+  const purposeOf = (sessionId) => restartPurpose === void 0 ? {} : { message: `${restartPurpose}: ${decisionById.get(sessionId)?.reason ?? ""}` };
   return [
-    ...report.respawnedSessionIds.map((sessionId) => ({ at, kind: "respawned" /* Respawned */, subject: describe(sessionId) })),
-    ...report.failedSessionIds.map((sessionId) => ({ at, kind: "respawn-failed" /* RespawnFailed */, subject: describe(sessionId) })),
+    ...report.respawnedSessionIds.map((sessionId) => ({ at, kind: "respawned" /* Respawned */, subject: describe(sessionId), ...purposeOf(sessionId) })),
+    ...report.failedSessionIds.map((sessionId) => ({ at, kind: "respawn-failed" /* RespawnFailed */, subject: describe(sessionId), ...purposeOf(sessionId) })),
     ...report.untrustedSessionIds.map((sessionId) => ({
       at,
       kind: "restart-refused" /* RestartRefused */,
@@ -6321,6 +6469,15 @@ function runReloadPass(record, claudeSessions, watchOwnerSessionIds, deps, at) {
   const report = executeReloadFanOut(decisions, deps.runCommand, canRestartVia(deps));
   return { report, pendingReload: advancePendingReload(record, report), events: reloadEvents(report, at) };
 }
+function runRemoteControlPass(login, claudeSessions, restartsBySession, maxRestarts, deps, at) {
+  const plan = planRemoteControlRestarts(claudeSessions, login, restartsBySession, deps.nowMs, maxRestarts);
+  const executed = executeReloadFanOut(plan.decisions, deps.runCommand, canRestartVia(deps));
+  return {
+    report: { ...executed, connectedSessionIds: plan.connectedSessionIds },
+    restartsBySession: recordRemoteControlRestarts(restartsBySession, executed, deps.nowMs),
+    events: reloadEvents(executed, at, "restarted to reconnect Remote Control")
+  };
+}
 function canRestartVia(deps) {
   return (cwd) => canRestartSessionIn(cwd, deps.runCommand);
 }
@@ -6366,7 +6523,7 @@ function runTickUnlocked(deps) {
     at
   );
   for (const cachedStatus of cachedStatuses) liveStatusesByUrl.set(cachedStatus.url, cachedStatus);
-  const allAssessments = assessWatchSlots(slots, processes, activeSessionIds, liveStatusesByUrl, deps.nowMs);
+  const allAssessments = assessWatchSlots(slots, processes, activeSessionIds, liveStatusesByUrl, deps.nowMs, idleSinceBySessionId(runningSessions));
   const closeOut = closeOutTerminalSlots(allAssessments, deps, at);
   const assessments = allAssessments.filter((assessment) => !closeOut.closedOutSlugs.includes(assessment.slug));
   const findings = deriveWatchFindings(assessments, processes ?? [], isPollingDisabled);
@@ -6409,16 +6566,34 @@ function runTickUnlocked(deps) {
     serviceArms = started.serviceArms;
     events.push(...started.events);
   }
+  const restartedSessionIds = new Set(recoveries.filter(isRestartAttempted).map((recovery) => recovery.ownerSessionId));
   let pendingReload = state.pendingReload;
   let reload;
   const targetAtMs = reloadTargetAtMs(deps, installs);
   if (deps.isAutoReloadEnabled && targetAtMs !== void 0 && claudeSessions !== null) {
-    const restartedOwnerIds = new Set(recoveries.filter(isRestartAttempted).map((recovery) => recovery.ownerSessionId));
-    const reloadableSessions = claudeSessions.filter((session) => !restartedOwnerIds.has(session.sessionId));
+    const reloadableSessions = claudeSessions.filter((session) => !restartedSessionIds.has(session.sessionId));
     const pass = runReloadPass(reloadRecordFor(state, targetAtMs), reloadableSessions, watchOwnersOf(assessments), deps, at);
     pendingReload = pass.pendingReload;
     reload = pass.report;
     events.push(...pass.events);
+    for (const sessionId of [...reload.respawnedSessionIds, ...reload.failedSessionIds]) restartedSessionIds.add(sessionId);
+  }
+  const observedLogin = readClaudeLogin(deps.paths.claudeGlobalConfigFile, deps.paths.claudeCredentialsFile);
+  const claudeLogin = advanceClaudeLogin(state.claudeLogin, observedLogin, deps.nowMs);
+  let remoteControlRestartsBySession = state.remoteControlRestartsBySession ?? {};
+  let remoteControl;
+  if (deps.isRemoteControlKeptOn && claudeSessions !== null && claudeLogin !== void 0 && observedLogin.accountUuid !== void 0 && isRemoteControlAtStartup(deps.paths.claudeSettingsFile)) {
+    const pass = runRemoteControlPass(
+      claudeLogin,
+      claudeSessions.filter((session) => !restartedSessionIds.has(session.sessionId)),
+      remoteControlRestartsBySession,
+      Math.max(0, MAX_RESPAWNS_PER_TICK - (reload ? reload.respawnedSessionIds.length + reload.failedSessionIds.length : 0)),
+      deps,
+      at
+    );
+    remoteControl = pass.report;
+    remoteControlRestartsBySession = pass.restartsBySession;
+    events.push(...pass.events);
   }
   appendWatchEvents(deps.paths.watchDir, events);
   notifyIfAny(deps, composeTickNotification(transitions.raised, recoveries, reload));
@@ -6426,7 +6601,9 @@ function runTickUnlocked(deps) {
     activeFindings: transitions.activeFindings,
     recoveryAttemptsByOwner,
     terminalPrsByUrl,
-    pendingReload
+    pendingReload,
+    claudeLogin,
+    remoteControlRestartsBySession
   });
   const snapshot = {
     takenAt: at,
@@ -6439,7 +6616,8 @@ function runTickUnlocked(deps) {
     findings,
     recoveries,
     serviceArms,
-    reload
+    reload,
+    remoteControl
   };
   writeWatchSnapshot(deps.paths.watchDir, snapshot);
   return snapshot;
@@ -6493,7 +6671,11 @@ function failWith(message) {
 function watchTickCommand(flags) {
   try {
     const snapshot = runWatchTick(
-      createDefaultWatchTickDeps({ isAutoReloadEnabled: flags.autoReload, isRecoveryEnabled: flags.recovery })
+      createDefaultWatchTickDeps({
+        isAutoReloadEnabled: flags.autoReload,
+        isRecoveryEnabled: flags.recovery,
+        isRemoteControlKeptOn: flags.remoteControl
+      })
     );
     if (flags.json) {
       process.stdout.write(`${JSON.stringify(snapshot, null, 2)}
@@ -6533,7 +6715,10 @@ function renderReloadReport(report, isDryRun) {
 function watchReloadPluginsCommand(flags) {
   try {
     const isDryRun = flags.dryRun === true;
-    const report = runReloadPluginsPass(createDefaultWatchTickDeps({ isAutoReloadEnabled: true, isRecoveryEnabled: false }), isDryRun);
+    const report = runReloadPluginsPass(
+      createDefaultWatchTickDeps({ isAutoReloadEnabled: true, isRecoveryEnabled: false, isRemoteControlKeptOn: false }),
+      isDryRun
+    );
     if (!report) {
       failWith("could not list Claude sessions (`claude agents --json` failed)");
       return;
@@ -6618,7 +6803,7 @@ function createProgram() {
   stack.command("status").description("Show every lease, the line, and the services prepare tracks").option("--json", "Print the full report as JSON").action(stackStatusCommand);
   program.command("ci-install").description("Add the Muggle walkthrough check to this repository's GitHub Actions").option("--force", "Replace an existing workflow file").action(ciInstallCommand);
   const watch = program.command("watch").description("Standing watch over Claude/Codex sessions, their processes, and PR watchers");
-  watch.command("tick").description("Run one watch pass (the scheduled task runs this)").option("--no-auto-reload", "Do not start a plugin reload fan-out when installed plugins change").option("--no-recovery", "Report dead watchers without resuming their owner sessions").option("--json", "Print the full snapshot as JSON").action(watchTickCommand);
+  watch.command("tick").description("Run one watch pass (the scheduled task runs this)").option("--no-auto-reload", "Do not start a plugin reload fan-out when installed plugins change").option("--no-recovery", "Report dead watchers without resuming their owner sessions").option("--no-remote-control", "Report sessions off Remote Control without restarting them").option("--json", "Print the full snapshot as JSON").action(watchTickCommand);
   watch.command("status").description("Show the last watch pass: sessions, processes, PR watches, findings").option("--json", "Print the snapshot as JSON").action(watchStatusCommand);
   watch.command("reload-plugins").description("Reload plugins across active Claude sessions (respawns idle background ones)").option("--dry-run", "Show what each session would get without respawning anything").option("--json", "Print the report as JSON").action(watchReloadPluginsCommand);
   watch.command("install").description("Schedule the watch with this OS's scheduler, or refresh the entry in place").option("--uninstall", "Remove the task; the ledger is kept").option("--no-wait", "Return once the task is registered, without waiting for its first pass").option("--from-preference", "Act on the autoInstallWatchService preference, as an install or upgrade does").action(watchInstallCommand);

package/dist/{chunk-YLQSNSSM.js → chunk-XUANXZ2O.js}

@@ -6375,6 +6375,9 @@ var PinnedAccountSchema = z.object({
 
 // packages/mcps/src/mcp/e2e/contracts/constants.ts
 var WORKFLOW_RUNTIME_ID_NOT_RUN_ID_HINT = "Use the `workflowRuntimeId` returned when the workflow was started \u2014 not a run `id` or a test runs summary's `latestWorkflowRunId`, which are run ids and are not found here.";
+var TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_MIN = 1;
+var TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_MAX = 20;
+var TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_DEFAULT = 5;
 var FanOutChoice = /* @__PURE__ */ ((FanOutChoice2) => {
   FanOutChoice2["FollowPolicy"] = "followPolicy";
   FanOutChoice2["PrimaryOnly"] = "primaryOnly";
@@ -6401,6 +6404,85 @@ var SecretFieldEnum = /* @__PURE__ */ ((SecretFieldEnum2) => {
   SecretFieldEnum2["BILLING_POSTAL_CODE"] = "billing_postal_code";
   return SecretFieldEnum2;
 })(SecretFieldEnum || {});
+
+// packages/mcps/src/mcp/e2e/contracts/test-state-types.ts
+var TestStateFactScopeEnum = /* @__PURE__ */ ((TestStateFactScopeEnum2) => {
+  TestStateFactScopeEnum2["ACCOUNT_SET"] = "ACCOUNT_SET";
+  TestStateFactScopeEnum2["ACCOUNT"] = "ACCOUNT";
+  return TestStateFactScopeEnum2;
+})(TestStateFactScopeEnum || {});
+var TestRoleSourceEnum = /* @__PURE__ */ ((TestRoleSourceEnum2) => {
+  TestRoleSourceEnum2["CREATED"] = "CREATED";
+  TestRoleSourceEnum2["SUPPLIED"] = "SUPPLIED";
+  return TestRoleSourceEnum2;
+})(TestRoleSourceEnum || {});
+
+// packages/mcps/src/mcp/e2e/contracts/test-state-schemas.ts
+var TestStateProjectIdSchema = MuggleEntityIdSchema.describe("Project ID (UUID) that owns the test states and roles");
+var TestStateIdSchema = MuggleEntityIdSchema.describe("Test state ID (UUID)");
+var TestRoleIdSchema = MuggleEntityIdSchema.describe("Test role ID (UUID)");
+var TestStateFactSchema = z.object({
+  statement: z.string().min(1).describe("What holds, e.g. 'the thread shows one unread message'"),
+  scope: z.enum(TestStateFactScopeEnum).describe(
+    "ACCOUNT_SET: only this account set's data, e.g. the patient's thread with the doctor. ACCOUNT: one account as a whole, e.g. the doctor's unread count"
+  ),
+  roleId: MuggleEntityIdSchema.nullable().describe("Test role ID (UUID) whose account an ACCOUNT fact is about; null for an ACCOUNT_SET fact")
+});
+var TestStateFactsSchema = z.array(TestStateFactSchema).describe("Every fact the state's tests rely on");
+var TestStateCheckSchema = z.string().describe("Quick read-only check that an account set is in this state, e.g. 'the thread shows one unread message'; may be empty");
+var TestRoleSourceSchema = z.enum(TestRoleSourceEnum).describe("CREATED: Muggle signs the account up itself. SUPPLIED: the customer provides the account");
+var TestRoleAllowsChangesSchema = z.boolean().describe("SUPPLIED only: the customer allows tests to change the account's account-wide facts when a proven way back restores them");
+var TestChainingCatalogGetInputSchema = z.object({
+  projectId: TestStateProjectIdSchema
+});
+var TestChainingSettingsUpdateInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  freshAccountSetStateId: MuggleEntityIdSchema.nullable().optional().describe("Test state ID (UUID) a newly formed account set starts in, e.g. 'New patient'; null clears it"),
+  parallelAccountSetLimit: z.number().int().min(TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_MIN).max(TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_MAX).optional().describe(`Most account sets a batch runs at once (default ${TEST_STATE_PARALLEL_ACCOUNT_SET_LIMIT_DEFAULT})`)
+});
+var TestStateCreateInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  name: z.string().min(1).describe("State name, unique per project ignoring case, e.g. 'Message unread'"),
+  facts: TestStateFactsSchema.optional(),
+  check: TestStateCheckSchema.optional()
+});
+var TestStateUpdateInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  stateId: TestStateIdSchema,
+  name: z.string().min(1).optional().describe("New state name, unique per project ignoring case"),
+  facts: TestStateFactsSchema.optional(),
+  check: TestStateCheckSchema.optional()
+});
+var TestStateDeleteInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  stateId: TestStateIdSchema
+});
+var TestRoleCreateInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  name: z.string().min(1).describe("Role name, unique per project ignoring case, e.g. 'Patient'"),
+  source: TestRoleSourceSchema,
+  allowsChanges: TestRoleAllowsChangesSchema.optional()
+});
+var TestRoleUpdateInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  roleId: TestRoleIdSchema,
+  name: z.string().min(1).optional().describe("New role name, unique per project ignoring case"),
+  source: TestRoleSourceSchema.optional(),
+  allowsChanges: TestRoleAllowsChangesSchema.optional()
+});
+var TestRoleDeleteInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  roleId: TestRoleIdSchema
+});
+var TestChainingPlanGetInputSchema = z.object({
+  projectId: TestStateProjectIdSchema,
+  isProduction: z.boolean().optional().describe("True to plan for production, which runs at the floor with no extra account sets for speed (default false)")
+});
+var TestCaseTestStateFieldsSchema = z.object({
+  actsAsRoleIds: z.array(MuggleEntityIdSchema).nullable().optional().describe("Test role IDs (UUID) the test acts as, in order; null clears them"),
+  prerequisiteStateId: MuggleEntityIdSchema.nullable().optional().describe("Test state ID (UUID) the test needs to start; null clears it"),
+  resultStateId: MuggleEntityIdSchema.nullable().optional().describe("Test state ID (UUID) the test leaves when it passes; the prerequisite's ID for an observation; null clears it")
+});
 var FanOutPlanInputSchema = z.object({
   projectId: z.string().min(1).describe("Project ID"),
   testCaseId: z.string().min(1).describe("Test case ID whose fan-out to plan"),
@@ -6720,7 +6802,8 @@ var TestCaseCreateInputSchema = z.object({
   category: z.string().optional().describe("Test case category"),
   automated: z.boolean().optional().describe("Whether this test case is automated (default: true)"),
   pinnedAccount: PinnedAccountSchema.optional().describe("Project secrets the test case signs in as. Omit to leave it unpinned"),
-  alwaysStartsFreshSession: z.boolean().optional().describe(ALWAYS_STARTS_FRESH_SESSION_DESCRIPTION)
+  alwaysStartsFreshSession: z.boolean().optional().describe(ALWAYS_STARTS_FRESH_SESSION_DESCRIPTION),
+  ...TestCaseTestStateFieldsSchema.shape
 });
 var TestCaseUpdateInputSchema = z.object({
   testCaseId: IdSchema.describe("Test case ID (UUID) to update"),
@@ -6736,7 +6819,8 @@ var TestCaseUpdateInputSchema = z.object({
   category: z.string().optional().describe("Updated category"),
   automated: z.boolean().optional().describe("Whether this test case is automated"),
   pinnedAccount: PinnedAccountSchema.nullable().optional().describe("Project secrets the test case signs in as; null clears the pin"),
-  alwaysStartsFreshSession: z.boolean().optional().describe(ALWAYS_STARTS_FRESH_SESSION_DESCRIPTION)
+  alwaysStartsFreshSession: z.boolean().optional().describe(ALWAYS_STARTS_FRESH_SESSION_DESCRIPTION),
+  ...TestCaseTestStateFieldsSchema.shape
 });
 var TestScriptListInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to list test scripts for"),
@@ -7611,6 +7695,32 @@ function mapTestScriptsSummary(response) {
   };
 }
 
+// packages/mcps/src/mcp/tools/e2e/test-state-upstream.ts
+function buildTestChainingCatalogPath(projectId) {
+  return `${MUGGLE_TEST_PREFIX}/projects/${projectId}/test-chaining/catalog`;
+}
+function buildTestStatesPath(projectId) {
+  return `${MUGGLE_TEST_PREFIX}/projects/${projectId}/test-chaining/states`;
+}
+function buildTestRolesPath(projectId) {
+  return `${MUGGLE_TEST_PREFIX}/projects/${projectId}/test-chaining/roles`;
+}
+function buildTestChainingSettingsPath(projectId) {
+  return `${MUGGLE_TEST_PREFIX}/projects/${projectId}/test-chaining/settings`;
+}
+function buildTestChainingPlanPath(projectId) {
+  return `${MUGGLE_TEST_PREFIX}/projects/${projectId}/test-chaining/plan`;
+}
+function pickTestCaseTestStateFields(testStateFields) {
+  const requestFields = {};
+  if (testStateFields.actsAsRoleIds !== void 0) requestFields.actsAsRoleIds = testStateFields.actsAsRoleIds;
+  if (testStateFields.prerequisiteStateId !== void 0) {
+    requestFields.prerequisiteStateId = testStateFields.prerequisiteStateId;
+  }
+  if (testStateFields.resultStateId !== void 0) requestFields.resultStateId = testStateFields.resultStateId;
+  return requestFields;
+}
+
 // packages/mcps/src/mcp/tools/e2e/tool-registry.ts
 var getWorkflowTimeoutMs = () => getConfig().e2e.workflowTimeoutMs;
 var projectTools = [
@@ -8000,7 +8110,7 @@ var testCaseTools = [
   },
   {
     name: "muggle-remote-test-case-create",
-    description: "Create a new test case for a use case.",
+    description: "Create a new test case for a use case. Optionally place it on the project's test states: the roles it acts as (actsAsRoleIds), the state it needs to start (prerequisiteStateId) and the state it leaves when it passes (resultStateId), using ids from muggle-remote-test-chaining-catalog-get.",
     inputSchema: TestCaseCreateInputSchema,
     dashboardLink: linkToInputProjectPage("test-cases" /* TestCases */),
     mapToUpstream: (input) => {
@@ -8025,18 +8135,19 @@ var testCaseTools = [
           ...toolInput.pinnedAccount !== void 0 && { pinnedAccount: toolInput.pinnedAccount },
           ...toolInput.alwaysStartsFreshSession !== void 0 && {
             alwaysStartsFreshSession: toolInput.alwaysStartsFreshSession
-          }
+          },
+          ...pickTestCaseTestStateFields(toolInput)
         }
       };
     }
   },
   {
     name: "muggle-remote-test-case-update",
-    description: "Directly update an existing test case's fields. Pass only the fields you want to change \u2014 others are left untouched. Use this for cheap, deterministic edits (rename, change status/priority, fix expected result, add tags, set or clear the pinned account with pinnedAccount, set whether every run starts from a fresh session with alwaysStartsFreshSession; pinned account and fresh session apply from the next script generation, not to existing scripts). Does not touch the associated test script \u2014 script regeneration is a separate workflow (muggle-remote-workflow-start-test-script-generation).",
+    description: "Directly update an existing test case's fields. Pass only the fields you want to change \u2014 others are left untouched. Use this for cheap, deterministic edits (rename, change status/priority, fix expected result, add tags, set or clear the pinned account with pinnedAccount, set whether every run starts from a fresh session with alwaysStartsFreshSession; pinned account and fresh session apply from the next script generation, not to existing scripts; set the roles it acts as and its prerequisite and result test states with actsAsRoleIds, prerequisiteStateId and resultStateId, null clearing each). Does not touch the associated test script \u2014 script regeneration is a separate workflow (muggle-remote-workflow-start-test-script-generation).",
     inputSchema: TestCaseUpdateInputSchema,
     mapToUpstream: (input) => {
       const toolInput = input;
-      const body = { id: toolInput.testCaseId };
+      const body = { id: toolInput.testCaseId, ...pickTestCaseTestStateFields(toolInput) };
       if (toolInput.title !== void 0) body.title = toolInput.title;
       if (toolInput.description !== void 0) body.description = toolInput.description;
       if (toolInput.goal !== void 0) body.goal = toolInput.goal;
@@ -8085,6 +8196,146 @@ var testCaseTools = [
     }
   }
 ];
+var testStateTools = [
+  {
+    name: "muggle-remote-test-chaining-catalog-get",
+    description: "Get a project's test states and roles. A state is a named set of facts about one account set's data that tests start from and leave, each fact scoped to the account set or account-wide, with a quick read-only check. A role is a kind of account a test acts as, CREATED by Muggle or SUPPLIED by the customer. Also returns freshAccountSetStateId (the state a newly formed account set starts in) and parallelAccountSetLimit; a project with none saved returns an empty catalog. Response shape: { projectId, states: [{ id, name, facts: [{ statement, scope, roleId }], check }], roles: [{ id, name, source, allowsChanges }], freshAccountSetStateId, parallelAccountSetLimit, updatedAt }.",
+    inputSchema: TestChainingCatalogGetInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      return {
+        method: "GET",
+        path: buildTestChainingCatalogPath(toolInput.projectId)
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-chaining-settings-update",
+    description: "Set a project's freshAccountSetStateId (the state a newly formed account set starts in, such as 'New patient'; null clears it) and parallelAccountSetLimit (the most account sets a batch runs at once). Omitted fields stay unchanged. Returns the whole catalog, as muggle-remote-test-chaining-catalog-get does.",
+    inputSchema: TestChainingSettingsUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      const body = {};
+      if (toolInput.freshAccountSetStateId !== void 0) body.freshAccountSetStateId = toolInput.freshAccountSetStateId;
+      if (toolInput.parallelAccountSetLimit !== void 0) body.parallelAccountSetLimit = toolInput.parallelAccountSetLimit;
+      return {
+        method: "PUT",
+        path: buildTestChainingSettingsPath(toolInput.projectId),
+        body
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-state-create",
+    description: "Create a test state: a named set of facts about one account set's data, such as 'Booked' or 'Message unread'. List every fact the state's tests rely on, each scoped to the account set (only this account set's data, e.g. the patient's thread with the doctor) or account-wide (one account as a whole, e.g. the doctor's unread count, naming that account's role). check is a quick read-only check that an account set is in the state. Reuse a matching state from muggle-remote-test-chaining-catalog-get before creating one. Returns the created state.",
+    inputSchema: TestStateCreateInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      const body = { name: toolInput.name };
+      if (toolInput.facts !== void 0) body.facts = toolInput.facts;
+      if (toolInput.check !== void 0) body.check = toolInput.check;
+      return {
+        method: "POST",
+        path: buildTestStatesPath(toolInput.projectId),
+        body
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-state-update",
+    description: "Update a test state's name, facts or check. Omitted fields stay unchanged; facts replaces the state's whole fact list. Returns the updated state.",
+    inputSchema: TestStateUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      const body = {};
+      if (toolInput.name !== void 0) body.name = toolInput.name;
+      if (toolInput.facts !== void 0) body.facts = toolInput.facts;
+      if (toolInput.check !== void 0) body.check = toolInput.check;
+      return {
+        method: "PUT",
+        path: `${buildTestStatesPath(toolInput.projectId)}/${toolInput.stateId}`,
+        body
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-state-delete",
+    description: "Delete a test state. Rejected while a test case uses it as its prerequisite or result state, or while it is the project's freshAccountSetStateId.",
+    inputSchema: TestStateDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      return {
+        method: "DELETE",
+        path: `${buildTestStatesPath(toolInput.projectId)}/${toolInput.stateId}`
+      };
+    },
+    mapFromUpstream: (_response, input) => {
+      const toolInput = input;
+      return { stateId: toolInput.stateId, isDeleted: true };
+    }
+  },
+  {
+    name: "muggle-remote-test-role-create",
+    description: "Create a test role: a kind of account a test acts as, such as Patient or Doctor; two accounts of one kind in one test are two roles. CREATED: Muggle signs each account set's account up itself, and it is disposable. SUPPLIED: the customer provides the account, which is never used up; allowsChanges lets tests change its account-wide facts when a proven way back restores them. Returns the created role.",
+    inputSchema: TestRoleCreateInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      const body = { name: toolInput.name, source: toolInput.source };
+      if (toolInput.allowsChanges !== void 0) body.allowsChanges = toolInput.allowsChanges;
+      return {
+        method: "POST",
+        path: buildTestRolesPath(toolInput.projectId),
+        body
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-role-update",
+    description: "Update a test role's name, source or allowsChanges. Omitted fields stay unchanged. Returns the updated role.",
+    inputSchema: TestRoleUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      const body = {};
+      if (toolInput.name !== void 0) body.name = toolInput.name;
+      if (toolInput.source !== void 0) body.source = toolInput.source;
+      if (toolInput.allowsChanges !== void 0) body.allowsChanges = toolInput.allowsChanges;
+      return {
+        method: "PUT",
+        path: `${buildTestRolesPath(toolInput.projectId)}/${toolInput.roleId}`,
+        body
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-role-delete",
+    description: "Delete a test role. Rejected while a test case acts as it or a state's account-wide fact names it.",
+    inputSchema: TestRoleDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      return {
+        method: "DELETE",
+        path: `${buildTestRolesPath(toolInput.projectId)}/${toolInput.roleId}`
+      };
+    },
+    mapFromUpstream: (_response, input) => {
+      const toolInput = input;
+      return { roleId: toolInput.roleId, isDeleted: true };
+    }
+  },
+  {
+    name: "muggle-remote-test-chaining-plan-get",
+    description: "Preview how the project's test cases would run on account sets. Read-only: it plans from the saved states, roles and test cases and does not run anything. Returns the floor (fewest account sets that can run every placed test), each account set's route in order with setup runs (replays that only reach a state, with no verdict) and the one-way test that forced each account set beyond the first, the groups of states, Not allowed tests that would change a supplied account, tests whose prerequisite state no test reaches, and test cases with no states yet (they run as today). Response shape: { floor, batchLength, totalRuns, setupRuns, account sets: [{ accountSetNumber, slotNumber, steps: [{ testCaseId, prerequisiteStateId, resultStateId, isSetup, heldSuppliedRoleIds }], endStateId, isUsedUp, forcedByTestCaseId }], groups: [{ groupNumber, stateIds, isTerminal }], notAllowed: [{ testCaseId, reason, suppliedRoleIds }], missingState: [{ testCaseId, prerequisiteStateId }], unplacedTestCaseIds, unrestoredSuppliedRoleIds }.",
+    inputSchema: TestChainingPlanGetInputSchema,
+    mapToUpstream: (input) => {
+      const toolInput = input;
+      return {
+        method: "GET",
+        path: buildTestChainingPlanPath(toolInput.projectId),
+        queryParams: { isProduction: toolInput.isProduction }
+      };
+    }
+  }
+];
 var bulkPreviewTools = [
   {
     name: "muggle-remote-bulk-preview-job-get",
@@ -9368,6 +9619,7 @@ var allQaToolDefinitions = [
   ...projectTools,
   ...useCaseTools,
   ...testCaseTools,
+  ...testStateTools,
   ...bulkPreviewTools,
   ...testScriptTools,
   ...actionScriptTools,
@@ -10708,11 +10960,24 @@ __export(e2e_exports2, {
   TestCaseGetInputSchema: () => TestCaseGetInputSchema,
   TestCaseListByUseCaseInputSchema: () => TestCaseListByUseCaseInputSchema,
   TestCaseListInputSchema: () => TestCaseListInputSchema,
+  TestCaseTestStateFieldsSchema: () => TestCaseTestStateFieldsSchema,
   TestCaseUpdateInputSchema: () => TestCaseUpdateInputSchema,
+  TestChainingCatalogGetInputSchema: () => TestChainingCatalogGetInputSchema,
+  TestChainingPlanGetInputSchema: () => TestChainingPlanGetInputSchema,
+  TestChainingSettingsUpdateInputSchema: () => TestChainingSettingsUpdateInputSchema,
   TestPlanGraphRebuildInputSchema: () => TestPlanGraphRebuildInputSchema,
+  TestRoleCreateInputSchema: () => TestRoleCreateInputSchema,
+  TestRoleDeleteInputSchema: () => TestRoleDeleteInputSchema,
+  TestRoleSourceEnum: () => TestRoleSourceEnum,
+  TestRoleUpdateInputSchema: () => TestRoleUpdateInputSchema,
   TestScriptDeleteInputSchema: () => TestScriptDeleteInputSchema,
   TestScriptGetInputSchema: () => TestScriptGetInputSchema,
   TestScriptListInputSchema: () => TestScriptListInputSchema,
+  TestStateCreateInputSchema: () => TestStateCreateInputSchema,
+  TestStateDeleteInputSchema: () => TestStateDeleteInputSchema,
+  TestStateFactSchema: () => TestStateFactSchema,
+  TestStateFactScopeEnum: () => TestStateFactScopeEnum,
+  TestStateUpdateInputSchema: () => TestStateUpdateInputSchema,
   TokenPackageIdSchema: () => TokenPackageIdSchema,
   TokenUsageFilterTypeSchema: () => TokenUsageFilterTypeSchema,
   UseCaseCandidatesApproveInputSchema: () => UseCaseCandidatesApproveInputSchema,

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-J2DEXYH7.js';
-import './chunk-YLQSNSSM.js';
+import { runCli } from './chunk-RQ43IPVN.js';
+import './chunk-XUANXZ2O.js';
 
 // src/cli/main.ts
 runCli().catch((error) => {

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-J2DEXYH7.js';
-export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-YLQSNSSM.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-RQ43IPVN.js';
+export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-XUANXZ2O.js';

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.codex-mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.31.0-staging.269",
+        "@muggleai/works@5.31.0-staging.271",
         "serve"
       ],
       "env": {

package/dist/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "muggle",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
   "author": {
     "name": "Muggle AI",

package/dist/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.31.0-staging.269",
+        "@muggleai/works@5.31.0-staging.271",
         "serve"
       ]
     }

package/dist/release-manifest.json

@@ -1,7 +1,7 @@
 {
   "release": "5.26.0",
-  "buildId": "run-269-1",
-  "commitSha": "74e4ffc37ec51905f9a9a588d4f723d6e890f7db",
-  "buildTime": "2026-10-31T20:55:33Z",
+  "buildId": "run-271-1",
+  "commitSha": "5036fc9c7a6ea65a6269500436e8eb9b6c443413",
+  "buildTime": "2026-11-01T05:29:33Z",
   "serviceName": "muggle-ai-works-mcp"
 }

package/dist/{src-7OY7H63R.js → src-J6AIYTLA.js}

@@ -1 +1 @@
-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, 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, StackCheckVerdict, StackClaimVerdict, StackLeaseEndReason, StackMismatchKind, StackPortAction, WATCHER_LIFETIME_SECONDS, WATCHER_LIFETIME_UNBOUNDED_SECONDS, 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_exports as e2e, evaluateCheckoutFreshness, findVacatedNeeds, finishStackRun, formatPreferencesOneLiner, getActiveElectronAppReleaseStream, getActiveRuntimeTarget, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDashboardBaseUrl, getDataDir2 as getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppReleaseTagPrefix, getElectronAppSignedFromVersion, getElectronAppVersion, getElectronAppVersionSource, getLlmSourceOption, getLocalQaTools, getLogger, getOnboardingToggleKeys, getPlatformKey, getQaTools, getReleaseSignerIdentityUri, getRunSessionsDir, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, isElectronAppPlatform, isFirstRun, isValidLocalBaseUrl, loadApiKeyData, loadCredentials, local_exports as localQa, lookUpCheckoutPullRequest, markOnboardingCompleted, maskLlmApiKey, mcp_exports as mcp, needsConflict, needsOnboarding, openBrowserUrl, parseElectronAppDirName, performLogin, performLogout, pollDeviceCode, portOfUrl, e2e_exports as qa, 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, startDeviceCodeFlow, startStackRun, stopVacatedServices, toDisplayRef, toolRequiresAuth, validatePreference, verifyFileChecksum, writeLlmEnvBlock, writePreferences, writePreferencesWithMetadata, writeRunViewHtml } from './chunk-YLQSNSSM.js';
+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, 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, StackCheckVerdict, StackClaimVerdict, StackLeaseEndReason, StackMismatchKind, StackPortAction, WATCHER_LIFETIME_SECONDS, WATCHER_LIFETIME_UNBOUNDED_SECONDS, 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_exports as e2e, evaluateCheckoutFreshness, findVacatedNeeds, finishStackRun, formatPreferencesOneLiner, getActiveElectronAppReleaseStream, getActiveRuntimeTarget, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDashboardBaseUrl, getDataDir2 as getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppReleaseTagPrefix, getElectronAppSignedFromVersion, getElectronAppVersion, getElectronAppVersionSource, getLlmSourceOption, getLocalQaTools, getLogger, getOnboardingToggleKeys, getPlatformKey, getQaTools, getReleaseSignerIdentityUri, getRunSessionsDir, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, isElectronAppPlatform, isFirstRun, isValidLocalBaseUrl, loadApiKeyData, loadCredentials, local_exports as localQa, lookUpCheckoutPullRequest, markOnboardingCompleted, maskLlmApiKey, mcp_exports as mcp, needsConflict, needsOnboarding, openBrowserUrl, parseElectronAppDirName, performLogin, performLogout, pollDeviceCode, portOfUrl, e2e_exports as qa, 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, startDeviceCodeFlow, startStackRun, stopVacatedServices, toDisplayRef, toolRequiresAuth, validatePreference, verifyFileChecksum, writeLlmEnvBlock, writePreferences, writePreferencesWithMetadata, writeRunViewHtml } from './chunk-XUANXZ2O.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@muggleai/works",
   "mcpName": "io.github.multiplex-ai/muggle",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "description": "13 years of Microsoft hyperscale engineering, packaged as a harness for your AI coding agent.",
   "type": "module",
   "main": "dist/index.js",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/plugin/.codex-mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.31.0-staging.269",
+        "@muggleai/works@5.31.0-staging.271",
         "serve"
       ],
       "env": {

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "muggle",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
   "author": {
     "name": "Muggle AI",

package/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.31.0-staging.269",
+  "version": "5.31.0-staging.271",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/plugin/.mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.31.0-staging.269",
+        "@muggleai/works@5.31.0-staging.271",
         "serve"
       ]
     }

package/scripts/muggle-watch/README.md

@@ -4,10 +4,11 @@ A standing per-user scheduled job that runs `muggle watch tick` every few minute
 
 - **Tracks** active Claude Code sessions (`claude agents --json`) and Codex sessions (recent `~/.codex/sessions` rollouts). It also tracks their processes: claude, codex, muggle MCP servers, and PR watch loops. Each live Claude session is stamped with when it last loaded its plugins (its process start, or its newest muggle MCP server start after a `/reload-plugins`) and the muggle works build installed then, read off `~/.muggle-ai/postinstall.log`.
 - **Checks every open PR-watch slot** under `~/.muggle-ai/muggle-do/sessions/`. Is its loop running, and heard by a live session? Is CI red? Is the branch behind or conflicting? Are review threads unresolved?
-- **Keeps registered watchers running.** A slot carrying `watch-registration.json` (written by `pr-watch-arm.sh` on every arm) has its owner session resumed in the background when its loop is gone and the owner is down, or idle in the background (stopped first, once a throwaway launch confirms Claude will resume it there). A resume that only hit the usage limit is retried without counting against the per-owner cap. The resumed session's `/muggle:muggle-pr-followup reconcile` re-arms it with that session's own context. The service never addresses a review, pushes, or kills a process.
+- **Keeps registered watchers running.** A slot carrying `watch-registration.json` (written by `pr-watch-arm.sh` on every arm) whose loop is dead or unheard gets a loop the service starts itself, as a program outside every session. When that loop reports new activity or the PR ending, the owner session is woken with `/muggle:muggle-pr-followup <slug> <n> --wake=<event|terminal>` for that one PR, but only between its turns. The service never addresses a review, pushes, or pushes anything else into a session.
 - **Closes out finished slots.** A slot whose PR GitHub reports merged or closed, with no loop and no running owner, is finalized the way a watcher's terminal tick would: `prs.json` takes the state, `followup.log` the terminal line, and `result.md` is written. Only local files change; post-merge cleanup is left to a session and recorded as not run.
-- **Keeps sessions on the installed build.** A session loaded before the newest global install (or a later user-scope update of the muggle plugin) is behind; other plugins updating restart nothing. Idle background sessions are restarted onto the new build, up to 3 per tick: a session that owns open PR watches is stopped and resumed on `/muggle:muggle-pr-followup reconcile`, so its watchers come back with it; any other is respawned. A resume waits for the stopped process to exit and passes no flag beyond `--bg`, so the session continues under its own id and name. Resuming a session that is still running, or adding flags, starts a copy that the agent view lists beside the original. Before either, a throwaway background launch in the session's workspace confirms Claude will bring it back; a workspace that refuses is left running and named once. Busy or waiting sessions wait for a later tick, and terminal sessions get one notification to run `/reload-plugins`. No interface runs a slash command inside another session.
-- **Records and alerts.** Results go to `status.json` (last snapshot, with open-PR coverage per repo), `state.json` (active findings, recovery attempts, reload progress) and `events.jsonl` (raise/clear/resume/respawn/close-out history) under `~/.muggle-ai/watch/`. New alerts raise one desktop notification per tick.
+- **Keeps sessions on the installed build.** A session loaded before the newest global install (or a later user-scope update of the muggle plugin) is behind; other plugins updating restart nothing. Idle background sessions are respawned onto the new build, up to 3 per tick, keeping their own id and name. A session that owns open PR watches is left running. Before a restart, a throwaway background launch in the session's workspace confirms Claude will bring it back; a workspace that refuses is left running and named once. Busy or waiting sessions wait for a later tick, and terminal sessions get one notification to run `/reload-plugins`. No interface runs a slash command inside another session.
+- **Keeps sessions on Remote Control.** With `remoteControlAtStartup` on in Claude's settings, a live background session is off when its `~/.claude/sessions/<pid>.json` entry has no Remote Control link, or its process started before the current claude.ai login took effect, so its link serves another account. Such a session is respawned once its turn is over (registry status `idle` or `shell`), sharing the 3-per-tick cap with the reload. That keeps the same session id, so there is no duplicate in the agent view, and nothing is typed into it. Background commands carry over to the restarted process, PR watch loops included, so they keep reporting to that session. Each restart opens a new Remote Control session, so a session already on is never restarted. A restarted session gets 30 minutes to link, and one still off after 2 restarts in a day is left alone. Terminal sessions that are off are listed for `/remote-control`.
+- **Records and alerts.** Results go to `status.json` (last snapshot, with open-PR and Remote Control coverage), `state.json` (active findings, recovery attempts, reload progress, the login last seen, Remote Control restarts) and `events.jsonl` (raise/clear/resume/respawn/close-out history) under `~/.muggle-ai/watch/`. New alerts raise one desktop notification per tick.
 
 ## Install
 
@@ -43,6 +44,7 @@ On Windows the PowerShell installer also takes flags directly:
 | `-IntervalMinutes <n>` | Tick interval, default 2 |
 | `-NoRecovery` | Report dead watchers without resuming their owners |
 | `-NoAutoReload` | Never restart sessions onto a new build |
+| `-NoRemoteControl` | Report sessions off Remote Control without restarting them |
 | `-NoWait` | Return once the task is registered, before its first tick |
 | `-MuggleEntry <path>` | Run a specific `bin\muggle.js` instead of the global install |
 | `-Uninstall` | Remove the task; the ledger is kept |

package/scripts/muggle-watch/install-muggle-watch.ps1

@@ -1,8 +1,9 @@
 # Installs the MuggleWatch scheduled task for the current user (no elevation):
 # every -IntervalMinutes it runs `muggle watch tick`, which snapshots Claude and
 # Codex sessions, their processes and every PR-watch slot, alerts on dead or deaf
-# watchers, red CI and stale branches, resumes the owner session of a registered
-# slot whose watcher died, and fans plugin reloads out across sessions.
+# watchers, red CI and stale branches, restarts the loop of a registered slot
+# whose watcher died, fans plugin reloads out across sessions, and restarts
+# sessions that are off Remote Control under the current login.
 #
 # The task runs the global @muggleai/works install, whose path survives
 # `muggle upgrade`, so the service always runs the current release. Only the
@@ -20,6 +21,7 @@ param(
     [string]$MuggleEntry,
     [switch]$NoAutoReload,
     [switch]$NoRecovery,
+    [switch]$NoRemoteControl,
     # Return once the task is registered; its trigger runs the first tick a minute later.
     [switch]$NoWait,
     [switch]$Uninstall
@@ -61,6 +63,7 @@ Copy-Item (Join-Path $PSScriptRoot "muggle-watch-hidden.vbs") $installedLauncher
 $tickFlags = @()
 if ($NoAutoReload) { $tickFlags += "--no-auto-reload" }
 if ($NoRecovery) { $tickFlags += "--no-recovery" }
+if ($NoRemoteControl) { $tickFlags += "--no-remote-control" }
 $launcherArguments = @("`"$installedLauncher`"", "`"$($nodeCommand.Source)`"", "`"$MuggleEntry`"") + $tickFlags
 
 # wscript.exe rather than node.exe is what keeps every run off the desktop; see