@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/{chunk-QMSEL5YS.js → chunk-ZIG7VPJV.js}

@@ -4,6 +4,9 @@ import {
   atomicWriteJsonSync,
   ensurePrivateDir
 } from "./chunk-HSGBZSCA.js";
+import {
+  assertHermeticPath
+} from "./chunk-RH4AH3YB.js";
 import {
   currentKeyDirContext,
   refusedQuarantineDir,
@@ -13,61 +16,8 @@ import {
 // src/lib/config.ts
 import { readFile } from "fs/promises";
 import { readFileSync, existsSync, renameSync } from "fs";
-import path2 from "path";
-import os2 from "os";
-
-// src/lib/hermetic-guard.ts
-import { realpathSync } from "fs";
-import os from "os";
 import path from "path";
-var SHARED_TMP_BASES = ["/tmp", os.tmpdir()];
-function isHermeticTestEnv() {
-  return process.env.EXE_TEST_HERMETIC === "1";
-}
-function harnessRealHome() {
-  const v = process.env.EXE_HERMETIC_REAL_HOME ?? process.env.EXE_REAL_HOME;
-  return v && v.trim() ? v : null;
-}
-function harnessSandboxRoot() {
-  const v = process.env.EXE_HERMETIC_SANDBOX_ROOT;
-  return v && v.trim() ? v : null;
-}
-function canonical(p) {
-  let dir = path.resolve(p);
-  const tail = [];
-  for (; ; ) {
-    try {
-      return path.join(realpathSync(dir), ...tail);
-    } catch {
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) return path.resolve(p);
-    tail.unshift(path.basename(dir));
-    dir = parent;
-  }
-}
-function isInside(candidate, base) {
-  const rel = path.relative(canonical(base), canonical(candidate));
-  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
-}
-function realInstallDirs(realHome) {
-  return [path.join(realHome, ".exe-os"), path.join(realHome, ".exe-mem")];
-}
-function assertHermeticPath(what, resolved) {
-  if (!isHermeticTestEnv()) return;
-  const realHome = harnessRealHome();
-  if (!realHome) return;
-  const sandboxRoot = harnessSandboxRoot();
-  if (sandboxRoot && isInside(resolved, sandboxRoot)) return;
-  const breached = realInstallDirs(realHome).find((dir) => isInside(resolved, dir));
-  if (!breached) return;
-  throw new Error(
-    `[hermetic-guard] Test isolation breach: ${what} resolved to ${resolved}, which is the REAL exe-os install at ${breached}.
-  This process runs under the hermetic test harness (EXE_TEST_HERMETIC=1) but is operating on the LIVE install. Real product code reached from here can and does kill the production daemon (bug 2b7072a7 / 7a915790).
-  Cause is almost always a spawn that overrode the sandbox: an explicit env: {...} that dropped EXE_OS_DIR/EXE_MEM_DIR, or HOME: os.homedir() captured outside the sandbox.
-  Fix: inherit ...process.env, or use the hermetic HOME (process.env.HOME), never os.homedir().`
-  );
-}
+import os from "os";
 
 // src/lib/theme.ts
 var THEME_MODES = ["dark", "light", "system"];
@@ -151,7 +101,7 @@ function resolveDataDir() {
     return dir;
   }
   if (!existsSync(dir)) {
-    const legacyDir = path2.join(path2.dirname(dir), ".exe-mem");
+    const legacyDir = path.join(path.dirname(dir), ".exe-mem");
     if (existsSync(legacyDir)) {
       try {
         renameSync(legacyDir, dir);
@@ -166,9 +116,9 @@ function resolveDataDir() {
   return dir;
 }
 var EXE_AI_DIR = resolveDataDir();
-var DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
-var MODELS_DIR = path2.join(EXE_AI_DIR, "models");
-var CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
 var CANONICAL_EMBED_MODEL_FILE = "exe-embeddings-v1-q4_k_m.gguf";
 var LEGACY_EMBED_MODEL_FILES = [
   "jina-embeddings-v5-small-q4_k_m.gguf",
@@ -178,14 +128,14 @@ var LEGACY_EMBED_MODEL_FILES = [
 function resolveEmbedModelFile(dir = MODELS_DIR, preferred = CANONICAL_EMBED_MODEL_FILE) {
   const candidates = [preferred, CANONICAL_EMBED_MODEL_FILE, ...LEGACY_EMBED_MODEL_FILES];
   for (const name of candidates) {
-    if (name && existsSync(path2.join(dir, name))) return name;
+    if (name && existsSync(path.join(dir, name))) return name;
   }
   return preferred || CANONICAL_EMBED_MODEL_FILE;
 }
 function isDbAuthorityEnabled() {
   return (process.env.EXE_DB_AUTHORITY ?? "") === "1";
 }
-var LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
 var CURRENT_CONFIG_VERSION = 1;
 var DEFAULT_CONFIG = {
   config_version: CURRENT_CONFIG_VERSION,
@@ -223,6 +173,8 @@ var DEFAULT_CONFIG = {
   consolidationMaxCallsPerRun: 20,
   selfQueryRouter: true,
   selfQueryModel: "claude-haiku-4-5-20251001",
+  hyde: false,
+  hydeModel: "claude-haiku-4-5-20251001",
   rerankerEnabled: true,
   scalingRoadmap: {
     rerankerAutoTrigger: {
@@ -428,7 +380,7 @@ function normalizeCloudEndpoint(raw) {
   }
   try {
     const cfgDir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-    const cfgPath = path2.join(cfgDir, "config.json");
+    const cfgPath = path.join(cfgDir, "config.json");
     if (existsSync(cfgPath)) {
       const onDisk = JSON.parse(readFileSync(cfgPath, "utf8"));
       const diskCloud = onDisk.cloud;
@@ -443,9 +395,9 @@ function normalizeCloudEndpoint(raw) {
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await ensurePrivateDir(dir);
-  const configPath = path2.join(dir, "config.json");
+  const configPath = path.join(dir, "config.json");
   if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   let raw;
   try {
@@ -461,11 +413,11 @@ async function loadConfig() {
         await atomicWrite(configPath, raw);
       } catch {
         process.stderr.write("[exe-os] config.json.bak also corrupt \u2014 using defaults\n");
-        return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+        return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
       }
     } else {
       process.stderr.write("[exe-os] config.json corrupt, no backup available \u2014 using defaults\n");
-      return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+      return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
     }
   }
   try {
@@ -491,24 +443,24 @@ async function loadConfig() {
     normalizeEmbeddingPrefixes(migratedCfg);
     normalizeAppearance(migratedCfg);
     normalizeCloudEndpoint(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
     }
-    const envDbPath = path2.join(dir, "memories.db");
+    const envDbPath = path.join(dir, "memories.db");
     if (process.env.EXE_OS_DIR && config.dbPath !== envDbPath && !existsSync(config.dbPath) && existsSync(envDbPath)) {
       config.dbPath = envDbPath;
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
 }
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path2.join(dir, "config.json");
+  const configPath = path.join(dir, "config.json");
   if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   try {
     const raw = readFileSync(configPath, "utf-8");
@@ -526,23 +478,23 @@ function loadConfigSync() {
     normalizeEmbeddingPrefixes(migratedCfg);
     normalizeAppearance(migratedCfg);
     normalizeCloudEndpoint(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
     }
-    const envDbPath = path2.join(dir, "memories.db");
+    const envDbPath = path.join(dir, "memories.db");
     if (process.env.EXE_OS_DIR && config.dbPath !== envDbPath && !existsSync(config.dbPath) && existsSync(envDbPath)) {
       config.dbPath = envDbPath;
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
 }
 async function saveConfig(config) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await ensurePrivateDir(dir);
-  const configPath = path2.join(dir, "config.json");
+  const configPath = path.join(dir, "config.json");
   await atomicWriteJson(configPath, config);
 }
 async function loadConfigFrom(configPath) {

package/dist/{chunk-WZJVGA5I.js → chunk-ZL4AGWAH.js}

@@ -6,8 +6,15 @@ import {
   supportVersionSchema
 } from "./chunk-5H47VHB7.js";
 import {
-  buildVerificationArtifact
-} from "./chunk-KZXMP6JG.js";
+  assessAttribution,
+  assessDisposition,
+  buildVerificationArtifact,
+  isPlaceholderIdentity,
+  isUnresolvedIdentity
+} from "./chunk-4YNA3CM6.js";
+import {
+  getActiveAgent
+} from "./chunk-55BEFF4V.js";
 import {
   SUPPORT_PRODUCTS,
   sanitizeProductFilter,
@@ -17,7 +24,7 @@ import {
 import {
   loadLicense,
   readCachedLicenseToken
-} from "./chunk-DKBPCOU4.js";
+} from "./chunk-L6RXG36J.js";
 
 // src/mcp/tools/support-inbox.ts
 import { z as z2 } from "zod";
@@ -27,23 +34,183 @@ 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"]).optional().describe(
-    "REQUIRED to set status=fixed or closed. '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."
+  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 only: 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."),
+  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.",
   "",
@@ -58,33 +225,94 @@ var NO_ARTIFACT_HELP = [
   "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 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 or manual) when setting status=fixed or closed." };
+    return { ok: false, message: "verification_kind is required (regression_test, manual or ops_transcript) when setting status=fixed or closed." };
   }
-  if (!input.fix_commit) {
+  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." };
   }
+  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,
+    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
+    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}` };
   }
-  return { ok: true, artifact: built.artifact };
+  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 };
@@ -336,8 +564,9 @@ function registerTriageBugReport(server) {
     },
     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) && verification.verification_kind === "manual") {
+      if (isVerifiedStatus(status) && attestsByIdentity) {
         try {
           const row = await requestJson(bugUrl);
           authorIdentities = [row?.agent_id, row?.license_email];
@@ -348,6 +577,10 @@ function registerTriageBugReport(server) {
       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 }] };
@@ -363,7 +596,17 @@ function registerTriageBugReport(server) {
           fixed_version,
           product,
           verification_artifact: resolved.artifact,
-          delivery_proof: delivery.value
+          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(
@@ -521,7 +764,9 @@ function registerTriageReview(server) {
 }
 
 export {
+  resolveAttribution,
   verificationArtifactInputSchema,
+  assertVerdictAttribution,
   resolveVerificationArtifact,
   parseDeliveryProof,
   registerListBugReports,

package/dist/{chunk-QR624DER.js → chunk-ZSODLMFV.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/worker-gate.ts
 import { readdirSync, writeFileSync, unlinkSync, mkdirSync, existsSync, readFileSync } from "fs";
@@ -119,7 +119,7 @@ function releaseBackfillLock() {
 }
 async function getTaskAwareCapacity() {
   const { getClient } = await import("./lib/database.js");
-  const { sessionScopeFilter } = await import("./task-scope-KXF7Y6KA.js");
+  const { sessionScopeFilter } = await import("./task-scope-ERVEUEYU.js");
   const client = getClient();
   const scope = sessionScopeFilter();
   const result = await client.execute({

package/dist/{cleanup-graph-garbage-IPYDS5OX.js → cleanup-graph-garbage-DPJGO52H.js}

@@ -1,34 +1,35 @@
 #!/usr/bin/env node
-import "./chunk-RIK5GRWI.js";
+import "./chunk-LGS2V2XD.js";
 import {
   isGarbageEntity
-} from "./chunk-ZYCLSEZT.js";
-import "./chunk-Z6BZQHP5.js";
+} from "./chunk-ULIBLJ6W.js";
 import "./chunk-GUMRIUI5.js";
+import "./chunk-Z6BZQHP5.js";
 import "./chunk-VGMACSEV.js";
-import "./chunk-7UTJA6HF.js";
+import "./chunk-VZAFWPAY.js";
 import "./chunk-CHCA3ZM2.js";
-import "./chunk-3F2UB4IQ.js";
+import "./chunk-DN4YVV4Z.js";
 import {
   fastDbInit
-} from "./chunk-HR2R2QER.js";
+} from "./chunk-M4IRPXSZ.js";
 import "./chunk-5MOYSU5A.js";
 import "./chunk-4QCFFW2H.js";
 import "./chunk-76CJBM36.js";
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
-import "./chunk-TKDITWDN.js";
+} from "./chunk-TAMDAOCU.js";
 import "./chunk-BBMTVAE3.js";
+import "./chunk-TKDITWDN.js";
 import "./chunk-5YEUPUV4.js";
-import "./chunk-UTDMTQNH.js";
+import "./chunk-DSJI76XL.js";
 import "./chunk-YYB5PMTK.js";
 import "./chunk-NJFJWQNN.js";
 import "./chunk-V3W3SATA.js";
 import "./chunk-JY5GAZYC.js";
 import "./chunk-FXU7JOXK.js";
-import "./chunk-QMSEL5YS.js";
+import "./chunk-ZIG7VPJV.js";
 import "./chunk-HSGBZSCA.js";
+import "./chunk-RH4AH3YB.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{cloud-sync-command-JLNVG7H4.js → cloud-sync-command-JPNTT4OQ.js}

@@ -23,7 +23,7 @@ async function runCloudSyncCli() {
   const { getMasterKey } = await import("./lib/keychain.js");
   const { initSyncCrypto } = await import("./lib/crypto.js");
   const { assertCloudSyncReachable, withTimeout } = await import("./bin/exe-cloud.js");
-  const { runCloudSyncShutdown } = await import("./cloud-sync-shutdown-Z4SBP6PL.js");
+  const { runCloudSyncShutdown } = await import("./cloud-sync-shutdown-BNALPWGX.js");
   const { disconnectClient } = await import("./lib/exe-daemon-client.js");
   let shuttingDown = false;
   const handleShutdown = (signal) => {
@@ -48,7 +48,7 @@ async function runCloudSyncCli() {
         const { initPostgresOnlyDatabase } = await import("./lib/database.js");
         await initPostgresOnlyDatabase();
       } else {
-        const { initCloudSyncDatabase } = await import("./cloud-sync-db-init-JXUF6GI3.js");
+        const { initCloudSyncDatabase } = await import("./cloud-sync-db-init-V2LWIUQU.js");
         await initCloudSyncDatabase();
       }
       const masterKey = await getMasterKey();