@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/chunk-QFAFKEB5.js

@@ -1,820 +0,0 @@
-import {
-  supportCommitSchema,
-  supportIdSchema,
-  supportProductSchema,
-  supportTaskIdSchema,
-  supportVersionSchema
-} from "./chunk-3B6FLNLV.js";
-import {
-  assessAttribution,
-  assessDisposition,
-  buildVerificationArtifact,
-  isPlaceholderIdentity,
-  isUnresolvedIdentity
-} from "./chunk-4YNA3CM6.js";
-import {
-  getActiveAgent
-} from "./chunk-F4BBMIPG.js";
-import {
-  SUPPORT_PRODUCTS,
-  sanitizeProductFilter,
-  sanitizeUpstreamId,
-  sanitizedUpstreamBody
-} from "./chunk-ELEGH4DX.js";
-import {
-  loadLicense,
-  readCachedLicenseToken
-} from "./chunk-TNS63ATU.js";
-
-// src/mcp/tools/support-inbox.ts
-import { z as z2 } from "zod";
-import { readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-// 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 \u2014 a comment-only or test-only commit is refused."),
-  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: how it was verified, in enough detail for someone else to repeat it."),
-  verification_observation: z.string().optional().describe("manual only: what was observed that shows the DEFECT IS ABSENT \u2014 not what the change did. 'It is fixed' is refused."),
-  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). 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).",
-  "",
-  "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/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 STATUS = z2.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 };
-}
-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.",
-      inputSchema: {
-        status: z2.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
-        severity: z2.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: z2.enum(SUPPORT_PRODUCTS).optional().describe("Filter by product"),
-        limit: z2.number().int().min(1).max(500).default(25),
-        offset: z2.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
-      }
-    },
-    async ({ status, severity, product, limit, offset }) => {
-      const url = new URL(endpoint());
-      url.searchParams.set("status", status);
-      url.searchParams.set("limit", String(limit));
-      url.searchParams.set("offset", String(offset));
-      if (severity) url.searchParams.set("severity", severity);
-      const safeProduct = sanitizeProductFilter(product);
-      if (safeProduct) url.searchParams.set("product", safeProduct);
-      const data = await requestJson(url.toString());
-      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-    }
-  );
-}
-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 [];
-  }
-}
-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 }) => {
-      const data = await requestJson(`${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
-      const comments = parseComments(data);
-      const enriched = data && typeof data === "object" ? { ...data, comments } : { id, comments };
-      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: z2.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: STATUS.optional(),
-        triage_notes: z2.string().optional(),
-        add_note: z2.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"),
-        ...verificationArtifactInputSchema
-      }
-    },
-    async ({ id, status, triage_notes, add_note, linked_task_id, linked_commit, fixed_version, product, ...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,
-          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 = z2.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");
-}
-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.",
-      inputSchema: {
-        status: z2.enum(["all", "open", "planned", "in_progress", "shipped", "closed", "wontdo"]).default("open"),
-        priority: z2.enum(["p0", "p1", "p2", "p3"]).optional(),
-        product: z2.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: z2.number().int().min(1).max(500).default(25),
-        offset: z2.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
-      }
-    },
-    async ({ status, priority, product, limit, offset }) => {
-      const url = new URL(featureEndpoint());
-      url.searchParams.set("status", status);
-      url.searchParams.set("limit", String(limit));
-      url.searchParams.set("offset", String(offset));
-      if (priority) url.searchParams.set("priority", priority);
-      const safeProduct = sanitizeProductFilter(product);
-      if (safeProduct) url.searchParams.set("product", safeProduct);
-      const data = await requestJson(url.toString());
-      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-    }
-  );
-}
-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: z2.string().optional(),
-        add_note: z2.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 = z2.enum(["open", "in_review", "approved", "merged", "closed", "rejected"]);
-function reviewEndpoint() {
-  return endpoint().replace(/\/bug-reports\/?$/, "/reviews");
-}
-function registerListReviews(server) {
-  server.registerTool(
-    "list_reviews",
-    {
-      title: "List Reviews",
-      description: "AskExe-internal only: list incoming review requests from the support inbox.",
-      inputSchema: {
-        status: z2.enum(["all", "open", "in_review", "approved", "merged", "closed", "rejected"]).default("open"),
-        priority: z2.enum(["p0", "p1", "p2", "p3"]).optional(),
-        limit: z2.number().int().min(1).max(500).default(25),
-        offset: z2.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
-      }
-    },
-    async ({ status, priority, limit, offset }) => {
-      const url = new URL(reviewEndpoint());
-      url.searchParams.set("status", status);
-      url.searchParams.set("limit", String(limit));
-      url.searchParams.set("offset", String(offset));
-      if (priority) url.searchParams.set("priority", priority);
-      const data = await requestJson(url.toString());
-      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-    }
-  );
-}
-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: z2.string().optional(),
-        add_note: z2.string().optional().describe("Append a timestamped progress note without changing status or replacing response_notes"),
-        resolution: z2.string().optional(),
-        pr_url: z2.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,
-  isVerifiedStatus,
-  verificationArtifactInputSchema,
-  assertVerdictAttribution,
-  resolveVerificationArtifact,
-  parseDeliveryProof,
-  registerListBugReports,
-  registerGetBugReport,
-  registerAddBugReportComment,
-  registerGetBugReportComments,
-  registerTriageBugReport,
-  registerListFeatureRequests,
-  registerGetFeatureRequest,
-  registerTriageFeatureRequest,
-  registerListReviews,
-  registerGetReview,
-  registerTriageReview
-};