@muggleai/works 5.11.1 → 5.12.0-staging.74

package/dist/plugin/scripts/guardrails.mjs

@@ -1,10 +1,116 @@
-import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync, readdirSync, openSync, writeSync, closeSync, unlinkSync } from 'fs';
 import { join, isAbsolute, resolve, dirname } from 'path';
-import { homedir } from 'os';
+import { homedir, hostname } from 'os';
 import { fileURLToPath } from 'url';
 import { execFileSync } from 'child_process';
 
 // src/guardrails/cli.ts
+
+// src/guardrails/constants.ts
+var GH_PR_MERGED_LINE = /\b(?:Merged|Squashed and merged|Rebased and merged) pull request [\w./-]*#(\d+)/;
+var GH_PR_CLOSED_LINE = /\bClosed pull request [\w./-]*#(\d+)/;
+var GH_PR_REOPENED_LINE = /\bReopened pull request [\w./-]*#(\d+)/;
+var PR_MONITOR_TERMINAL_LINE = /\bTERMINAL pr=(\d+): (MERGED|CLOSED)\b/;
+var MAX_PR_TERMINAL_BLOCKS = 3;
+var MAX_WATCH_BLOCKS = 3;
+var MAX_WALKTHROUGH_BLOCKS = 3;
+var GH_LOOKUP_TIMEOUT_MS = 1e4;
+var MUGGLE_SKILL_EMIT_TOOL = /muggle-local-telemetry-skill-emit/i;
+var MUGGLE_TEST_SKILL_NAME = "muggle-test";
+var MANDATORY_STAGES_FRONTMATTER_KEY = "mandatoryStages";
+var SKILL_NAME_INPUT_KEYS = ["skill", "skillName", "name", "command"];
+var MAX_STAGE_BLOCKS = 3;
+var MAX_DEBUG_BLOCKS = 3;
+var ANY_TEST_CASE = "*";
+var MUGGLE_EXECUTION_TOOL = /muggle-local-(execute-test-generation|execute-replay)/i;
+var MUGGLE_EVENT_EMIT_TOOL = /muggle-local-telemetry-event-emit/i;
+var MUGGLE_FEEDBACK_CREATE_TOOL = /muggle-remote-user-feedback-create/i;
+var PRE_EXECUTION_CLASSIFICATION_EVENT = "pre-execution-classification";
+var FAILURE_DIAGNOSIS_EVENT = /-failure-(classified|resolved)$/;
+var MUGGLE_RUN_ID_LINE = /\*\*Run ID:\*\*\s*([^\s*]+)/;
+var MUGGLE_RUN_STATUS_LINE = /\*\*Status:\*\*\s*([A-Za-z_]+)/;
+var MUGGLE_RUN_PASSED_STATUS = "passed";
+var GITHUB_RESOLVE_THREAD_MUTATION = /\bresolveReviewThread\b/;
+var GITLAB_RESOLVE_DISCUSSION_CALL = /discussions\/[^\s"']*[?&]resolved=true/i;
+var PROVIDER_API_INVOCATION = /\b(?:gh|glab)\s+api\b/;
+var LOOP_REPLY_MARKER = "<!-- muggle-do:bot -->";
+var REVIEW_THREAD_FETCH_COMMAND = /reviewThreads|merge_requests\/\d+\/discussions/;
+var THREADED_REPLY_TARGET = /pulls\/\d+\/comments\/(\d+)\/replies|discussions\/([\w-]+)\/notes/g;
+var MAX_REPLY_BLOCKS = 3;
+var CAPABILITY_CLAIM_TRANSCRIPT_TAIL_BYTES = 64e3;
+var SESSION_STATE_LOCK_WAIT_MS = 250;
+var LOCK_POLL_INTERVAL_MS = 10;
+var CALL_FAILURE_SIGNALS = [
+  /\bgh:\s/,
+  /\bglab:\s/,
+  /\bHTTP\s(?:4|5)\d\d\b/,
+  /"status"\s*:\s*"?(?:4|5)\d\d/,
+  /"isError"\s*:\s*true/
+];
+var FORGE_TERMINAL_CMD = /\b(?:gh\s+pr\s+(?:merge|close|reopen)|glab\s+mr\s+(?:merge|close|reopen))\b/;
+
+// src/guardrails/store/fileLock.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function recordedHolder(lockPath) {
+  try {
+    return JSON.parse(readFileSync(lockPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function breakLockIfHolderIsDead(lockPath) {
+  const holder = recordedHolder(lockPath);
+  if (!holder) return;
+  if (holder.host !== hostname() || isProcessAlive(holder.pid)) return;
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    return;
+  }
+}
+function pauseBetweenAttempts() {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_POLL_INTERVAL_MS);
+}
+function withFileLock(lockPath, waitMs, run) {
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    let lockFileDescriptor;
+    try {
+      lockFileDescriptor = openSync(lockPath, "wx");
+      writeSync(
+        lockFileDescriptor,
+        JSON.stringify({
+          pid: process.pid,
+          host: hostname(),
+          acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    } catch {
+      breakLockIfHolderIsDead(lockPath);
+      if (Date.now() >= deadline) return void 0;
+      pauseBetweenAttempts();
+      continue;
+    }
+    try {
+      return run();
+    } finally {
+      closeSync(lockFileDescriptor);
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/guardrails/sessionState.ts
 var baseDir = (override) => override ?? join(homedir(), ".muggle-ai", "guardrails");
 var fileFor = (sessionId2, override) => join(baseDir(override), `${sessionId2.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
 function readState(sessionId2, dirOverride) {
@@ -19,7 +125,25 @@ function readState(sessionId2, dirOverride) {
 }
 function writeState(state, dirOverride) {
   mkdirSync(baseDir(dirOverride), { recursive: true });
-  writeFileSync(fileFor(state.sessionId, dirOverride), JSON.stringify(state, null, 2));
+  const target = fileFor(state.sessionId, dirOverride);
+  const staging = `${target}.${process.pid}.tmp`;
+  writeFileSync(staging, JSON.stringify(state, null, 2));
+  renameSync(staging, target);
+}
+function updateState(sessionId2, mutate, dirOverride) {
+  mkdirSync(baseDir(dirOverride), { recursive: true });
+  const committed = withFileLock(
+    `${fileFor(sessionId2, dirOverride)}.lock`,
+    SESSION_STATE_LOCK_WAIT_MS,
+    () => {
+      const current = readState(sessionId2, dirOverride);
+      const next = mutate(current);
+      if (next === current) return true;
+      writeState({ ...next, generation: (current.generation ?? 0) + 1 }, dirOverride);
+      return true;
+    }
+  );
+  return committed === true;
 }
 function markPrHandled(sessionId2, prUrl, dirOverride) {
   const state = readState(sessionId2, dirOverride);
@@ -42,41 +166,22 @@ ${input2.tool_response?.output ?? ""}`;
   return m ? m[0] : null;
 }
 
-// src/guardrails/constants.ts
-var GH_PR_MERGED_LINE = /\b(?:Merged|Squashed and merged|Rebased and merged) pull request [\w./-]*#(\d+)/;
-var GH_PR_CLOSED_LINE = /\bClosed pull request [\w./-]*#(\d+)/;
-var GH_PR_REOPENED_LINE = /\bReopened pull request [\w./-]*#(\d+)/;
-var PR_MONITOR_TERMINAL_LINE = /\bTERMINAL pr=(\d+): (MERGED|CLOSED)\b/;
-var MAX_PR_TERMINAL_BLOCKS = 3;
-var MAX_WATCH_BLOCKS = 3;
-var MAX_WALKTHROUGH_BLOCKS = 3;
-var GH_LOOKUP_TIMEOUT_MS = 1e4;
-var MUGGLE_SKILL_EMIT_TOOL = /muggle-local-telemetry-skill-emit/i;
-var MUGGLE_TEST_SKILL_NAME = "muggle-test";
-var MANDATORY_STAGES_FRONTMATTER_KEY = "mandatoryStages";
-var SKILL_NAME_INPUT_KEYS = ["skill", "skillName", "name", "command"];
-var MAX_STAGE_BLOCKS = 3;
-var MAX_DEBUG_BLOCKS = 3;
-var ANY_TEST_CASE = "*";
-var MUGGLE_EXECUTION_TOOL = /muggle-local-(execute-test-generation|execute-replay)/i;
-var MUGGLE_EVENT_EMIT_TOOL = /muggle-local-telemetry-event-emit/i;
-var MUGGLE_FEEDBACK_CREATE_TOOL = /muggle-remote-user-feedback-create/i;
-var PRE_EXECUTION_CLASSIFICATION_EVENT = "pre-execution-classification";
-var FAILURE_DIAGNOSIS_EVENT = /-failure-(classified|resolved)$/;
-var MUGGLE_RUN_ID_LINE = /\*\*Run ID:\*\*\s*([^\s*]+)/;
-var MUGGLE_RUN_STATUS_LINE = /\*\*Status:\*\*\s*([A-Za-z_]+)/;
-var MUGGLE_RUN_PASSED_STATUS = "passed";
-
 // src/guardrails/prTerminal.ts
+function terminalProvenance(input2) {
+  const command = input2.tool_input?.command;
+  if (command === void 0) return { acceptsForgeLine: true };
+  return { acceptsForgeLine: FORGE_TERMINAL_CMD.test(command) };
+}
 function detectPrTerminal(input2) {
   if (input2.tool_name !== "Bash" && input2.tool_name !== "Monitor") return null;
   const response = input2.tool_response;
+  const provenance = terminalProvenance(input2);
   const haystack = [response?.stdout, response?.stderr, response?.output, response?.content].filter((part) => typeof part === "string").join("\n");
-  const mergedMatch = haystack.match(GH_PR_MERGED_LINE);
+  const mergedMatch = provenance.acceptsForgeLine ? haystack.match(GH_PR_MERGED_LINE) : null;
   if (mergedMatch) {
     return { prNumber: Number(mergedMatch[1]), verdict: "merged" /* Merged */ };
   }
-  const closedMatch = haystack.match(GH_PR_CLOSED_LINE);
+  const closedMatch = provenance.acceptsForgeLine ? haystack.match(GH_PR_CLOSED_LINE) : null;
   if (closedMatch) {
     return { prNumber: Number(closedMatch[1]), verdict: "closed" /* Closed */ };
   }
@@ -91,6 +196,7 @@ function detectPrTerminal(input2) {
 }
 function detectPrReopened(input2) {
   if (input2.tool_name !== "Bash") return null;
+  if (!terminalProvenance(input2).acceptsForgeLine) return null;
   const response = input2.tool_response;
   const haystack = [response?.stdout, response?.stderr, response?.output, response?.content].filter((part) => typeof part === "string").join("\n");
   const reopenedMatch = haystack.match(GH_PR_REOPENED_LINE);
@@ -132,6 +238,39 @@ function prTerminalGateDecision(state, maxBlocks = MAX_PR_TERMINAL_BLOCKS) {
   }
   return { action: "block" /* Block */, blockCount: blockCount + 1 };
 }
+
+// src/guardrails/capabilityClaim.ts
+var SENTENCE = /[^.!?\n]+/g;
+var IMPOSSIBILITY = /\b(?:can(?:'|’)?t|cannot|can not|could ?n(?:'|’)?t|unable to|no way to|not able to|impossible|infeasible|untestable|unverifiable|not testable|blocked from|no (?:local )?(?:mail|email|smtp) path)\b/i;
+var MUGGLE_CLEARS = /\b(?:magic[- ]?link|sign[- ]?in link|login link|email link|one[- ]time (?:code|password)|otp|verification (?:code|link|email|mail)|email verification|confirmation (?:code|link|email|mail)|2fa|two[- ]factor|password reset|reset link|inbox|mailbox|mailhog|mailpit|mailtrap|mailcatcher|smtp|transactional email|captcha|recaptcha|hcaptcha|log ?in|logged[- ]?in|sign ?in|signed[- ]in|authenticate|credential)/i;
+var TESTING_CONTEXT = /\b(?:e2e|end[- ]to[- ]end|test(?:s|ed|ing|able)?|verif(?:y|ied|ication)|validat(?:e|ed|ion)|automat(?:e|ed|ion)|coverage|covered|exercis(?:e|ed)|reproduc(?:e|ed)|replay|scripts?|scripted|muggle|playwright|cypress|selenium)\b/i;
+var GENUINELY_UNSUPPORTED = /\b(?:sms|text message|phone (?:number|call)|authenticator app|google authenticator|authy|totp)\b/i;
+function detectFalseCapabilityClaim(text) {
+  const sentences = (text ?? "").match(SENTENCE) ?? [];
+  return sentences.some(
+    (sentence) => IMPOSSIBILITY.test(sentence) && MUGGLE_CLEARS.test(sentence) && TESTING_CONTEXT.test(sentence) && !GENUINELY_UNSUPPORTED.test(sentence)
+  );
+}
+function lastAssistantText(transcriptJsonl) {
+  const lines = (transcriptJsonl ?? "").split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim();
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant") continue;
+    const content = entry.message?.content;
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) continue;
+    const prose = content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+    if (prose) return prose;
+  }
+  return "";
+}
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
 var SEQUENCE_ENTRY = /^\s*-\s*(.+?)\s*$/;
 var FLOW_LIST = /^\s*\[(.*)\]\s*$/;
@@ -238,11 +377,28 @@ function stageGateDecision(state, unreadStagePaths, maxBlocks = MAX_STAGE_BLOCKS
   return { action: "block" /* Block */, blockCount: blockCount + 1, unread: unreadStagePaths };
 }
 
+// src/guardrails/callOutcome.ts
+function renderedResponse(toolResponse) {
+  const rendered = [];
+  const collect = (value) => {
+    if (typeof value === "string") rendered.push(value);
+    else if (Array.isArray(value)) value.forEach(collect);
+    else if (value && typeof value === "object") Object.values(value).forEach(collect);
+  };
+  collect(toolResponse);
+  return rendered.join("\n");
+}
+function callFailed(input2) {
+  const rendered = renderedResponse(input2.tool_response);
+  return CALL_FAILURE_SIGNALS.some((signal) => signal.test(rendered));
+}
+
 // src/guardrails/preExecutionClassification.ts
 var CLASSIFICATION_SKIP_MARKER = /^\s*echo\s+["']?MUGGLE_CLASSIFY_SKIP\b/;
 function detectClassifiedTestCaseId(input2) {
   if (!MUGGLE_EVENT_EMIT_TOOL.test(input2.tool_name ?? "")) return void 0;
   if (input2.tool_input?.eventType !== PRE_EXECUTION_CLASSIFICATION_EVENT) return void 0;
+  if (callFailed(input2)) return void 0;
   return input2.tool_input?.testCaseId ?? ANY_TEST_CASE;
 }
 function applyClassifiedTestCase(state, testCaseId) {
@@ -299,6 +455,7 @@ function detectDebugEvidenceRunIds(input2, owedRunIds) {
   const toolName = input2.tool_name ?? "";
   const isDiagnosisEmit = MUGGLE_EVENT_EMIT_TOOL.test(toolName) && FAILURE_DIAGNOSIS_EVENT.test(input2.tool_input?.eventType ?? "");
   if (!isDiagnosisEmit && !MUGGLE_FEEDBACK_CREATE_TOOL.test(toolName)) return [];
+  if (callFailed(input2)) return [];
   const payload = serialize(input2);
   return owedRunIds.filter((runId) => payload.includes(runId));
 }
@@ -474,6 +631,7 @@ function detectWalkthroughPost(input2, read = defaultFileReader) {
   if (input2.tool_name !== "Bash") return false;
   const cmd = input2.tool_input?.command ?? "";
   if (!isPrReportPostCommand(cmd)) return false;
+  if (callFailed(input2)) return false;
   return collectPrPostText(cmd, input2.cwd, read).includes(REPORT_SENTINEL);
 }
 function applyWalkthroughPosted(state, posted) {
@@ -533,6 +691,245 @@ function walkthroughGateDecision(state, owedPrUrls, maxBlocks = MAX_WALKTHROUGH_
   return { action: "block" /* Block */, blockCount: blockCount + 1, owed: owedPrUrls };
 }
 
+// src/guardrails/ledger/constants.ts
+var LEDGER_FILE_NAME = "comment-ledger.json";
+var LEDGER_VERSION = 1;
+var LEDGER_LOCK_WAIT_MS = 3e4;
+var LEDGER_COMMIT_ATTEMPTS = 5;
+var FOREIGN_CLAIM_EXPIRY_MS = 6 * 60 * 60 * 1e3;
+
+// src/guardrails/ledger/store.ts
+var ledgerPath = (slotPath) => join(slotPath, LEDGER_FILE_NAME);
+function newThreadEntry(provider) {
+  return {
+    provider,
+    generation: 0,
+    humanCommentIds: [],
+    coveredCommentIds: [],
+    claim: null,
+    lastClaimedBySessionId: null,
+    lastReplySha: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function readLedger(slotPath) {
+  const path = ledgerPath(slotPath);
+  if (!existsSync(path)) return { version: LEDGER_VERSION, threads: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return { version: parsed.version ?? LEDGER_VERSION, threads: parsed.threads ?? {} };
+  } catch {
+    return { version: LEDGER_VERSION, threads: {} };
+  }
+}
+function writeLedger(slotPath, ledger) {
+  const target = ledgerPath(slotPath);
+  const staging = `${target}.${process.pid}.tmp`;
+  writeFileSync(staging, JSON.stringify(ledger, null, 2));
+  renameSync(staging, target);
+}
+function commitThread(slotPath, threadId, mutate) {
+  mkdirSync(slotPath, { recursive: true });
+  for (let attempt = 0; attempt < LEDGER_COMMIT_ATTEMPTS; attempt += 1) {
+    const committed = withFileLock(`${ledgerPath(slotPath)}.lock`, LEDGER_LOCK_WAIT_MS, () => {
+      const ledger = readLedger(slotPath);
+      const current = ledger.threads[threadId] ?? newThreadEntry("github" /* GitHub */);
+      const next = mutate(current);
+      ledger.threads[threadId] = {
+        ...next,
+        generation: current.generation + 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      writeLedger(slotPath, ledger);
+      return true;
+    });
+    if (committed === true) return true;
+  }
+  return false;
+}
+function isClaimLive(claim, now = Date.now()) {
+  if (!claim) return false;
+  if (claim.host !== hostname()) {
+    return now - Date.parse(claim.claimedAt) < FOREIGN_CLAIM_EXPIRY_MS;
+  }
+  return isProcessAlive(claim.pid);
+}
+function uncoveredComments(entry) {
+  const covered = new Set(entry.coveredCommentIds);
+  return entry.humanCommentIds.filter((commentId) => !covered.has(commentId));
+}
+function threadState(entry, now = Date.now()) {
+  if (uncoveredComments(entry).length === 0) return "processed" /* Processed */;
+  if (isClaimLive(entry.claim, now)) return "processing" /* Processing */;
+  return "unprocessed" /* Unprocessed */;
+}
+function claimThread(entry, sessionId2) {
+  return {
+    ...entry,
+    claim: {
+      sessionId: sessionId2,
+      pid: process.pid,
+      host: hostname(),
+      claimedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    lastClaimedBySessionId: sessionId2
+  };
+}
+function coverComments(entry, commentIds, replySha) {
+  const covered = [...entry.coveredCommentIds];
+  for (const commentId of commentIds) if (!covered.includes(commentId)) covered.push(commentId);
+  return { ...entry, coveredCommentIds: covered, lastReplySha: replySha ?? entry.lastReplySha };
+}
+function refreshHumanComments(entry, humanCommentIds) {
+  return { ...entry, humanCommentIds: [...humanCommentIds] };
+}
+
+// src/guardrails/commentReply.ts
+var REPLY_SKIP_MARKER = /^\s*echo\s+["']?MUGGLE_REPLY_SKIP\b/;
+var REPLY_SHA_CITATION = /Addressed in ([0-9a-f]{7,40})/;
+function parsedResponse(input2) {
+  for (const rendered of [input2.tool_response?.stdout, input2.tool_response?.output]) {
+    if (!rendered) continue;
+    try {
+      return JSON.parse(rendered);
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function collectThreads(value, found) {
+  if (Array.isArray(value)) {
+    value.forEach((entry) => collectThreads(entry, found));
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  const thread = value;
+  if (Array.isArray(thread.comments?.nodes) || Array.isArray(thread.notes)) {
+    found.push(thread);
+    return;
+  }
+  Object.values(value).forEach((nested) => collectThreads(nested, found));
+}
+var commentTimestamp = (comment) => comment.createdAt ?? comment.created_at ?? "";
+function inChronologicalOrder(comments) {
+  if (comments.some((comment) => commentTimestamp(comment) === "")) return comments;
+  return [...comments].sort(
+    (earlier, later) => commentTimestamp(earlier).localeCompare(commentTimestamp(later))
+  );
+}
+var isLoopAuthored = (comment) => (comment.body ?? "").includes(LOOP_REPLY_MARKER);
+function commentsAwaitingReply(comments) {
+  const ordered = inChronologicalOrder(comments);
+  let lastLoopIndex = -1;
+  ordered.forEach((comment, index) => {
+    if (isLoopAuthored(comment)) lastLoopIndex = index;
+  });
+  return ordered.slice(lastLoopIndex + 1).filter((comment) => !isLoopAuthored(comment));
+}
+function githubThread(thread) {
+  if (thread.isResolved === true || !thread.id) return void 0;
+  const awaiting = commentsAwaitingReply(thread.comments?.nodes ?? []);
+  const humanCommentIds = awaiting.map((comment) => comment.databaseId).filter((databaseId) => databaseId !== void 0).map(String);
+  if (humanCommentIds.length === 0) return void 0;
+  return {
+    threadId: thread.id,
+    provider: "github" /* GitHub */,
+    humanCommentIds
+  };
+}
+function gitlabThread(thread) {
+  const notes = thread.notes ?? [];
+  if (!notes.some((note) => note.resolved === false) || !thread.id) return void 0;
+  const humanCommentIds = commentsAwaitingReply(notes).map((note) => note.id).filter((noteId) => noteId !== void 0).map(String);
+  if (humanCommentIds.length === 0) return void 0;
+  return {
+    threadId: thread.id,
+    provider: "gitlab" /* GitLab */,
+    humanCommentIds
+  };
+}
+function detectUnansweredThreads(input2) {
+  if (input2.tool_name !== "Bash") return [];
+  if (!REVIEW_THREAD_FETCH_COMMAND.test(input2.tool_input?.command ?? "")) return [];
+  const threads = [];
+  collectThreads(parsedResponse(input2), threads);
+  return threads.map((thread) => Array.isArray(thread.notes) ? gitlabThread(thread) : githubThread(thread)).filter((thread) => thread !== void 0);
+}
+function detectConfirmedReplies(input2) {
+  if (input2.tool_name !== "Bash") return [];
+  const command = input2.tool_input?.command ?? "";
+  const targets = [...command.matchAll(THREADED_REPLY_TARGET)].map(
+    ([, githubCommentId, gitlabDiscussionId]) => githubCommentId ?? gitlabDiscussionId
+  );
+  if (targets.length === 0) return [];
+  const created = parsedResponse(input2);
+  if (created?.id === void 0) return [];
+  const replySha = REPLY_SHA_CITATION.exec(created.body ?? "")?.[1] ?? null;
+  return targets.map((targetId) => ({ targetId, replySha }));
+}
+function isReplySkipMarker(command) {
+  return REPLY_SKIP_MARKER.test(command);
+}
+function threadForReplyTarget(ledger, targetId) {
+  if (ledger.threads[targetId]) return targetId;
+  for (const [threadId, entry] of Object.entries(ledger.threads)) {
+    if (entry.humanCommentIds.includes(targetId)) return threadId;
+  }
+  return void 0;
+}
+function resolveSlotForPr(prUrl, sessionsDirOverride) {
+  const sessionsDir = join(homedir(), ".muggle-ai", "muggle-do", "sessions");
+  if (!existsSync(sessionsDir)) return void 0;
+  for (const slug of readdirSync(sessionsDir)) {
+    const slotPath = join(sessionsDir, slug);
+    try {
+      const parsed = JSON.parse(readFileSync(join(slotPath, "prs.json"), "utf-8"));
+      const slotPr = Array.isArray(parsed) ? parsed[0] : parsed;
+      if (slotPr?.url === prUrl) return slotPath;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function overdueThreads(slotPath, sessionId2) {
+  const overdue = [];
+  for (const [threadId, entry] of Object.entries(readLedger(slotPath).threads)) {
+    if (entry.lastClaimedBySessionId !== sessionId2) continue;
+    if (threadState(entry) === "processed" /* Processed */) continue;
+    overdue.push({ threadId, uncovered: uncoveredComments(entry) });
+  }
+  return overdue;
+}
+function commentReplyGateDecision(state, overdue, maxBlocks = MAX_REPLY_BLOCKS) {
+  const blockCount = state.commentReplyBlockCount ?? 0;
+  const unanswered = overdue.flatMap((thread) => thread.uncovered);
+  if (state.commentReplySkipped === true || unanswered.length === 0) {
+    return { action: "none" /* None */, blockCount, unanswered };
+  }
+  if (blockCount >= maxBlocks) {
+    return {
+      action: "release" /* Release */,
+      blockCount,
+      unanswered
+    };
+  }
+  return {
+    action: "block" /* Block */,
+    blockCount: blockCount + 1,
+    unanswered
+  };
+}
+function deferredCommentIds(ledger, command) {
+  const deferred = [];
+  for (const [threadId, entry] of Object.entries(ledger.threads)) {
+    const named = uncoveredComments(entry).filter((commentId) => command.includes(commentId));
+    if (named.length > 0) deferred.push({ threadId, commentIds: named });
+  }
+  return deferred;
+}
+
 // src/guardrails/detectBuildIntent.ts
 var BUILD = /\b(implement|build|add|create|write|fix|refactor|wire up|hook up|make (a|the|it)|change the)\b/i;
 var DEVCYCLE = /\bresolve\b[^.?!]{0,40}\bconflicts?\b|\bget\b[^.?!]{0,40}\bpr\b[^.?!]{0,40}\b(green|merged?|passing)\b/i;
@@ -567,6 +964,21 @@ function evaluateReportPost(input2, read = defaultFileReader) {
   };
 }
 
+// src/guardrails/reviewThreadResolve.ts
+function detectResolveCall(command) {
+  if (!PROVIDER_API_INVOCATION.test(command)) return null;
+  if (GITHUB_RESOLVE_THREAD_MUTATION.test(command)) return "github" /* GitHub */;
+  if (GITLAB_RESOLVE_DISCUSSION_CALL.test(command)) return "gitlab" /* GitLab */;
+  return null;
+}
+var RESOLVE_DENIAL = "Blocked: resolving a review thread is the reviewer's call, not the loop's. Reply to the thread instead \u2014 the `<!-- muggle-do:bot -->` marker on that reply is what retires it (a thread is actionable only while it is unresolved AND its newest comment is unmarked), so resolving buys no echo protection and costs the reviewer their record of what is still unverified. The loop has twice hidden threads carrying fixes that were partly wrong. If a thread genuinely warrants resolving, say so and let the reviewer close it in the UI; to nudge, run the resolve-reminder stage, which lists addressed-but-open threads without touching them.";
+function evaluateReviewThreadResolve(input2) {
+  if (input2.tool_name !== "Bash") return { deny: false };
+  const provider = detectResolveCall(input2.tool_input?.command ?? "");
+  if (!provider) return { deny: false };
+  return { deny: true, reason: RESOLVE_DENIAL };
+}
+
 // src/guardrails/emit.ts
 function envelope(eventName, context, host2) {
   if (!context) return "{}";
@@ -604,6 +1016,13 @@ var host = process.env.CURSOR_PLUGIN_ROOT ? "cursor" : "claude";
 var sub = process.argv[2];
 var input = readStdin();
 var sessionId = input.session_id ?? "unknown";
+function releaseGate(field) {
+  updateState(
+    sessionId,
+    (current) => current[field] === true ? current : { ...current, [field]: true }
+  );
+  return "{}";
+}
 function prOpened() {
   const url = detectPrOpened(input);
   if (!url) return "{}";
@@ -640,6 +1059,7 @@ function offerRan() {
 function terminalGate() {
   const state = readState(sessionId);
   const decision = prTerminalGateDecision(state);
+  if (decision.action === "release" /* Release */) return releaseGate("terminalReleased");
   if (decision.action !== "block" /* Block */) return "{}";
   state.terminalBlockCount = decision.blockCount;
   writeState(state);
@@ -713,6 +1133,7 @@ function classifyGate() {
 function stageGate() {
   const state = readState(sessionId);
   const decision = stageGateDecision(state, unreadMandatoryStages(state));
+  if (decision.action === "release" /* Release */) return releaseGate("stageReleased");
   if (decision.action !== "block" /* Block */) return "{}";
   state.stageBlockCount = decision.blockCount;
   writeState(state);
@@ -723,6 +1144,7 @@ function stageGate() {
 function debugPathGate() {
   const state = readState(sessionId);
   const decision = debugGateDecision(state);
+  if (decision.action === "release" /* Release */) return releaseGate("debugReleased");
   if (decision.action !== "block" /* Block */) return "{}";
   state.debugBlockCount = decision.blockCount;
   writeState(state);
@@ -733,7 +1155,8 @@ function debugPathGate() {
 function e2eGate() {
   const state = readState(sessionId);
   const decision = e2eGateDecision(state);
-  if (decision.action === "none" /* None */ || decision.action === "release" /* Release */) return "{}";
+  if (decision.action === "release" /* Release */) return releaseGate("e2eReleased");
+  if (decision.action === "none" /* None */) return "{}";
   state.e2eBlockCount = decision.blockCount;
   writeState(state);
   const reason = decision.blockCount === 1 ? `Do not end the turn yet. Unit tests passed this session but no E2E acceptance run has happened. Per the autoE2ETest preference (default: always), run change-driven E2E now via /muggle:muggle-test, then finish. If E2E genuinely cannot run here (no app to drive, services down, no PR), tell the user why and run \`echo "MUGGLE_E2E_SKIP: <reason>"\` \u2014 that records the skip and keeps this gate quiet for the rest of the session.` : `E2E acceptance run still owed (reminder ${decision.blockCount}/${MAX_E2E_BLOCKS}): run /muggle:muggle-test, or record a legitimate skip via \`echo "MUGGLE_E2E_SKIP: <reason>"\`.`;
@@ -743,9 +1166,8 @@ function watchGate() {
   const state = readState(sessionId);
   const untrackedPrUrls = findUntrackedHandledPrs(state.prsHandled);
   const decision = watchGateDecision(state, untrackedPrUrls);
-  if (decision.action === "none" /* None */ || decision.action === "release" /* Release */) {
-    return "{}";
-  }
+  if (decision.action === "release" /* Release */) return releaseGate("watchReleased");
+  if (decision.action === "none" /* None */) return "{}";
   state.watchBlockCount = decision.blockCount;
   writeState(state);
   const prList = decision.untracked.join(", ");
@@ -763,6 +1185,7 @@ function walkthroughGate() {
     return "{}";
   }
   const decision = walkthroughGateDecision(state, scan.owed);
+  if (decision.action === "release" /* Release */) return releaseGate("walkthroughReleased");
   if (decision.action !== "block" /* Block */) return "{}";
   state.walkthroughBlockCount = decision.blockCount;
   writeState(state);
@@ -770,11 +1193,73 @@ function walkthroughGate() {
   const reason = decision.blockCount === 1 ? `Do not end the turn yet. An E2E acceptance run happened this session but no visual walkthrough has reached ${prList}. Per the postPRVisualWalkthrough preference (default: always), post it now via /muggle:muggle-pr-visual-walkthrough \u2014 include the failed runs, which are the ones reviewers most need to see. If this result genuinely should not be posted (postPRVisualWalkthrough=never, someone else's PR, nothing renderable), tell the user why and run \`echo "MUGGLE_WALKTHROUGH_SKIP: <reason>"\` \u2014 that records the skip and keeps this gate quiet for the rest of the session.` : `Walkthrough still owed for ${prList} (reminder ${decision.blockCount}/${MAX_WALKTHROUGH_BLOCKS}): post via /muggle:muggle-pr-visual-walkthrough, or record a legitimate skip via \`echo "MUGGLE_WALKTHROUGH_SKIP: <reason>"\`.`;
   return blockStop(reason, host);
 }
+function slotForSession(state) {
+  for (const prUrl of state.prsHandled) {
+    const slotPath = resolveSlotForPr(prUrl);
+    if (slotPath) return slotPath;
+  }
+  return void 0;
+}
+function recordCommentReplies() {
+  const cmd = input.tool_input?.command ?? "";
+  const state = readState(sessionId);
+  const slotPath = slotForSession(state);
+  if (!slotPath) return "{}";
+  if (isReplySkipMarker(cmd)) {
+    const deferred = deferredCommentIds(readLedger(slotPath), cmd);
+    if (deferred.length === 0) {
+      updateState(sessionId, (current) => ({ ...current, commentReplySkipped: true }));
+      return "{}";
+    }
+    for (const { threadId, commentIds } of deferred) {
+      commitThread(slotPath, threadId, (entry) => coverComments(entry, commentIds, null));
+    }
+    return "{}";
+  }
+  for (const thread of detectUnansweredThreads(input)) {
+    commitThread(
+      slotPath,
+      thread.threadId,
+      (entry) => claimThread(
+        refreshHumanComments({ ...entry, provider: thread.provider }, thread.humanCommentIds),
+        sessionId
+      )
+    );
+  }
+  const confirmed = detectConfirmedReplies(input);
+  if (confirmed.length > 0) {
+    const ledger = readLedger(slotPath);
+    for (const reply of confirmed) {
+      const threadId = threadForReplyTarget(ledger, reply.targetId);
+      if (!threadId) continue;
+      const covered = threadId === reply.targetId ? uncoveredComments(ledger.threads[threadId]) : [reply.targetId];
+      commitThread(slotPath, threadId, (entry) => coverComments(entry, covered, reply.replySha));
+    }
+  }
+  return "{}";
+}
+function commentReplyGate() {
+  const state = readState(sessionId);
+  const slotPath = slotForSession(state);
+  if (!slotPath) return "{}";
+  const decision = commentReplyGateDecision(state, overdueThreads(slotPath, sessionId));
+  if (decision.action === "release" /* Release */) return releaseGate("commentReplyReleased");
+  if (decision.action !== "block" /* Block */) return "{}";
+  updateState(sessionId, (current) => ({ ...current, commentReplyBlockCount: decision.blockCount }));
+  const commentList = decision.unanswered.join(", ");
+  const reason = decision.blockCount === 1 ? `Do not end the turn yet. This session took these review comments as work and never answered them: ${commentList}. Post one reply per comment in its own thread per muggle-do do/per-comment-replies.md \u2014 "Addressed in <short-sha>: <what changed for THIS comment>", signed via sign-body.sh --mode loop. A silent round leaves the reviewer with no answer in the thread, and the loop marker that reply carries is the only thing that stops the watcher re-dispatching the same thread next tick. If a comment was escalated to the user instead of answered, record it as deferred rather than replying.` : `Review comments still owe a threaded reply (reminder ${decision.blockCount}/${MAX_REPLY_BLOCKS}): ${commentList}. Reply per do/per-comment-replies.md, or record the deferral.`;
+  return blockStop(reason, host);
+}
 function reportGate() {
   const reportPostVerdict = evaluateReportPost(input);
   if (!reportPostVerdict.deny || !reportPostVerdict.reason) return "{}";
   return denyTool(reportPostVerdict.reason, host);
 }
+function resolveGate() {
+  const resolveVerdict = evaluateReviewThreadResolve(input);
+  if (!resolveVerdict.deny || !resolveVerdict.reason) return "{}";
+  return denyTool(resolveVerdict.reason, host);
+}
 function buildRouter() {
   if (!detectBuildIntent(input.prompt ?? "")) return "{}";
   const state = readState(sessionId);
@@ -784,8 +1269,28 @@ function buildRouter() {
   const ctx = `This looks like a build/implement/fix request. Per the autoRouteBuildToMuggleDo preference, route it through /muggle-do \u2014 which runs requirements \u2192 build (delegated to superpowers' design\u2192plan\u2192review) \u2192 impact \u2192 unit tests \u2192 E2E \u2192 PR \u2192 watcher. If autoRouteBuildToMuggleDo=always, enter that flow; if =ask, offer it; if =never, proceed normally.`;
   return envelope("UserPromptSubmit", ctx, host);
 }
+function capabilityClaimGate() {
+  const state = readState(sessionId);
+  if (state.capabilityClaimNudged) return "{}";
+  const transcriptPath = input.transcript_path;
+  if (!transcriptPath) return "{}";
+  let transcriptTail;
+  try {
+    transcriptTail = readFileSync(transcriptPath, "utf-8").slice(
+      -CAPABILITY_CLAIM_TRANSCRIPT_TAIL_BYTES
+    );
+  } catch {
+    return "{}";
+  }
+  if (!detectFalseCapabilityClaim(lastAssistantText(transcriptTail))) return "{}";
+  state.capabilityClaimNudged = true;
+  writeState(state);
+  const reason = `Do not end the turn yet. This turn tells the user that an email- or login-gated flow cannot be tested, reached, or verified \u2014 the one class of blocker Muggle clears. Every managed login profile owns a live inbox, so magic-link and sign-in-link logins, emailed OTPs, email-based 2FA, verification mail, and password resets run end to end with no mail stub and no test-only backdoor; stored credentials and CAPTCHA solving are covered too. Re-read plugin/skills/_shared/identity-and-inbox.md, then correct the claim or run the flow. If the real blocker is SMS/phone OTP, authenticator-app TOTP, or OAuth-only social login, those limits are genuine \u2014 name the one that applies and move on.`;
+  return blockStop(reason, host);
+}
 var handlers = {
   "pr-opened": prOpened,
+  "capability-claim-gate": capabilityClaimGate,
   "pr-terminal": prTerminal,
   "offer-ran": offerRan,
   "record-tests": recordTests,
@@ -793,7 +1298,10 @@ var handlers = {
   "terminal-gate": terminalGate,
   "watch-gate": watchGate,
   "walkthrough-gate": walkthroughGate,
+  "record-comment-replies": recordCommentReplies,
+  "comment-reply-gate": commentReplyGate,
   "report-gate": reportGate,
+  "resolve-gate": resolveGate,
   "build-router": buildRouter,
   "skill-stages": skillStages,
   "record-stage-read": recordStageRead,