@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/chunk-O45GBJEH.js

@@ -0,0 +1,1500 @@
+import {
+  persistSupportArtifact,
+  supportClusterClearableSchema,
+  supportClusterSchema,
+  supportCommitSchema,
+  supportIdSchema,
+  supportProductSchema,
+  supportTaskIdSchema,
+  supportVersionSchema
+} from "./chunk-BNI4LIU5.js";
+import {
+  queueSupportStatusUpdateSync
+} from "./chunk-X7HZHKY4.js";
+import {
+  assessAttribution,
+  assessDisposition,
+  buildVerificationArtifact,
+  isPlaceholderIdentity,
+  isUnresolvedIdentity
+} from "./chunk-SSFS4NCH.js";
+import {
+  SUPPORT_REPORT_SENT_MARKER
+} from "./chunk-MMRUBN3I.js";
+import {
+  resolveSupportAdminToken,
+  supportAdminHeaders
+} from "./chunk-2XZ6X3PJ.js";
+import {
+  getActiveAgent
+} from "./chunk-B4XJQBQB.js";
+import {
+  SUPPORT_PRODUCTS,
+  describeUpstreamFailure,
+  redactSecrets,
+  redactedToolResult,
+  sanitizeProductFilter,
+  sanitizeUpstreamId,
+  sanitizeVersionField,
+  sanitizedUpstreamBody
+} from "./chunk-ZUGQPYUY.js";
+import {
+  loadLicense,
+  readCachedLicenseToken
+} from "./chunk-FWRPDSO3.js";
+import {
+  EXE_AI_DIR,
+  loadConfig
+} from "./chunk-MMS2HBRT.js";
+
+// src/mcp/tools/support-inbox.ts
+import { z as z3 } from "zod";
+import { readFileSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/mcp/tools/update-bug-report.ts
+import { z as z2 } from "zod";
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+
+// src/lib/support-text-limits.ts
+var SUPPORT_PROGRESS_NOTE_MAX = 2e3;
+var SUPPORT_TRIAGE_NOTES_MAX = 12e3;
+var SUPPORT_EVIDENCE_PREFIX = "Evidence: ";
+var SUPPORT_REOPEN_PREFIX = "Reopen requested: ";
+var SUPPORT_EVIDENCE_MAX = SUPPORT_PROGRESS_NOTE_MAX - SUPPORT_EVIDENCE_PREFIX.length;
+var SUPPORT_REOPEN_REASON_MAX = SUPPORT_PROGRESS_NOTE_MAX - SUPPORT_REOPEN_PREFIX.length;
+function upstreamTextLength(text) {
+  if (!text) return 0;
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  return redactSecrets(trimmed).text.length;
+}
+function checkSupportTextLimits(entries) {
+  const oversize = [];
+  for (const entry of entries) {
+    const length = upstreamTextLength(entry.text);
+    if (length > entry.limit) {
+      oversize.push({ field: entry.field, length, limit: entry.limit });
+    }
+  }
+  return oversize;
+}
+function describeOversizeRefusal(oversize) {
+  const lines = oversize.map((o) => `  - ${o.field}: ${o.length} chars (max ${o.limit})`);
+  return `Refused: text too long for the support tracker, which truncates silently (bug 43b2a68c).
+` + lines.join("\n") + `
+Nothing was written \u2014 no local update, no memory, no upstream send. Shorten the field(s) above or split the text across multiple calls, then retry.`;
+}
+
+// src/lib/support-verification-input.ts
+import { z } from "zod";
+
+// src/lib/attribution-resolve.ts
+import { execFileSync } from "child_process";
+function resolveModelFromEnvironment() {
+  const candidates = [
+    process.env.EXE_ATTRIBUTION_MODEL,
+    process.env.ANTHROPIC_MODEL,
+    process.env.CLAUDE_MODEL,
+    process.env.EXE_MODEL
+  ];
+  for (const candidate of candidates) {
+    const value = candidate?.trim();
+    if (value && !isPlaceholderIdentity(value)) return value;
+  }
+  return null;
+}
+function resolveRef(ref, cwd) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--verify", `${ref}^{commit}`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{40}$/i.test(out) ? out : null;
+  } catch {
+    return null;
+  }
+}
+var MODEL_HELP = "Set ANTHROPIC_MODEL (employee sessions get it automatically at launch) or pass attribution_model explicitly. It is NOT guessed: a wrong model on the record is worse than no record at all, because it points at the wrong suspect.";
+function resolveAttribution(purpose, input = {}) {
+  const stated = input.agent?.trim() ?? "";
+  let observed = "";
+  try {
+    observed = getActiveAgent().agentId?.trim() ?? "";
+  } catch {
+    observed = "";
+  }
+  let agent;
+  if (purpose === "verdict") {
+    const observedIsReal = observed !== "" && !isUnresolvedIdentity(observed);
+    if (observedIsReal && stated && stated.toLowerCase() !== observed.toLowerCase()) {
+      return {
+        ok: false,
+        code: "attribution_agent_conflict",
+        message: `Refused locally [attribution_agent_conflict]: attribution_agent was given as "${stated}", but this session resolves to "${observed}". A verdict is signed by whoever actually made it \u2014 attribution_agent is a fallback for a session that cannot observe its own identity (the MCP daemon), not a way to record the call under another employee's name. Omit attribution_agent to sign as "${observed}", or make the call from that employee's session.`
+      };
+    }
+    agent = observedIsReal ? observed : stated;
+  } else {
+    agent = stated || observed;
+  }
+  if (purpose === "verdict" && isUnresolvedIdentity(agent)) {
+    agent = "";
+  }
+  if (!agent) {
+    const message = purpose === "verdict" ? "Refused locally [attribution_agent_missing]: could not resolve which agent is producing this verdict, and it will not be invented. The MCP tools run in the launchd daemon, which carries no active-agent marker, no tmux session and no AGENT_ID, so the session identity is not observable from there. Pass attribution_agent with your own employee name exactly as it appears in the roster \u2014 never a role like 'admin'." : `Refused locally [attribution_agent_missing]: could not resolve which agent is producing this ${purpose}, and it will not be invented. Restore the active-agent marker or set AGENT_ID to your real employee name.`;
+    return {
+      ok: false,
+      code: "attribution_agent_missing",
+      // Every refusal out of this function names its machine-stable code in the message,
+      // including the ones below that come back from `assessAttribution`. A caller only
+      // ever sees the message, so a code that appears in some refusals and not others is
+      // a code the caller cannot rely on.
+      message
+    };
+  }
+  const model = input.model?.trim() || resolveModelFromEnvironment();
+  if (!model) {
+    return {
+      ok: false,
+      code: "attribution_model_missing",
+      message: `Refused locally [attribution_model_missing]: could not resolve which model is producing this record. ${MODEL_HELP}`
+    };
+  }
+  const observedAt = input.observed_at?.trim() || (/* @__PURE__ */ new Date()).toISOString();
+  const attribution = {
+    agent,
+    model,
+    observed_at: observedAt
+  };
+  if (purpose === "verdict") {
+    const repo = input.repo_path?.trim() || process.cwd();
+    const requested = input.evidence_ref?.trim() || "HEAD";
+    const resolved = resolveRef(requested, repo);
+    if (!resolved) {
+      return {
+        ok: false,
+        code: "attribution_evidence_ref_invalid",
+        message: `Refused locally [attribution_evidence_ref_invalid]: evidence_ref "${requested}" does not resolve to a commit in ${repo}. A verdict is only meaningful against a ref someone else can check out \u2014 name the commit you actually read; if the repository is wrong, pass repo_path for the repository that contains the commit.`
+      };
+    }
+    attribution.evidence_ref = resolved;
+  }
+  if (input.second_opinion_model || input.second_opinion_verdict) {
+    attribution.second_opinion = {
+      model: input.second_opinion_model?.trim() ?? "",
+      verdict: input.second_opinion_verdict ?? "confirmed"
+    };
+  }
+  const assessed = assessAttribution(attribution, purpose);
+  if (!assessed.ok) {
+    return { ok: false, code: assessed.code, message: `Refused locally [${assessed.code}]: ${assessed.message}` };
+  }
+  return { ok: true, attribution };
+}
+
+// src/lib/support-verification-input.ts
+function isVerifiedStatus(status) {
+  return status === "fixed" || status === "closed";
+}
+var verificationArtifactInputSchema = {
+  verification_kind: z.enum(["regression_test", "manual", "ops_transcript"]).optional().describe(
+    "REQUIRED to set status=fixed or closed (unless closing with a non-'fixed' disposition). 'regression_test' when you actually RAN a test that fails at the parent commit and passes at the fix. 'manual' when a named person reproduced the original defect and confirmed it is gone. 'ops_transcript' when the defect was settled by running commands against a live system and there is no commit (CI state, a VPS config edit, an ops confirmation)."
+  ),
+  defect_layer: z.enum(["production", "test_harness"]).optional().describe(
+    "Where the DEFECT lives. Omit for the normal case (production source). Declare 'test_harness' ONLY when the filed defect IS the test/harness \u2014 a flaky fixture, a leaked singleton, a test that spawns a hook wrong \u2014 so that a production diff would be the WRONG fix. This costs MORE evidence, not less: it additionally requires regression_test_id and reverted_result. It is NOT a way past a refused substance check; if your fix was supposed to change production code and did not, the honest answer is that it is not finished."
+  ),
+  reverted_result: z.enum(["fail", "pass", "error"]).optional().describe(
+    "defect_layer=test_harness only: the result you OBSERVED re-running the named test with the fix reverted. Must be 'fail' \u2014 a test-only diff that does not go red when removed evidences nothing."
+  ),
+  claim_type: z.enum(["point_in_time", "ongoing_state"]).optional().describe(
+    "ops_transcript only. 'point_in_time' for a fact true when observed (a config now routes correctly). 'ongoing_state' for a claim that a condition HOLDS (an agent is reporting, CI is green) \u2014 that requires at least two probes taken at two distinct times, because one sample cannot evidence a continuing condition."
+  ),
+  ops_probes: z.string().optional().describe(
+    `ops_transcript only. JSON array of probes, each {"command","output","host","ran_at"}. VERBATIM: the command as typed, its real output, the host/system it ran against, and an ISO timestamp. Summaries are refused \u2014 'checked the VPS and it looks fine' is not a probe.`
+  ),
+  fix_commit: supportCommitSchema.optional().describe(
+    "SHA of the merged commit containing the fix. Its diff is measured locally on EVERY kind that supplies one, ops_transcript included \u2014 a comment-only, test-only, docs-only or lockfile-only commit is refused. Optional only for ops_transcript, which may name no commit at all."
+  ),
+  repo_path: z.string().optional().describe("Absolute path to the repository containing fix_commit. Required when the fix landed outside the current working repo (e.g. exe-gateway, exe-crm). Defaults to the current directory."),
+  regression_test_id: z.string().optional().describe("regression_test only: the test that detects the defect, e.g. 'tests/raw-event-backlog.test.ts::counts unprocessed events'."),
+  parent_result: z.enum(["fail", "pass", "error"]).optional().describe("regression_test only: the result you OBSERVED running that test at the parent commit. Must be 'fail' \u2014 a test that already passed does not detect the defect."),
+  fix_result: z.enum(["fail", "pass", "error"]).optional().describe("regression_test only: the result you OBSERVED running that test at the fix commit. Must be 'pass'."),
+  verifier: z.string().optional().describe("manual and ops_transcript: the identity of the person or employee who confirmed the defect is gone. Checked server-side against the bug's filer and assignee \u2014 it may not be either. Placeholders ('me', 'agent') are refused."),
+  disposition: z.enum(["fixed", "not_a_defect", "superseded", "wontfix"]).optional().describe(
+    "WHY the record is closing. Omit (or 'fixed') for the normal case: a defect was repaired, and a verification artifact is required. Use 'not_a_defect' when there was nothing to fix (a smoke-test record, a misfiled report), 'superseded' when another record covers it, 'wontfix' when it is a deliberate decline. Those three require NO fix_commit but DO require disposition_reason \u2014 and they are recorded as closed, not as fixed, because asserting a repair that never happened is its own kind of false record."
+  ),
+  disposition_reason: z.string().optional().describe(
+    "REQUIRED for any disposition other than 'fixed': what makes this record a non-defect. Explain the call \u2014 a bare label or a hedge is refused."
+  ),
+  superseded_by: z.string().optional().describe("REQUIRED for disposition='superseded': the id of the record that replaces this one, so the claim is checkable."),
+  superseded_coverage: z.string().optional().describe(
+    `REQUIRED for disposition='superseded': JSON array of {"id","evidence"} \u2014 one entry per declared symptom, each naming where the superseding record covers it. PARTIAL COVERAGE SUPERSEDES NOTHING: if the other record covers three of five symptoms, the honest outcome is to keep this record open with the two survivors as its remaining scope, not to close it. The refusal names the survivors.`
+  ),
+  symptoms: z.string().optional().describe(
+    `JSON array of the distinct defects this record claims, as ids or {"id"} objects. Required to close as 'superseded' so coverage can be checked one by one.`
+  ),
+  observed_at: z.string().optional().describe(
+    "ISO timestamp of when you actually READ the evidence. Defaults to now. Set it explicitly when the evidence was observed earlier than this call."
+  ),
+  evidence_ref: z.string().optional().describe(
+    "The git ref you read the evidence at (defaults to HEAD of repo_path, resolved locally and refused if it does not exist). main moves several times a day, so a verdict against an unnamed ref cannot be reproduced."
+  ),
+  attribution_agent: z.string().optional().describe(
+    "The employee identity producing this verdict \u2014 your own name as it appears in the roster. Normally OMITTED: it is resolved from the session's active-agent marker. Supply it when the call is made through the MCP daemon (which has no marker, no tmux and no AGENT_ID and would otherwise sign the record 'default') or from a harness. It is never guessed, and a role ('admin', 'agent', 'support') is refused \u2014 the whole point is that a verdict can be traced to someone."
+  ),
+  attribution_model: z.string().optional().describe(
+    "The model producing this verdict, e.g. 'claude-opus-5'. Normally OMITTED: it is read from ANTHROPIC_MODEL, which employee launches set automatically. Supply it only when the session carries no such variable \u2014 a session launched outside the employee router, or a harness. It is still never guessed: omit it with no environment model and the close is refused, naming the variable."
+  ),
+  second_opinion_model: z.string().optional().describe("Optional adversarial review: the OTHER model that checked this verdict. Must differ from the model producing it."),
+  second_opinion_verdict: z.enum(["confirmed", "refuted"]).optional().describe("Optional adversarial review: what the second model concluded. A 'refuted' verdict cannot be closed over."),
+  disposition_verifier: z.string().optional().describe(
+    "REQUIRED for disposition='not_a_defect' or 'superseded': a named identity, not the record's filer or assignee, who agrees that what was filed is not a defect. Same identity rule as a manual verification."
+  ),
+  verification_method: z.string().optional().describe("manual only \u2014 genuinely manual-only, unlike verification_observation: how it was verified, in enough detail for someone else to repeat it."),
+  verification_observation: z.string().optional().describe(
+    "REQUIRED for manual AND for ops_transcript (it is listed under both in REQUIRED_ARGUMENTS_BY_KIND, and both run the same assessObservation predicate): what was observed that shows the DEFECT IS ABSENT \u2014 not what the change did, and not what you were doing. 'It is fixed' is refused; so is 'probing whether ...'. On an ops_transcript the observation must additionally report what the probes returned, in the output's own words."
+  ),
+  delivery_proof: z.string().optional().describe('Optional JSON delivery declaration, e.g. {"channel":"npm","version":"0.9.364","tarball_shasum":"\u2026","fix_path_published":true}. Recorded, not required \u2014 delivery does not gate closing. A declaration that is present must still be true.')
+};
+function buildVerdictAttribution(input) {
+  return resolveAttribution("verdict", {
+    agent: input.attribution_agent,
+    model: input.attribution_model,
+    observed_at: input.observed_at,
+    evidence_ref: input.evidence_ref,
+    repo_path: input.repo_path,
+    second_opinion_model: input.second_opinion_model,
+    second_opinion_verdict: input.second_opinion_verdict
+  });
+}
+var NO_ARTIFACT_HELP = [
+  "Refused locally: setting status=fixed or closed requires evidence that the defect is ABSENT.",
+  "",
+  "Supply ONE of:",
+  "  regression_test \u2014 verification_kind='regression_test', fix_commit, repo_path,",
+  "      regression_test_id, parent_result (must be the result you observed at the parent),",
+  "      fix_result. Use this when you actually ran the test at both commits.",
+  "  manual \u2014 verification_kind='manual', fix_commit, repo_path, verifier (a real identity,",
+  "      not the bug's filer or assignee), verification_method, verification_observation",
+  "      describing what you saw that shows the defect is gone.",
+  "  ops_transcript \u2014 verification_kind='ops_transcript', verifier, claim_type",
+  "      ('point_in_time' for a fact true when observed, e.g. a config now routes",
+  "      correctly; 'ongoing_state' for a claim that a condition HOLDS, e.g. an agent is",
+  "      reporting or CI is green \u2014 that needs 2+ probes at distinct times, since one",
+  "      sample cannot evidence a continuing condition), ops_probes (verbatim",
+  "      {command, output, host, ran_at} entries), and verification_observation \u2014 which",
+  "      is required for this kind too, and must report what the probes actually returned",
+  "      in the output's own words. Use this when there is no commit to measure \u2014 the",
+  "      defect was settled by running commands against a live system (CI state, a VPS",
+  "      config edit, an ops confirmation). fix_commit stays OPTIONAL here, but a commit",
+  "      you do name is measured exactly as it is on every other kind.",
+  "",
+  "The fix commit's diff is measured from the repository; substance is never taken from the caller.",
+  "If you have not verified the defect is absent, do not close it \u2014 record what you found with notes instead."
+].join("\n");
+var REQUIRED_ARGUMENTS_BY_KIND = {
+  regression_test: ["fix_commit", "regression_test_id", "parent_result", "fix_result"],
+  manual: ["fix_commit", "verifier", "verification_method", "verification_observation"],
+  ops_transcript: ["verifier", "claim_type", "ops_probes", "verification_observation"]
+};
+function argumentArrived(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  return true;
+}
+function assertVerificationArgumentsArrived(kind, input) {
+  const missing = REQUIRED_ARGUMENTS_BY_KIND[kind].filter((field) => !argumentArrived(input[field]));
+  if (missing.length === 0) return { ok: true };
+  return {
+    ok: false,
+    message: [
+      `Refused locally [verification_arguments_missing]: this close declared verification_kind='${kind}', but these required parameters did not arrive in the tool call:`,
+      ...missing.map((field) => `  - ${String(field)}`),
+      "",
+      "They reached the tool as undefined or empty, so this is NOT a judgement on the evidence you wrote \u2014 that value was never seen here.",
+      "If you did pass them, the argument was dropped or truncated between your client and the tool. Resend the call with those parameters present; long evidence survives better as a separate add_comment followed by a close that references it.",
+      "",
+      "Nothing was written locally and nothing was sent upstream."
+    ].join("\n")
+  };
+}
+var ATTRIBUTION_REQUIRED_HELP = [
+  "Refused locally [attribution_missing]: a close carries WHO made the call, with WHAT model, at WHICH commit \u2014 and it did not resolve here, so it will not be sent unattributed for the server to refuse with an opaque 422.",
+  "",
+  "Supply the parts that could not be resolved from this session:",
+  "  attribution_agent \u2014 your real employee name (the MCP daemon has no session identity to read).",
+  "  attribution_model \u2014 the model producing this verdict, e.g. 'claude-opus-5'.",
+  "  evidence_ref / repo_path \u2014 the commit you actually read the evidence at, in the repo it lives in.",
+  "",
+  "None of these are guessed: a verdict signed with the wrong agent or model is a record pointing at the wrong suspect."
+].join("\n");
+function assertVerdictAttribution(status, resolved) {
+  if (!isVerifiedStatus(status) || !resolved.ok || resolved.attribution) return { ok: true };
+  return { ok: false, message: ATTRIBUTION_REQUIRED_HELP };
+}
+function resolveVerificationArtifact(status, input, context = {}) {
+  if (!isVerifiedStatus(status)) return { ok: true };
+  const disposition = input.disposition ?? "fixed";
+  if (disposition !== "fixed") {
+    const assessed = assessDisposition(disposition, {
+      status: typeof status === "string" ? status : "closed",
+      disposition,
+      disposition_reason: input.disposition_reason,
+      superseded_by: input.superseded_by,
+      disposition_verifier: input.disposition_verifier,
+      superseded_coverage: input.superseded_coverage,
+      symptoms: input.symptoms,
+      context
+    });
+    if (!assessed.ok) return { ok: false, message: `Refused locally [${assessed.code}]: ${assessed.message}` };
+    const dispositionAttribution = buildVerdictAttribution(input);
+    if (!dispositionAttribution.ok) return { ok: false, message: dispositionAttribution.message };
+    return { ok: true, attribution: dispositionAttribution.attribution };
+  }
+  if (!input.verification_kind && !input.fix_commit) {
+    return { ok: false, message: NO_ARTIFACT_HELP };
+  }
+  if (!input.verification_kind) {
+    return { ok: false, message: "verification_kind is required (regression_test, manual or ops_transcript) when setting status=fixed or closed." };
+  }
+  if (!input.fix_commit && input.verification_kind !== "ops_transcript") {
+    return { ok: false, message: "fix_commit is required when setting status=fixed or closed \u2014 the diff is measured, not described." };
+  }
+  const arrived = assertVerificationArgumentsArrived(input.verification_kind, input);
+  if (!arrived.ok) return { ok: false, message: arrived.message };
+  let probes;
+  if (input.verification_kind === "ops_transcript") {
+    const parsed = parseOpsProbes(input.ops_probes);
+    if (!parsed.ok) return { ok: false, message: parsed.message };
+    probes = parsed.probes;
+  }
+  const request = {
+    kind: input.verification_kind,
+    fix_commit: input.fix_commit ?? "",
+    repo_path: input.repo_path?.trim() || process.cwd(),
+    test_id: input.regression_test_id,
+    parent_result: input.parent_result,
+    fix_result: input.fix_result,
+    verifier: input.verifier,
+    method: input.verification_method,
+    observation: input.verification_observation,
+    defect_layer: input.defect_layer,
+    reverted_result: input.reverted_result,
+    claim_type: input.claim_type,
+    probes
+  };
+  const built = buildVerificationArtifact(request, context);
+  if (!built.ok) {
+    return { ok: false, message: `Refused locally [${built.code}]: ${built.message}` };
+  }
+  const attribution = buildVerdictAttribution(input);
+  if (!attribution.ok) return { ok: false, message: attribution.message };
+  return { ok: true, artifact: built.artifact, attribution: attribution.attribution };
+}
+function parseOpsProbes(raw) {
+  if (raw === void 0 || !raw.trim()) {
+    return {
+      ok: false,
+      message: "ops_probes is required for verification_kind='ops_transcript': a JSON array of {command, output, host, ran_at}, all verbatim."
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { ok: false, message: "ops_probes must be valid JSON: an array of {command, output, host, ran_at}." };
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    return { ok: false, message: "ops_probes must be a non-empty JSON array of {command, output, host, ran_at}." };
+  }
+  return { ok: true, probes: parsed };
+}
+function parseDeliveryProof(raw) {
+  if (raw === void 0 || !raw.trim()) return { ok: true };
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false, message: "delivery_proof must be valid JSON (or omitted \u2014 delivery does not gate closing)." };
+  }
+}
+
+// src/mcp/tools/update-bug-report.ts
+var STATUS = z2.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var FRONTMATTER_ID_RE = /^id:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s*$/m;
+async function readReportId(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return content.match(FRONTMATTER_ID_RE)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findReportFile(id) {
+  const dir = path.join(EXE_AI_DIR, "bug-reports");
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return null;
+  }
+  const requested = id.trim().toLowerCase();
+  if (UUID_RE.test(requested)) {
+    for (const f of files) {
+      const filePath = path.join(dir, f);
+      const fileId = await readReportId(filePath);
+      if (fileId && fileId.toLowerCase() === requested) {
+        return { filePath, fullId: fileId };
+      }
+    }
+    return null;
+  }
+  const prefix = requested.slice(0, 8);
+  const suffix = `-${prefix}.md`;
+  const candidates = files.filter((f) => f.toLowerCase().endsWith(suffix));
+  if (candidates.length === 0) return null;
+  for (const f of candidates) {
+    const filePath = path.join(dir, f);
+    const fileId = await readReportId(filePath);
+    if (fileId && fileId.toLowerCase().startsWith(prefix)) {
+      return { filePath, fullId: fileId };
+    }
+  }
+  if (candidates.length === 1 && candidates[0]) {
+    const filePath = path.join(dir, candidates[0]);
+    const fileId = await readReportId(filePath);
+    return { filePath, fullId: fileId ?? requested };
+  }
+  return null;
+}
+async function buildUpdateSection(filePath, opts) {
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf-8");
+  } catch {
+    existing = "";
+  }
+  const heading = opts.reopen ? "Reopen Request" : "Status Update";
+  const updateBlock = [
+    "",
+    `## ${heading} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    ...opts.status ? [`status: ${opts.status}`] : [],
+    ...opts.fixVersion ? [`fix_version: ${opts.fixVersion}`] : [],
+    ...opts.notes ? [``, opts.notes] : [],
+    ...opts.evidence ? [``, `Evidence: ${opts.evidence}`] : []
+  ].join("\n");
+  const titleMatch = existing.match(/^# Bug Report — (.+)$/m);
+  return { title: titleMatch?.[1] ?? "Unknown bug", updateBlock };
+}
+async function collectBugAuthorIdentities(id) {
+  const identities = [];
+  try {
+    const resolved = await findReportFile(id);
+    if (resolved) {
+      const content = await readFile(resolved.filePath, "utf-8");
+      const filedBy = content.match(/^filed_by:\s*(.+)$/m)?.[1]?.trim();
+      if (filedBy) identities.push(filedBy);
+    }
+  } catch {
+  }
+  try {
+    const config = await loadConfig();
+    const adminToken2 = resolveSupportAdminToken(config);
+    if (adminToken2) {
+      const support = config.support;
+      const base = (process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || support?.adminEndpoint || support?.admin_endpoint || "https://api.askexe.com/admin/support/bug-reports").replace(/\/+$/, "");
+      const parsed = new URL(`${base}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      if (parsed.protocol === "https:" || ["localhost", "127.0.0.1", "::1"].includes(parsed.hostname)) {
+        const resp = await fetch(parsed, {
+          headers: { authorization: `Bearer ${adminToken2}` },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (resp.ok) {
+          const row = await resp.json();
+          identities.push(row?.agent_id, row?.license_email);
+        }
+      }
+    }
+  } catch {
+  }
+  return identities;
+}
+async function sendUpstream(payload, isAdmin) {
+  const config = await loadConfig();
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  const adminToken2 = resolveSupportAdminToken(config);
+  const support = config.support;
+  const baseEndpoint = isAdmin && adminToken2 ? process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || support?.adminEndpoint || support?.admin_endpoint || "https://api.askexe.com/admin/support/bug-reports" : config.support?.bugReportEndpoint || process.env.EXE_BUG_REPORT_ENDPOINT || (routerUrl ? `${routerUrl}/v1/support/bug-reports` : "https://api.askexe.com/v1/support/bug-reports");
+  const licenseKey = loadLicense() || process.env.EXE_LICENSE_KEY || config.cloud?.apiKey;
+  const licenseToken = readCachedLicenseToken();
+  if (!baseEndpoint) return "not_configured";
+  try {
+    const base = baseEndpoint.replace(/\/+$/, "");
+    const url = `${base}/${encodeURIComponent(sanitizeUpstreamId(payload.id))}`;
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && !["localhost", "127.0.0.1", "::1"].includes(parsed.hostname)) {
+      return "failed: insecure endpoint rejected";
+    }
+    const adminHeaders = isAdmin && adminToken2 ? { authorization: `Bearer ${adminToken2}`, ...supportAdminHeaders(config) } : {};
+    const response = await fetch(parsed, {
+      method: "PATCH",
+      headers: {
+        "content-type": "application/json",
+        ...isAdmin && adminToken2 ? {} : {
+          ...licenseKey ? { "x-exe-license-key": licenseKey, authorization: `Bearer ${licenseKey}` } : {},
+          ...licenseToken ? { "x-exe-license-token": licenseToken } : {}
+        },
+        ...adminHeaders
+      },
+      // Egress redaction gate (dc16fee4) — add_evidence ("logs, repro details,
+      // stack traces"), add_note, and triage_notes are the most secret-dense
+      // support fields; redact before the network send.
+      body: sanitizedUpstreamBody(payload, "update-bug-report"),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) return `failed: ${await describeUpstreamFailure(response)}`;
+    return "sent";
+  } catch (err) {
+    return `failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+var UPSTREAM_BOOKKEEPING_FIELDS = /* @__PURE__ */ new Set(["id", "updated_at", "agent_id"]);
+var MISSING_ID_HELP = [
+  "Refused locally [id_missing]: update_bug requires the parameter 'id' \u2014 the bug report UUID, or its 8-character prefix \u2014 and it did not arrive in this tool call.",
+  "",
+  "Nothing was written locally and nothing was sent upstream. Resend the call with 'id' set.",
+  "If you did pass it, the argument was dropped or truncated between your client and the tool."
+].join("\n");
+function describeEmptyUpstreamPayload(isAdmin) {
+  return [
+    'Refused locally [upstream_payload_empty]: this update carries no supported field the AskExe support API can write, so it would be sent as an empty PATCH, refused upstream with HTTP 400 "No supported fields provided", and queued as a no-op retry that looks like recovery.',
+    "",
+    isAdmin ? "An admin update must carry at least one of: status, fix_version/fixed_version, product, notes (triage notes), add_evidence, reopen_request, or a verification artifact / disposition." : "An owner update must carry at least one of: notes, add_evidence, or reopen_request.",
+    "",
+    "Nothing was written locally and nothing was sent upstream. If you did pass one of those, the argument was dropped or truncated between your client and the tool \u2014 resend the call."
+  ].join("\n");
+}
+function registerUpdateBugReport(server) {
+  server.registerTool(
+    "update_bug_report",
+    {
+      title: "Update Bug Report",
+      description: "Update a previously filed bug report. As the filing customer (owner) you can add follow-up notes (notes/add_note), attach additional evidence (add_evidence), and request a reopen on a recurring fixed bug (reopen_request). AskExe support (with an admin token) can also move status: open \u2192 triaged \u2192 fixed \u2192 closed (or wontfix). Updates the local file, POSTs the change to AskExe support, and stores a memory.",
+      inputSchema: {
+        id: supportIdSchema.describe("Bug report UUID (full or 8-char prefix)"),
+        status: STATUS.optional().describe(
+          "New status (admin only): open, triaged, fixed, closed, wontfix. Owners cannot set this \u2014 use reopen_request instead."
+        ),
+        fix_version: supportVersionSchema.optional().describe("Version that fixes this bug (admin only, e.g. '0.9.161')"),
+        product: supportProductSchema.optional().describe("Re-label this bug's product (admin only): exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp"),
+        notes: z2.string().optional().describe("Follow-up notes about the bug or status change"),
+        add_note: z2.string().optional().describe("Owner follow-up note (alias of notes)"),
+        add_evidence: z2.string().optional().describe("Additional evidence: logs, repro details, stack traces"),
+        reopen_request: z2.boolean().optional().describe("Request a reopen on a recurring fixed/closed bug"),
+        reopen_reason: z2.string().optional().describe("Why the bug should be reopened (recurring symptoms, etc.)"),
+        send_upstream: z2.boolean().default(true).describe("POST the change to AskExe support endpoint"),
+        // Close gate (bug e9ba4b47) — this is the third client that can set a gated
+        // status, and it 422s exactly like the others without an artifact.
+        ...verificationArtifactInputSchema
+      }
+    },
+    async ({ id, status, fix_version, product, notes, add_note, add_evidence, reopen_request, reopen_reason, send_upstream, ...verification }) => redactedToolResult(async () => {
+      if (typeof id !== "string" || id.trim().length === 0) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: MISSING_ID_HELP
+          }]
+        };
+      }
+      const { agentId, agentRole } = getActiveAgent();
+      const config = await loadConfig();
+      const isAdmin = !!resolveSupportAdminToken(config);
+      const followUpNote = notes ?? add_note;
+      const reopen = reopen_request === true;
+      const effectiveStatus = reopen ? "open" : status;
+      const wireStatus = isAdmin ? effectiveStatus : void 0;
+      const gatedStatus = reopen ? void 0 : wireStatus;
+      const adminProgressNote = isAdmin ? [
+        add_evidence ? `${SUPPORT_EVIDENCE_PREFIX}${add_evidence}` : null,
+        reopen ? `${SUPPORT_REOPEN_PREFIX}${reopen_reason ?? "recurring"}` : null
+      ].filter(Boolean).join("\n\n") : "";
+      const oversize = checkSupportTextLimits(
+        isAdmin ? [
+          // Admin notes land in the triage_notes column (12k budget).
+          { field: notes !== void 0 ? "notes" : "add_note", text: followUpNote, limit: SUPPORT_TRIAGE_NOTES_MAX },
+          { field: "add_evidence", text: add_evidence, limit: SUPPORT_EVIDENCE_MAX },
+          { field: "reopen_reason", text: reopen ? reopen_reason : void 0, limit: SUPPORT_REOPEN_REASON_MAX },
+          // Evidence and reopen reason share ONE progress note upstream, so
+          // both fitting individually is not enough.
+          ...add_evidence && reopen ? [{ field: "add_evidence + reopen_reason (one progress note)", text: adminProgressNote, limit: SUPPORT_PROGRESS_NOTE_MAX }] : []
+        ] : [
+          { field: notes !== void 0 ? "notes" : "add_note", text: followUpNote, limit: SUPPORT_PROGRESS_NOTE_MAX },
+          { field: "add_evidence", text: add_evidence, limit: SUPPORT_EVIDENCE_MAX },
+          { field: "reopen_reason", text: reopen ? reopen_reason : void 0, limit: SUPPORT_REOPEN_REASON_MAX }
+        ]
+      );
+      if (oversize.length > 0) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: describeOversizeRefusal(oversize) }]
+        };
+      }
+      const attestsByIdentity = verification.verification_kind === "manual" || verification.verification_kind === "ops_transcript" || verification.disposition !== void 0 && verification.disposition !== "fixed";
+      let resolvedVerification = resolveVerificationArtifact(gatedStatus, verification);
+      if (resolvedVerification.ok && isVerifiedStatus(gatedStatus) && attestsByIdentity) {
+        const authorIdentities = await collectBugAuthorIdentities(id);
+        resolvedVerification = resolveVerificationArtifact(gatedStatus, verification, { authorIdentities });
+        if (!resolvedVerification.ok) {
+          const namedAuthors = authorIdentities.filter((a) => typeof a === "string" && a.trim().length > 0).map((a) => a.trim());
+          const authorNote = resolvedVerification.message.includes("manual_verifier_is_author") && namedAuthors.length > 0 ? `
+This record's author/assignee identities: ${namedAuthors.join(", ")}. Name a DIFFERENT person or employee as the verifier \u2014 a manual close attested by its own author is exactly what the gate exists to refuse, locally and server-side.` : "";
+          return { isError: true, content: [{ type: "text", text: resolvedVerification.message + authorNote }] };
+        }
+      }
+      if (!resolvedVerification.ok) {
+        return { isError: true, content: [{ type: "text", text: resolvedVerification.message }] };
+      }
+      const attribution = assertVerdictAttribution(gatedStatus, resolvedVerification);
+      if (!attribution.ok) {
+        return { isError: true, content: [{ type: "text", text: attribution.message }] };
+      }
+      const resolvedDelivery = parseDeliveryProof(verification.delivery_proof);
+      if (!resolvedDelivery.ok) {
+        return { isError: true, content: [{ type: "text", text: resolvedDelivery.message }] };
+      }
+      const resolved = await findReportFile(id);
+      const localFile = resolved?.filePath ?? null;
+      if (UUID_RE.test(id.trim().toLowerCase())) {
+        const requested = id.trim().toLowerCase();
+        if (resolved && resolved.fullId.toLowerCase() !== requested) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Refused: local bug report mismatch.
+Requested id: ${id}
+Resolved report id: ${resolved.fullId}
+These do not match \u2014 not updating to avoid mutating the wrong bug. Verify the bug id and the local bug-reports/ files.`
+              }
+            ]
+          };
+        }
+      }
+      const fullId = resolved?.fullId ?? id;
+      let localTitle = "Unknown bug";
+      let updateBlock = null;
+      if (localFile) {
+        try {
+          const built = await buildUpdateSection(localFile, {
+            status: effectiveStatus,
+            notes: followUpNote,
+            fixVersion: fix_version,
+            evidence: add_evidence,
+            reopen
+          });
+          localTitle = built.title;
+          updateBlock = built.updateBlock;
+        } catch {
+        }
+      }
+      const changeParts = [];
+      if (reopen) changeParts.push("reopen requested");
+      else if (status) changeParts.push(`marked ${status}`);
+      if (fix_version) changeParts.push(`fix v ${fix_version}`);
+      if (product) changeParts.push(`product \u2192 ${product}`);
+      if (add_evidence) changeParts.push("evidence added");
+      if (followUpNote && !reopen && !status) changeParts.push("note added");
+      const change = changeParts.length > 0 ? changeParts.join(", ") : "updated";
+      const memoryText = `Bug "${localTitle}" (${fullId.slice(0, 8)}) ${change}` + (reopen_reason ? `. Reopen reason: ${reopen_reason}` : "") + (followUpNote ? `. Notes: ${followUpNote}` : "");
+      const payload = {
+        // Body belt (round 9): even past ingress validation, sanitize the id so a
+        // value from a non-schema caller can't put a raw id in the JSON body.
+        id: sanitizeUpstreamId(fullId),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        agent_id: agentId
+      };
+      if (isAdmin) {
+        if (wireStatus) payload.status = wireStatus;
+        const safeFixVersion = sanitizeVersionField(fix_version);
+        if (safeFixVersion) {
+          payload.fixed_version = safeFixVersion;
+          payload.fix_version = safeFixVersion;
+        }
+        const safeProduct = sanitizeProductFilter(product);
+        if (safeProduct) payload.product = safeProduct;
+        if (followUpNote) payload.triage_notes = followUpNote;
+        if (adminProgressNote) payload.add_note = adminProgressNote;
+        if (resolvedVerification.artifact) payload.verification_artifact = resolvedVerification.artifact;
+        if (resolvedDelivery.value !== void 0) payload.delivery_proof = resolvedDelivery.value;
+        if (verification.disposition) payload.disposition = verification.disposition;
+        if (verification.disposition_reason) payload.disposition_reason = verification.disposition_reason;
+        if (verification.superseded_by) payload.superseded_by = verification.superseded_by;
+        if (verification.disposition_verifier) payload.disposition_verifier = verification.disposition_verifier;
+        if (verification.superseded_coverage) payload.superseded_coverage = verification.superseded_coverage;
+        if (verification.symptoms) payload.symptoms = verification.symptoms;
+        if (resolvedVerification.attribution) payload.attribution = resolvedVerification.attribution;
+      } else {
+        if (followUpNote) payload.add_note = followUpNote;
+        if (add_evidence) payload.add_evidence = add_evidence;
+        if (reopen) {
+          payload.reopen_request = true;
+          if (reopen_reason) payload.reopen_reason = reopen_reason;
+        }
+      }
+      const actionableFields = Object.keys(payload).filter((k) => !UPSTREAM_BOOKKEEPING_FIELDS.has(k));
+      if (send_upstream && actionableFields.length === 0) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: describeEmptyUpstreamPayload(isAdmin) }]
+        };
+      }
+      const memoryId = `${fullId}-update-${Date.now()}`;
+      await persistSupportArtifact({
+        memoryText,
+        file: localFile && updateBlock !== null ? { path: localFile, content: updateBlock, append: true } : void 0,
+        memory: {
+          id: memoryId,
+          agent_id: agentId,
+          agent_role: agentRole,
+          session_id: process.env.SESSION_ID ?? "manual",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "update_bug_report",
+          project_name: "support",
+          has_error: false,
+          source_path: localFile ?? null,
+          source_type: "bug_report",
+          memory_type: "bug_report",
+          tier: 1,
+          importance: status === "fixed" || status === "closed" ? 8 : 6,
+          intent: "update",
+          domain: "support",
+          file_paths: null
+        }
+      });
+      const upstreamStatus = send_upstream ? await sendUpstream(payload, isAdmin) : "skipped";
+      const upstreamFailed = send_upstream && upstreamStatus.startsWith("failed:");
+      const queuedId = sanitizeUpstreamId(fullId);
+      const queuedPath = upstreamFailed ? queueSupportStatusUpdateSync({
+        id: queuedId,
+        kind: "bug",
+        endpointPath: ["bug-reports", queuedId].join("/"),
+        method: "PATCH",
+        payload,
+        lastError: upstreamStatus
+      }) : void 0;
+      if (upstreamFailed) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Bug report update failed upstream.
+ID: ${fullId}
+` + (status && isAdmin ? `Requested status: ${status}
+` : "") + (reopen ? `Reopen requested: yes
+` : "") + (fix_version && isAdmin ? `Fix version: ${fix_version}
+` : "") + (product && isAdmin ? `Product: ${product}
+` : "") + (add_evidence ? `Evidence: added
+` : "") + (followUpNote ? `Note: added
+` : "") + `Mode: ${isAdmin ? "admin" : "owner"}
+Local file: ${localFile ?? "not found"}
+Memory stored: ${memoryId}
+Upstream status: ${upstreamStatus}
+Retry queued: ${queuedPath ? "yes" : "no"}`
+            }
+          ]
+        };
+      }
+      const versionOnlyStatusNotice = isAdmin && fix_version && !status ? `Status unchanged: fix version ${fix_version} was recorded, but the bug was NOT closed. Pass status: "closed" explicitly to close it.
+` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Bug report ${reopen ? "reopen requested" : "updated"}.
+ID: ${fullId}
+` + (status && isAdmin ? `New status: ${status}
+` : "") + (reopen ? `Reopen requested: yes
+` : "") + (fix_version && isAdmin ? `Fix version: ${fix_version}
+` : "") + versionOnlyStatusNotice + (product && isAdmin ? `Product: ${product}
+` : "") + (add_evidence ? `Evidence: added
+` : "") + (followUpNote ? `Note: added
+` : "") + `Mode: ${isAdmin ? "admin" : "owner"}
+Local file: ${localFile ?? "not found"}
+Memory stored: ${memoryId}
+Upstream status: ${upstreamStatus}`
+          }
+        ]
+      };
+    })
+  );
+}
+
+// src/mcp/tools/support-inbox.ts
+var DEFAULT_ENDPOINT = "https://api.askexe.com/admin/support/bug-reports";
+var DEFAULT_OWNER_ENDPOINT = "https://api.askexe.com/v1/support/bug-reports";
+var STATUS2 = z3.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+var SupportHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SupportHttpError";
+  }
+  status;
+};
+function adminToken() {
+  if (process.env.ASKEXE_SUPPORT_ADMIN_TOKEN) return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN;
+  if (process.env.EXE_SUPPORT_ADMIN_TOKEN) return process.env.EXE_SUPPORT_ADMIN_TOKEN;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return config.support?.adminToken || config.support?.admin_token;
+  } catch {
+    return void 0;
+  }
+}
+function endpoint() {
+  return (process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+}
+function ownerEndpoint() {
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  let configured;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    configured = config.support?.bugReportEndpoint;
+  } catch {
+  }
+  const base = configured || process.env.EXE_BUG_REPORT_ENDPOINT || (routerUrl ? `${routerUrl}/v1/support/bug-reports` : DEFAULT_OWNER_ENDPOINT);
+  return base.replace(/\/+$/, "");
+}
+function ownerAuthHeaders() {
+  let cloudApiKey;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    cloudApiKey = config.cloud?.apiKey;
+  } catch {
+  }
+  const licenseKey = loadLicense() || process.env.EXE_LICENSE_KEY || cloudApiKey;
+  const licenseToken = readCachedLicenseToken();
+  const headers = {};
+  if (licenseKey) {
+    headers["x-exe-license-key"] = licenseKey;
+    headers.authorization = `Bearer ${licenseKey}`;
+  }
+  if (licenseToken) headers["x-exe-license-token"] = licenseToken;
+  return headers;
+}
+function assertInternal() {
+  const token = adminToken();
+  if (!token) throw new Error("AskExe support admin token not configured");
+  return token;
+}
+async function requestJson(url, init) {
+  const token = assertInternal();
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      ...init?.headers ?? {}
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await res.text();
+  let data = text;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+  return data;
+}
+async function fetchJson(url, headers, init) {
+  const res = await fetch(url, {
+    ...init,
+    headers: { "content-type": "application/json", ...headers, ...init?.headers ?? {} },
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await res.text();
+  let data = text;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  if (!res.ok) throw new SupportHttpError(res.status, `HTTP ${res.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+  return data;
+}
+async function commentRequestJson(bugId, init) {
+  const token = adminToken();
+  if (token) {
+    const safeId2 = encodeURIComponent(sanitizeUpstreamId(bugId));
+    const bugUrl2 = `${endpoint()}/${safeId2}/comments`;
+    try {
+      return await fetchJson(bugUrl2, { authorization: `Bearer ${token}` }, init);
+    } catch (err) {
+      if (!(err instanceof SupportHttpError) || err.status !== 404) throw err;
+    }
+    const featureUrl2 = `${featureEndpoint()}/${safeId2}/comments`;
+    return fetchJson(featureUrl2, { authorization: `Bearer ${token}` }, init);
+  }
+  const ownerHeaders = ownerAuthHeaders();
+  if (!ownerHeaders.authorization && !ownerHeaders["x-exe-license-token"]) {
+    throw new Error(
+      "Not authenticated for support comments. Set a license key (`exe-os setup`), or store a support-issued token with `exe-os login --token <jwt>`, or configure an AskExe admin token (ASKEXE_SUPPORT_ADMIN_TOKEN)."
+    );
+  }
+  const safeId = encodeURIComponent(sanitizeUpstreamId(bugId));
+  const bugUrl = `${ownerEndpoint()}/${safeId}/comments`;
+  try {
+    return await fetchJson(bugUrl, ownerHeaders, init);
+  } catch (err) {
+    if (!(err instanceof SupportHttpError) || err.status !== 404) throw err;
+  }
+  const featureUrl = `${featureOwnerEndpoint()}/${safeId}/comments`;
+  return fetchJson(featureUrl, ownerHeaders, init);
+}
+function withStatusNotice(data, notice) {
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    return { ...data, status_notice: notice };
+  }
+  return { status_notice: notice, response: data };
+}
+var AUTO_PAGE_SIZE = 500;
+var AUTO_FETCH_MAX_PAGES = 40;
+async function fetchAllOrPage(baseUrl, opts) {
+  const explicitLimit = typeof opts.limit === "number";
+  const pageSize = explicitLimit ? opts.limit : AUTO_PAGE_SIZE;
+  let items = [];
+  let total;
+  let curOffset = opts.offset ?? 0;
+  let hasMore = false;
+  let nextOffset = null;
+  let hitSafetyCap = false;
+  let pages = 0;
+  do {
+    const url = new URL(baseUrl.toString());
+    url.searchParams.set("limit", String(pageSize));
+    url.searchParams.set("offset", String(curOffset));
+    const data = await requestJson(url.toString());
+    const pageItems = Array.isArray(data.items) ? data.items : [];
+    items = items.concat(pageItems);
+    total = data.total;
+    hasMore = !!data.has_more;
+    nextOffset = typeof data.next_offset === "number" ? data.next_offset : curOffset + pageItems.length;
+    curOffset = nextOffset;
+    pages++;
+    if (explicitLimit) break;
+    if (hasMore && pages >= AUTO_FETCH_MAX_PAGES) {
+      hitSafetyCap = true;
+      break;
+    }
+  } while (hasMore);
+  return {
+    items,
+    count: items.length,
+    total,
+    has_more: explicitLimit ? hasMore : hitSafetyCap,
+    next_offset: explicitLimit || hitSafetyCap ? nextOffset : null,
+    hit_safety_cap: hitSafetyCap
+  };
+}
+function computeCoverage(page, requestedOffset) {
+  const skippedBefore = requestedOffset ?? 0;
+  const totalKnown = typeof page.total === "number";
+  const complete = skippedBefore === 0 && !page.has_more && (!totalKnown || page.count === page.total);
+  const remainingAfter = totalKnown ? Math.max(page.total - skippedBefore - page.count, 0) : page.has_more ? null : 0;
+  return { complete, skippedBefore, remainingAfter };
+}
+function buildTruncationNotice(page, statusFilter, requestedOffset) {
+  const lines = [];
+  const coverage = computeCoverage(page, requestedOffset);
+  const capNote = page.hit_safety_cap ? ` [safety cap after ${AUTO_FETCH_MAX_PAGES} auto-fetched pages, not a limit you set]` : "";
+  if (coverage.complete) {
+    lines.push(
+      typeof page.total === "number" ? `Showing all ${page.count} matching result(s) (total=${page.total}).` : `Showing ${page.count} matching result(s).`
+    );
+  } else if (coverage.skippedBefore === 0) {
+    const notShownSuffix = typeof page.total === "number" ? ` OF ${page.total} \u2014 ${coverage.remainingAfter} NOT SHOWN.` : " \u2014 MORE RESULTS EXIST (exact total unknown).";
+    const nextHint = page.has_more ? ` Pass offset=${page.next_offset} for the next page.` : "";
+    lines.push(`SHOWING ${page.count}${notShownSuffix}${capNote}${nextHint}`);
+  } else {
+    const totalSuffix = typeof page.total === "number" ? ` OF ${page.total}` : " (total unknown)";
+    const afterLabel = coverage.remainingAfter === null ? "MORE RESULTS MAY EXIST" : `${coverage.remainingAfter}`;
+    const nextHint = page.has_more ? ` Pass offset=${page.next_offset} for the next page.` : "";
+    lines.push(
+      `SHOWING ${page.count}${totalSuffix} \u2014 ${coverage.skippedBefore} SKIPPED BEFORE THIS PAGE, ${afterLabel} AFTER.${capNote}${nextHint}`
+    );
+  }
+  if (statusFilter !== "all") {
+    lines.push(
+      `SCOPE: status='${statusFilter}' only \u2014 other statuses are NOT included in this count or list. Use status='all' (or count_only:true) to see totals across every status.`
+    );
+  }
+  lines.push("");
+  return lines;
+}
+async function fetchStatusCounts(baseUrl, statuses) {
+  const entries = await Promise.all(
+    statuses.map(async (s) => {
+      const url = new URL(baseUrl.toString());
+      url.searchParams.set("status", s);
+      url.searchParams.set("limit", "1");
+      url.searchParams.set("offset", "0");
+      const data = await requestJson(url.toString());
+      const n = typeof data.total === "number" ? data.total : typeof data.count === "number" ? data.count : 0;
+      return [s, n];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function formatCounts(counts, label, unresolvedKeys) {
+  const lines = [`${label} counts (per status):`, ""];
+  for (const [status, n] of Object.entries(counts)) lines.push(`  ${status}: ${n}`);
+  const unresolvedTotal = unresolvedKeys.reduce((sum, k) => sum + (counts[k] ?? 0), 0);
+  lines.push("");
+  lines.push(`  TOTAL unresolved (${unresolvedKeys.join("+")}): ${unresolvedTotal}`);
+  return lines.join("\n");
+}
+var BUG_STATUSES = ["open", "triaged", "fixed", "closed", "wontfix"];
+function registerListBugReports(server) {
+  server.registerTool(
+    "list_bug_reports",
+    {
+      title: "List Bug Reports",
+      description: "AskExe-internal only: list incoming customer bug reports from the support inbox. With no `limit`, returns the COMPLETE matching set (auto-paginated) \u2014 never a silent partial page. Pass `limit` explicitly for exactly one page (the response leads with a notice if more exist). Pass `count_only:true` for per-status totals (open/triaged/fixed/closed/wontfix) plus per-cluster totals (root-cause class) without fetching records \u2014 the cheapest way to answer 'how many bugs are open' or 'how many bugs are in this cluster'. Pass `cluster` to filter the row list to one root-cause class.",
+      inputSchema: {
+        status: z3.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
+        severity: z3.enum(["p0", "p1", "p2", "p3"]).optional(),
+        // Round 8: constrain to the known enum at the schema — a `product` filter is
+        // NOT free text, and it was sent raw as a query param.
+        product: z3.enum(SUPPORT_PRODUCTS).optional().describe("Filter by product"),
+        cluster: supportClusterSchema.optional().describe("Filter by root-cause-class cluster slug (feature d0970342)"),
+        limit: z3.number().int().min(1).max(500).optional().describe("Return exactly one page of this size. Omit to fetch the COMPLETE matching set instead of a 25-row default page."),
+        offset: z3.number().int().min(0).default(0).describe("Number of results to skip. Only meaningful together with an explicit `limit`; use next_offset from a prior response."),
+        count_only: z3.boolean().optional().describe("Skip fetching records; return counts per status AND per cluster. Cross-check: sum of open+triaged+fixed = total unresolved.")
+      }
+    },
+    async ({ status, severity, product, cluster, limit, offset, count_only }) => {
+      const safeProduct = sanitizeProductFilter(product);
+      const filteredUrl = new URL(endpoint());
+      if (severity) filteredUrl.searchParams.set("severity", severity);
+      if (safeProduct) filteredUrl.searchParams.set("product", safeProduct);
+      if (cluster) filteredUrl.searchParams.set("cluster", cluster);
+      if (count_only) {
+        let counts;
+        let by_cluster = {};
+        try {
+          const countOnlyUrl = new URL(filteredUrl.toString());
+          countOnlyUrl.searchParams.set("count_only", "1");
+          const data = await requestJson(countOnlyUrl.toString());
+          if (data.by_status) {
+            counts = Object.fromEntries(BUG_STATUSES.map((s) => [s, data.by_status[s] ?? 0]));
+            by_cluster = data.by_cluster ?? {};
+          }
+        } catch {
+        }
+        if (!counts) {
+          counts = await fetchStatusCounts(filteredUrl, BUG_STATUSES);
+        }
+        const text = formatCounts(counts, "Bug report", ["open", "triaged", "fixed"]);
+        const clusterLines = Object.keys(by_cluster).length > 0 ? "\n\nBy cluster (root-cause class):\n" + Object.entries(by_cluster).map(([c, n]) => `  ${c}: ${n}`).join("\n") : "";
+        return { content: [{ type: "text", text: text + clusterLines }], structuredContent: { counts, by_cluster } };
+      }
+      const url = new URL(filteredUrl.toString());
+      url.searchParams.set("status", status);
+      const page = await fetchAllOrPage(url, { limit, offset });
+      const notice = buildTruncationNotice(page, status, offset);
+      const body = JSON.stringify(
+        { items: page.items, count: page.count, total: page.total, has_more: page.has_more, next_offset: page.next_offset },
+        null,
+        2
+      );
+      return { content: [{ type: "text", text: notice.join("\n") + body }] };
+    }
+  );
+}
+function parseComments(row) {
+  if (!row || typeof row !== "object") return [];
+  const raw = row.progress_log;
+  if (typeof raw !== "string" || !raw.trim()) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+var LOCAL_FALLBACK_STATUSES = /* @__PURE__ */ new Set([404, 500, 502, 503, 504]);
+function upstreamMissingOrUnavailable(error) {
+  if (error instanceof SupportHttpError) return LOCAL_FALLBACK_STATUSES.has(error.status);
+  const message = error instanceof Error ? error.message : String(error);
+  const match = /^HTTP (\d{3}):/.exec(message);
+  if (match) return LOCAL_FALLBACK_STATUSES.has(Number(match[1]));
+  return !(error instanceof SupportHttpError);
+}
+async function readLocalBugReport(id) {
+  const found = await findReportFile(id);
+  if (!found) return null;
+  let markdown;
+  try {
+    markdown = await readFile2(found.filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const synced = markdown.includes(SUPPORT_REPORT_SENT_MARKER);
+  return {
+    id: found.fullId,
+    source: "local",
+    sync_state: synced ? "synced" : "never_synced",
+    upstream_reachable: false,
+    markdown
+  };
+}
+function registerGetBugReport(server) {
+  server.registerTool(
+    "get_bug_report",
+    {
+      title: "Get Bug Report",
+      description: "AskExe-internal only: fetch one customer bug report with full markdown payload and comments thread.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      let data;
+      let localOnly = false;
+      try {
+        data = await requestJson(`${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      } catch (err) {
+        if (!upstreamMissingOrUnavailable(err)) throw err;
+        const local = await readLocalBugReport(id);
+        if (!local) throw err;
+        data = local;
+        localOnly = true;
+      }
+      const comments = localOnly ? [] : parseComments(data);
+      const enriched = data && typeof data === "object" ? { ...data, comments } : { id, comments };
+      if (localOnly && enriched && typeof enriched === "object") {
+        const synced = enriched.sync_state === "synced";
+        enriched._note = synced ? "Upstream could not serve this record (not found or unreachable); returned from the local ~/.exe-os/bug-reports/ outbox. The local copy is marked upstream_sent, so this is an upstream read failure, not a lost send." : "Upstream has no record for this id (or is unreachable); returned from the local ~/.exe-os/bug-reports/ outbox. The upstream send has not succeeded yet.";
+      }
+      return { content: [{ type: "text", text: JSON.stringify(enriched, null, 2) }] };
+    }
+  );
+}
+function registerAddBugReportComment(server) {
+  server.registerTool(
+    "add_bug_report_comment",
+    {
+      title: "Add Bug Report Comment",
+      description: "AskExe-internal only: append a comment to a bug report's thread (POST /comments). Non-destructive \u2014 does not touch triage_notes or status.",
+      inputSchema: {
+        id: supportIdSchema,
+        comment: z3.string().min(1).describe("Comment text to append to the bug report thread")
+      }
+    },
+    async ({ id, comment }) => {
+      const data = await commentRequestJson(id, {
+        method: "POST",
+        body: sanitizedUpstreamBody({ comment }, "support-inbox:add_comment")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerGetBugReportComments(server) {
+  server.registerTool(
+    "get_bug_report_comments",
+    {
+      title: "Get Bug Report Comments",
+      description: "AskExe-internal only: list the comments thread on a bug report (GET /comments).",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await commentRequestJson(id);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageBugReport(server) {
+  server.registerTool(
+    "triage_bug_report",
+    {
+      title: "Triage Bug Report",
+      description: "AskExe-internal only: update bug report status and link task/commit/release metadata. Setting status=fixed or closed requires a verification artifact (verification_kind + fix_commit + either the regression-test fields or the manual verifier fields); the fix commit's diff is measured locally.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: STATUS2.optional(),
+        triage_notes: z3.string().optional(),
+        add_note: z3.string().optional().describe("Append a timestamped progress note without changing status or replacing triage_notes"),
+        linked_task_id: supportTaskIdSchema.optional(),
+        linked_commit: supportCommitSchema.optional(),
+        fixed_version: supportVersionSchema.optional(),
+        product: supportProductSchema.optional().describe("Re-label this bug's product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp"),
+        // Bug: this field was missing from the schema entirely, so a caller
+        // (e.g. support(action='triage_bug', classification=...)) had its
+        // value silently swallowed into the verification rest-spread below
+        // and NEVER reached the PATCH body — triage_bug left classification
+        // stuck at 'unclear' no matter what was passed. See test coverage in
+        // support-inbox-triage-classification.test.ts.
+        classification: z3.enum([
+          "upstream_bug",
+          "customer_customization",
+          "emergency_hotfix",
+          "unclear"
+        ]).optional().describe("Triage classification: upstream_bug, customer_customization, emergency_hotfix, unclear"),
+        cluster: supportClusterClearableSchema.optional().describe("Root-cause class this bug belongs to \u2014 a kebab-case slug (feature d0970342). Fixes are dispatched per cluster; use list_bugs(cluster=...) to find every bug sharing one. Pass an empty string to CLEAR a mis-triaged cluster back to unset."),
+        ...verificationArtifactInputSchema
+      }
+    },
+    async ({ id, status, triage_notes, add_note, linked_task_id, linked_commit, fixed_version, product, classification, cluster, ...verification }) => {
+      const bugUrl = `${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`;
+      const attestsByIdentity = verification.verification_kind === "manual" || verification.verification_kind === "ops_transcript" || verification.disposition !== void 0 && verification.disposition !== "fixed";
+      let authorIdentities = [];
+      if (isVerifiedStatus(status) && attestsByIdentity) {
+        try {
+          const row = await requestJson(bugUrl);
+          authorIdentities = [row?.agent_id, row?.license_email];
+        } catch {
+        }
+      }
+      const resolved = resolveVerificationArtifact(status, verification, { authorIdentities });
+      if (!resolved.ok) {
+        return { isError: true, content: [{ type: "text", text: resolved.message }] };
+      }
+      const attribution = assertVerdictAttribution(status, resolved);
+      if (!attribution.ok) {
+        return { isError: true, content: [{ type: "text", text: attribution.message }] };
+      }
+      const delivery = parseDeliveryProof(verification.delivery_proof);
+      if (!delivery.ok) {
+        return { isError: true, content: [{ type: "text", text: delivery.message }] };
+      }
+      const data = await requestJson(bugUrl, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({
+          status,
+          triage_notes,
+          add_note,
+          linked_task_id,
+          linked_commit,
+          fixed_version,
+          product,
+          classification,
+          cluster,
+          verification_artifact: resolved.artifact,
+          delivery_proof: delivery.value,
+          // The disposition travels with the close: the server gates on it, and stores
+          // it so the record reads as "closed because there was nothing to fix" rather
+          // than as an unexplained close.
+          disposition: verification.disposition,
+          disposition_reason: verification.disposition_reason,
+          superseded_by: verification.superseded_by,
+          disposition_verifier: verification.disposition_verifier,
+          superseded_coverage: verification.superseded_coverage,
+          symptoms: verification.symptoms,
+          attribution: resolved.attribution
+        }, "support-inbox:triage_bug")
+      });
+      const response = fixed_version && !status ? withStatusNotice(
+        data,
+        `fixed_version ${fixed_version} recorded. Status was not changed and the bug was NOT closed. To close it, pass status: "closed" explicitly.`
+      ) : data;
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+    }
+  );
+}
+var FEATURE_STATUS = z3.enum(["open", "planned", "in_progress", "shipped", "closed", "wontdo"]);
+function featureEndpoint() {
+  return endpoint().replace(/\/bug-reports\/?$/, "/feature-requests");
+}
+function featureOwnerEndpoint() {
+  return ownerEndpoint().replace(/\/bug-reports\/?$/, "/feature-requests");
+}
+var FEATURE_STATUSES = ["open", "planned", "in_progress", "shipped", "closed", "wontdo"];
+function registerListFeatureRequests(server) {
+  server.registerTool(
+    "list_feature_requests",
+    {
+      title: "List Feature Requests",
+      description: "AskExe-internal only: list incoming customer feature requests from the support inbox. With no `limit`, returns the COMPLETE matching set (auto-paginated) \u2014 never a silent partial page. Pass `limit` explicitly for exactly one page (the response leads with a notice if more exist). Pass `count_only:true` for per-status totals without fetching records.",
+      inputSchema: {
+        status: z3.enum(["all", "open", "planned", "in_progress", "shipped", "closed", "wontdo"]).default("open"),
+        priority: z3.enum(["p0", "p1", "p2", "p3"]).optional(),
+        product: z3.string().optional().describe("Filter by product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp"),
+        limit: z3.number().int().min(1).max(500).optional().describe("Return exactly one page of this size. Omit to fetch the COMPLETE matching set instead of a 25-row default page."),
+        offset: z3.number().int().min(0).default(0).describe("Number of results to skip. Only meaningful together with an explicit `limit`; use next_offset from a prior response."),
+        count_only: z3.boolean().optional().describe("Skip fetching records; return counts per status only.")
+      }
+    },
+    async ({ status, priority, product, limit, offset, count_only }) => {
+      const safeProduct = sanitizeProductFilter(product);
+      const filteredUrl = new URL(featureEndpoint());
+      if (priority) filteredUrl.searchParams.set("priority", priority);
+      if (safeProduct) filteredUrl.searchParams.set("product", safeProduct);
+      if (count_only) {
+        const counts = await fetchStatusCounts(filteredUrl, FEATURE_STATUSES);
+        const text = formatCounts(counts, "Feature request", ["open", "planned", "in_progress"]);
+        return { content: [{ type: "text", text }], structuredContent: { counts } };
+      }
+      const url = new URL(filteredUrl.toString());
+      url.searchParams.set("status", status);
+      const page = await fetchAllOrPage(url, { limit, offset });
+      const notice = buildTruncationNotice(page, status, offset);
+      const body = JSON.stringify(
+        { items: page.items, count: page.count, total: page.total, has_more: page.has_more, next_offset: page.next_offset },
+        null,
+        2
+      );
+      return { content: [{ type: "text", text: notice.join("\n") + body }] };
+    }
+  );
+}
+function registerGetFeatureRequest(server) {
+  server.registerTool(
+    "get_feature_request",
+    {
+      title: "Get Feature Request",
+      description: "AskExe-internal only: fetch one customer feature request with full payload.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await requestJson(`${featureEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageFeatureRequest(server) {
+  server.registerTool(
+    "triage_feature_request",
+    {
+      title: "Triage Feature Request",
+      description: "AskExe-internal only: update feature request status, response notes, and version metadata.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: FEATURE_STATUS.optional(),
+        response_notes: z3.string().optional(),
+        add_note: z3.string().optional().describe("Append a timestamped progress note without changing status or replacing response_notes"),
+        target_version: supportVersionSchema.optional(),
+        shipped_version: supportVersionSchema.optional(),
+        // bug b8e990ed: allow admin re-label of a feature's product. Typed with the
+        // strict product schema (round 10 ingress validation), not a loose string.
+        product: supportProductSchema.optional().describe("Re-label this feature's product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp")
+      }
+    },
+    async ({ id, status, response_notes, add_note, target_version, shipped_version, product }) => {
+      const data = await requestJson(`${featureEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({ status, response_notes, add_note, target_version, shipped_version, product }, "support-inbox:triage_feature")
+      });
+      const response = shipped_version && !status ? withStatusNotice(
+        data,
+        `shipped_version ${shipped_version} recorded. Status was not changed and the feature was NOT marked shipped or closed. To mark it shipped, pass status: "shipped" explicitly.`
+      ) : data;
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+    }
+  );
+}
+var REVIEW_STATUS = z3.enum(["open", "in_review", "approved", "merged", "closed", "rejected"]);
+function reviewEndpoint() {
+  return endpoint().replace(/\/bug-reports\/?$/, "/reviews");
+}
+var REVIEW_STATUSES = ["open", "in_review", "approved", "merged", "closed", "rejected"];
+function registerListReviews(server) {
+  server.registerTool(
+    "list_reviews",
+    {
+      title: "List Reviews",
+      description: "AskExe-internal only: list incoming review requests from the support inbox. With no `limit`, returns the COMPLETE matching set (auto-paginated) \u2014 never a silent partial page. Pass `limit` explicitly for exactly one page (the response leads with a notice if more exist). Pass `count_only:true` for per-status totals without fetching records.",
+      inputSchema: {
+        status: z3.enum(["all", "open", "in_review", "approved", "merged", "closed", "rejected"]).default("open"),
+        priority: z3.enum(["p0", "p1", "p2", "p3"]).optional(),
+        limit: z3.number().int().min(1).max(500).optional().describe("Return exactly one page of this size. Omit to fetch the COMPLETE matching set instead of a 25-row default page."),
+        offset: z3.number().int().min(0).default(0).describe("Number of results to skip. Only meaningful together with an explicit `limit`; use next_offset from a prior response."),
+        count_only: z3.boolean().optional().describe("Skip fetching records; return counts per status only.")
+      }
+    },
+    async ({ status, priority, limit, offset, count_only }) => {
+      const filteredUrl = new URL(reviewEndpoint());
+      if (priority) filteredUrl.searchParams.set("priority", priority);
+      if (count_only) {
+        const counts = await fetchStatusCounts(filteredUrl, REVIEW_STATUSES);
+        const text = formatCounts(counts, "Review", ["open", "in_review"]);
+        return { content: [{ type: "text", text }], structuredContent: { counts } };
+      }
+      const url = new URL(filteredUrl.toString());
+      url.searchParams.set("status", status);
+      const page = await fetchAllOrPage(url, { limit, offset });
+      const notice = buildTruncationNotice(page, status, offset);
+      const body = JSON.stringify(
+        { items: page.items, count: page.count, total: page.total, has_more: page.has_more, next_offset: page.next_offset },
+        null,
+        2
+      );
+      return { content: [{ type: "text", text: notice.join("\n") + body }] };
+    }
+  );
+}
+function registerGetReview(server) {
+  server.registerTool(
+    "get_review",
+    {
+      title: "Get Review",
+      description: "AskExe-internal only: fetch one review with full payload.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await requestJson(`${reviewEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageReview(server) {
+  server.registerTool(
+    "triage_review",
+    {
+      title: "Triage Review",
+      description: "AskExe-internal only: update review status, response notes, and resolution.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: REVIEW_STATUS.optional(),
+        response_notes: z3.string().optional(),
+        add_note: z3.string().optional().describe("Append a timestamped progress note without changing status or replacing response_notes"),
+        resolution: z3.string().optional(),
+        pr_url: z3.string().optional()
+      }
+    },
+    async ({ id, status, response_notes, add_note, resolution, pr_url }) => {
+      const data = await requestJson(`${reviewEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({ status, response_notes, add_note, resolution, pr_url }, "support-inbox:triage_review")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+
+export {
+  resolveAttribution,
+  verificationArtifactInputSchema,
+  registerUpdateBugReport,
+  registerListBugReports,
+  registerGetBugReport,
+  registerAddBugReportComment,
+  registerGetBugReportComments,
+  registerTriageBugReport,
+  registerListFeatureRequests,
+  registerGetFeatureRequest,
+  registerTriageFeatureRequest,
+  registerListReviews,
+  registerGetReview,
+  registerTriageReview
+};