mason-context 0.17.2 → 0.17.3

package/dist/mason-mcp.js

@@ -9,6 +9,28 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/profile.ts
+import { AsyncLocalStorage } from "async_hooks";
+async function profilePhase(label, run) {
+  const phases = profiles.getStore();
+  if (!phases) return run();
+  const start = performance.now();
+  try {
+    return await run();
+  } finally {
+    const timing = phases[label] ??= { calls: 0, totalMs: 0 };
+    timing.calls++;
+    timing.totalMs += performance.now() - start;
+  }
+}
+var profiles;
+var init_profile = __esm({
+  "src/utils/profile.ts"() {
+    "use strict";
+    profiles = new AsyncLocalStorage();
+  }
+});
+
 // src/audit/commands.ts
 import path from "path";
 function splitCommands(line) {
@@ -854,16 +876,27 @@ import path6 from "path";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 import fg3 from "fast-glob";
-async function isDirty(resolvedRoot, relPath) {
+async function dirtyDocs(resolvedRoot, files) {
+  if (!files.length) return /* @__PURE__ */ new Set();
   try {
-    const { stdout } = await exec3(
-      "git",
-      ["status", "--porcelain", "--", `:(literal)${relPath}`],
-      { cwd: resolvedRoot }
-    );
-    return stdout.trim().length > 0;
+    const dirty = /* @__PURE__ */ new Set();
+    for (let offset = 0; offset < files.length; offset += 256) {
+      const { stdout } = await exec3(
+        "git",
+        ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...files.slice(offset, offset + 256).map((file) => `:(literal)${file}`)],
+        { cwd: resolvedRoot, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 }
+      );
+      const entries = stdout.split("\0");
+      for (let i = 0; i < entries.length; i++) {
+        if (!entries[i]) continue;
+        const status = entries[i].slice(0, 2);
+        dirty.add(entries[i].slice(3));
+        if (/[RC]/.test(status) && entries[i + 1]) dirty.add(entries[++i]);
+      }
+    }
+    return dirty;
   } catch {
-    return true;
+    return new Set(files);
   }
 }
 async function discoverDocPaths(root) {
@@ -944,21 +977,30 @@ function documentScope(file) {
   return path6.posix.basename(parent).toLowerCase() === ".claude" ? path6.posix.dirname(parent) : parent;
 }
 async function discoverDocs(resolvedRoot) {
+  return profilePhase("audit.documents", () => readDocs(resolvedRoot));
+}
+async function readDocs(resolvedRoot) {
   const docs = [];
-  for (const candidate of await discoverDocPaths(resolvedRoot)) {
-    const content2 = await readAuditInput(resolvedRoot, candidate);
-    if (content2 === null) throw new Error("Document disappeared during discovery: " + candidate);
-    const [lastCommit, dirty] = await Promise.all([lastCommitOf(resolvedRoot, candidate), isDirty(resolvedRoot, candidate)]);
-    docs.push({
-      path: candidate,
-      content: content2,
-      scope: documentScope(candidate),
-      kind: /^readme\.md$/i.test(path6.posix.basename(candidate)) ? "readme" : "instructions",
-      lineCount: content2.split("\n").length,
-      lastCommit,
-      dirty,
-      claims: extractClaims(content2)
-    });
+  const files = await discoverDocPaths(resolvedRoot);
+  const dirty = await dirtyDocs(resolvedRoot, files);
+  for (let offset = 0; offset < files.length; offset += 4) {
+    docs.push(...await Promise.all(files.slice(offset, offset + 4).map(async (candidate) => {
+      const [content2, lastCommit] = await Promise.all([
+        readAuditInput(resolvedRoot, candidate),
+        profilePhase("audit.document-history", () => lastCommitOf(resolvedRoot, candidate))
+      ]);
+      if (content2 === null) throw new Error("Document disappeared during discovery: " + candidate);
+      return {
+        path: candidate,
+        content: content2,
+        scope: documentScope(candidate),
+        kind: /^readme\.md$/i.test(path6.posix.basename(candidate)) ? "readme" : "instructions",
+        lineCount: content2.split("\n").length,
+        lastCommit,
+        dirty: dirty.has(candidate),
+        claims: extractClaims(content2)
+      };
+    })));
   }
   return docs;
 }
@@ -966,6 +1008,7 @@ var exec3, DOC_CANDIDATES;
 var init_docs = __esm({
   "src/audit/docs.ts"() {
     "use strict";
+    init_profile();
     init_claims();
     init_git();
     init_inputs();
@@ -3180,6 +3223,9 @@ var init_advisory_review = __esm({
 import fs11 from "fs/promises";
 import path18 from "path";
 async function computeAudit(rootDir, options = {}) {
+  return profilePhase("audit.current", () => auditCurrent(rootDir, options));
+}
+async function auditCurrent(rootDir, options) {
   const resolvedRoot = path18.resolve(rootDir);
   const [docs, headHash] = await Promise.all([discoverDocs(resolvedRoot), getCurrentGitHash(resolvedRoot)]);
   if (docs.length === 0) return null;
@@ -3206,11 +3252,11 @@ async function computeAudit(rootDir, options = {}) {
   };
   if (!report.gitAvailable) return report;
   const changesSinceDoc = /* @__PURE__ */ new Map();
+  const changesByCommit = /* @__PURE__ */ new Map();
   for (const doc of docs) {
-    changesSinceDoc.set(
-      doc.path,
-      doc.lastCommit ? await getChangesWithStatus(resolvedRoot, doc.lastCommit.hash) : null
-    );
+    const hash2 = doc.lastCommit?.hash;
+    if (hash2 && !changesByCommit.has(hash2)) changesByCommit.set(hash2, await getChangesWithStatus(resolvedRoot, hash2));
+    changesSinceDoc.set(doc.path, hash2 ? changesByCommit.get(hash2) : null);
   }
   let decisionsPresent = false;
   try {
@@ -3244,6 +3290,7 @@ async function computeAudit(rootDir, options = {}) {
 var init_audit = __esm({
   "src/audit/audit.ts"() {
     "use strict";
+    init_profile();
     init_drift();
     init_snapshot();
     init_docs();
@@ -3263,7 +3310,9 @@ __export(repair_exports, {
   prepareRepair: () => prepareRepair,
   repairExitCode: () => repairExitCode,
   repairFindingSchema: () => repairFindingSchema,
-  verifyRepair: () => verifyRepair
+  reportSchema: () => reportSchema,
+  verifyRepair: () => verifyRepair,
+  withRepairSession: () => withRepairSession
 });
 import fs12 from "fs/promises";
 import path19 from "path";
@@ -3290,6 +3339,9 @@ async function docState(root) {
   return digest(docs);
 }
 async function stableAudit(root, checks, options = {}) {
+  return profilePhase("repair.audit", () => readStableAudit(root, checks, options));
+}
+async function readStableAudit(root, checks, options) {
   const head = await getCurrentGitHash(root);
   const before = await docState(root);
   const report = await computeAudit(root, { ...options, checks });
@@ -3299,9 +3351,46 @@ async function stableAudit(root, checks, options = {}) {
   return report;
 }
 async function prepareRepair(rootDir, checks = ALL_CHECKS, options = {}) {
+  return prepareOriginal(rootDir, checks, options);
+}
+async function withRepairSession(root, options, run, cachedAudit) {
+  const before = await Promise.all([getCurrentGitHash(root), docState(root), advisoryReviewInventory(root).then(digest)]);
+  const audits = /* @__PURE__ */ new Map();
+  const documents = /* @__PURE__ */ new Map();
+  const history = /* @__PURE__ */ new Map();
+  const assessments = /* @__PURE__ */ new Map();
+  const memo = (cache, key, read) => {
+    if (!cache.has(key)) cache.set(key, read());
+    return cache.get(key);
+  };
+  const session = {
+    audit: (checks) => memo(audits, [...checks].sort().join(","), async () => {
+      if (cachedAudit && cachedAudit.headHash === before[0] && cachedAudit.root === root && digest([...checks].sort()) === digest([...cachedAudit.checksRun ?? []].sort())) {
+        const current = structuredClone(cachedAudit);
+        const reviews = (await Promise.all(allFindings(current).map((f) => assessAdvisory(root, f, before[0])))).filter((r) => r !== null);
+        delete current.advisoryReviews;
+        if (reviews.length) current.advisoryReviews = reviews;
+        return current;
+      }
+      return computeAudit(root, { ...options, checks });
+    }),
+    document: (file) => memo(documents, file, async () => readBoundedFile(await storePath(root, file), 10 * 1024 * 1024)),
+    history: (head) => memo(history, head, () => getChangesWithStatus(root, head)),
+    assessment: (dir, finding, head) => memo(assessments, digest([dir, finding, head]), () => assessAdvisory(dir, finding, head))
+  };
+  const result = await run({
+    prepare: () => prepareOriginal(root, ALL_CHECKS, options, session),
+    verify: (baseline) => profilePhase("repair.verify", () => verifyOriginal(root, baseline, options, session)),
+    currentAudit: () => session.audit(ALL_CHECKS)
+  });
+  const after = await Promise.all([getCurrentGitHash(root), docState(root), advisoryReviewInventory(root).then(digest)]);
+  if (digest(before) !== digest(after)) throw new Error("HEAD, context files or advisory review records changed during verification; retry against stable evidence.");
+  return result;
+}
+async function prepareOriginal(rootDir, checks, options, session) {
   const root = await fs12.realpath(rootDir);
   const selected = z7.array(checkSchema).nonempty().parse(checks);
-  const report = await stableAudit(root, selected, options);
+  const report = await (session ? session.audit(selected) : stableAudit(root, selected, options));
   if (!report) throw new Error("No context files found to prepare a repair.");
   if (!report.gitAvailable) throw new Error("Readable Git history is required to prepare a repair.");
   const storedReport = reportSchema.parse(report);
@@ -3327,23 +3416,26 @@ async function loadRepairBaseline(rootDir, baselinePath) {
   return { root, relative, original };
 }
 async function verifyRepair(rootDir, baselinePath, options = {}) {
+  return profilePhase("repair.verify", () => verifyOriginal(rootDir, baselinePath, options));
+}
+async function verifyOriginal(rootDir, baselinePath, options, session) {
   const { root, relative, original } = await loadRepairBaseline(rootDir, baselinePath);
   const diagnostics = [];
   let reviewDigest;
   let current = null;
   try {
-    reviewDigest = digest(await advisoryReviewInventory(root));
-    current = await stableAudit(root, original.checksRun, options);
+    if (!session) reviewDigest = digest(await advisoryReviewInventory(root));
+    current = await (session ? session.audit(original.checksRun) : stableAudit(root, original.checksRun, options));
     if (!current) diagnostics.push("No context files remain available to audit.");
     else if (!current.gitAvailable) diagnostics.push("Git history is unavailable.");
     for (const doc of original.docs) {
       if (!allFindings(original).some((f) => f.anchor.doc === doc.path) || !current?.docs.some((d) => d.path === doc.path)) continue;
-      const content2 = await readBoundedFile(await storePath(root, doc.path), 10 * 1024 * 1024);
+      const content2 = await (session ? session.document(doc.path) : readBoundedFile(await storePath(root, doc.path), 10 * 1024 * 1024));
       if (content2 === null || !content2.trim()) {
         diagnostics.push("Original context file " + doc.path + " is empty or unreadable; losing its claims does not verify a repair.");
       }
     }
-    if (await getChangesWithStatus(root, original.headHash) === null) {
+    if (await (session ? session.history(original.headHash) : getChangesWithStatus(root, original.headHash)) === null) {
       diagnostics.push("The original audit commit is unavailable; repair history cannot be verified.");
     }
   } catch (error) {
@@ -3368,7 +3460,7 @@ async function verifyRepair(rootDir, baselinePath, options = {}) {
     if (!current.checksRun?.includes(finding.type) || skipped.length) {
       return { ...base, status: "unverified", reason: skipped.map((s) => s.reason).join("; ") || "The original check did not run." };
     }
-    const review = await assessAdvisory(root, now ?? finding, original.headHash);
+    const review = await (session?.assessment ?? assessAdvisory)(root, now ?? finding, original.headHash);
     if (review) {
       if (review.status === "unverified") return { ...base, review, status: "unverified", reason: review.reason };
       if (review.status === "current") return { ...base, review, status: "resolved", reason: review.reason };
@@ -3383,7 +3475,7 @@ async function verifyRepair(rootDir, baselinePath, options = {}) {
     }
     return { ...base, status: "resolved", reason: "The original check ran and no longer reports this claim. Inspect the edit for semantic correctness." };
   }));
-  try {
+  if (!session) try {
     if (reviewDigest !== digest(await advisoryReviewInventory(root)) || current?.headHash !== await getCurrentGitHash(root)) {
       diagnostics.push("HEAD or advisory review records changed during verification; repeat against stable evidence.");
       for (const finding of findings) {
@@ -3436,6 +3528,7 @@ var count2, reportSchema, baselineSchema, repairFindingSchema;
 var init_repair = __esm({
   "src/audit/repair.ts"() {
     "use strict";
+    init_profile();
     init_audit();
     init_docs();
     init_snapshot();
@@ -3496,20 +3589,20 @@ import { promisify as promisify9 } from "util";
 import fg5 from "fast-glob";
 import { z as z8 } from "zod";
 async function git3(root, ...args) {
-  return (await exec7("git", args, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout;
+  return profilePhase("automation.git", async () => (await exec7("git", args, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout);
 }
 async function workspace(dir) {
   const root = await fs13.realpath((await git3(dir, "rev-parse", "--show-toplevel")).trim());
-  const gitDir = await fs13.realpath((await git3(root, "rev-parse", "--absolute-git-dir")).trim());
-  let branch;
-  try {
-    branch = (await git3(root, "symbolic-ref", "--quiet", "HEAD")).trim();
-  } catch {
-    branch = "detached";
-  }
+  const [gitDir, branch] = await Promise.all([
+    git3(root, "rev-parse", "--absolute-git-dir").then((value) => fs13.realpath(value.trim())),
+    git3(root, "symbolic-ref", "--quiet", "HEAD").then((value) => value.trim(), () => "detached")
+  ]);
   return { root, gitDir, branch, directory: ".mason/reports/automation/" + hash([root, gitDir, branch]).slice(0, 24) };
 }
 async function readInputs(root) {
+  return profilePhase("automation.inputs", () => collectInputs(root));
+}
+async function collectInputs(root) {
   const docPaths = await discoverDocPaths(root);
   const [headText, docStatus, shallowPath, replacements] = await Promise.all([
     git3(root, "rev-parse", "HEAD"),
@@ -3526,21 +3619,29 @@ async function readInputs(root) {
   }
   const docs = {};
   const docContents = [];
+  const parsedDocs = [];
   const claims = [];
+  const presence = /* @__PURE__ */ new Map();
+  const exists = (file) => {
+    if (!presence.has(file)) presence.set(file, pathExists(root, file));
+    return presence.get(file);
+  };
   for (const file of docPaths) {
     const text2 = await content(root, file);
     docs[file] = text2 === null ? null : hash(text2);
     docContents.push([file, text2]);
-    for (const claim of text2 ? extractClaims(text2).paths : []) {
+    const parsed = { path: file, content: text2 ?? "", claims: extractClaims(text2 ?? "") };
+    parsedDocs.push(parsed);
+    for (const claim of parsed.claims.paths) {
       const scope = pathClaimScope(file, claim);
       if (scope?.candidates.some(gitMetadataPath)) continue;
       for (const candidate of scope?.candidates ?? []) {
         if (optionalMasonPath(candidate)) continue;
-        claims.push([candidate, await pathExists(root, candidate), await pathExists(root, path20.posix.dirname(candidate))]);
+        const [filePresent, parentPresent] = await Promise.all([exists(candidate), exists(path20.posix.dirname(candidate))]);
+        claims.push([candidate, filePresent, parentPresent]);
       }
     }
   }
-  const parsedDocs = docContents.map(([file, text2]) => ({ path: file, content: text2 ?? "", claims: extractClaims(text2 ?? "") }));
   const combinedDocs = moduleDocumentation(parsedDocs);
   const countClaims = parsedDocs.flatMap((doc) => doc.claims.counts.map((claim) => ({ doc: doc.path, claim })));
   const decisionDirectory = await storePath(root, ".mason/decisions");
@@ -3562,7 +3663,7 @@ async function readInputs(root) {
     git3(root, "status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".", ":(exclude).mason/reports"),
     git3(root, "ls-files", "--stage", "-z", "--", ".", ":(exclude).mason/reports")
   ]) : ["", ""];
-  const common = [4, engineVersion, head, shallow, replacements, docContents];
+  const common = [5, engineVersion, head, shallow, replacements, docContents];
   const keys = {
     "deleted-reference": hash([common, claims, docStatus]),
     "new-module": hash([common, modules]),
@@ -3587,21 +3688,29 @@ function checkCache(raw, inputs) {
       reused.add(name);
       return structuredClone(entries[name].result);
     }
-    const result = await CHECKS[name](ctx);
+    const result = await profilePhase("check." + name, () => CHECKS[name](ctx));
     ran.add(name);
     if (!result.skipped.length) entries[name] = { key: inputs.keys[name], result };
     else delete entries[name];
     return result;
   } };
-  return { options, ran, reused, diagnostic, serialize: () => {
-    const canonical = cacheSchema.shape.entries.parse(entries);
-    return { version: 1, entries: canonical, digest: hash(canonical) };
-  } };
+  return {
+    options,
+    ran,
+    reused,
+    diagnostic,
+    has: (name) => entries[name]?.key === inputs.keys[name] && !entries[name].result.skipped.length,
+    serialize: () => {
+      const canonical = cacheSchema.shape.entries.parse(entries);
+      return { version: 1, entries: canonical, digest: hash(canonical) };
+    }
+  };
 }
 var exec7, engineVersion, hash, content, cacheSchema;
 var init_evidence = __esm({
   "src/automation/evidence.ts"() {
     "use strict";
+    init_profile();
     init_docs();
     init_scope();
     init_claims();
@@ -3614,7 +3723,7 @@ var init_evidence = __esm({
     init_storage();
     init_advisory_review();
     exec7 = promisify9(execFile9);
-    engineVersion = true ? "0.17.2" : "development";
+    engineVersion = true ? "0.17.3" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     cacheSchema = z8.object({ version: z8.literal(1), entries: z8.record(z8.object({ key: z8.string(), result: checkResultSchema })), digest: z8.string() });
@@ -3706,7 +3815,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.17.2" : "development";
+    executingVersion = () => true ? "0.17.3" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -3981,7 +4090,7 @@ __export(runtime_exports, {
 import { randomUUID as randomUUID5 } from "crypto";
 import { z as z13 } from "zod";
 async function observeReadOnlyTool(dir, event) {
-  const ws = await workspace(dir);
+  const ws = await profilePhase("automation.workspace", () => workspace(dir));
   await withLock(ws.root, ws.directory, async () => {
     const statePath = ws.directory + "/state.json";
     const raw = await readStoreJson(ws.root, statePath);
@@ -4028,24 +4137,41 @@ async function loadState(ws) {
   }
   return state;
 }
-async function sharedAnalysis(ws, state, inputs, startedAt) {
+async function matchingAnalysis(ws, state, inputs) {
   const pointer = state.analysis;
-  if (!pointer || pointer.fingerprint !== inputs.fingerprint || pointer.completedAt < startedAt) return null;
-  const stored = sharedSchema.parse(await readStoreJson(ws.root, pointer.path));
+  if (!pointer || pointer.fingerprint !== inputs.fingerprint) return { analysis: null };
+  if (pointer.path !== ws.directory + "/checks/analysis-" + inputs.fingerprint + ".json") {
+    throw new Error("Invalid automation analysis cache path; inspect the retained state.");
+  }
+  const invalid = { analysis: null, diagnostic: "Discarded an invalid current-audit cache; audit preparation and original verification were repeated." };
+  let raw;
+  try {
+    raw = await readStoreJson(ws.root, pointer.path);
+  } catch (error) {
+    const cause = error.cause;
+    if (cause instanceof SyntaxError || cause instanceof Error && cause.message === "expected a JSON object, received null") return invalid;
+    throw error;
+  }
+  if (raw === null) return { analysis: null };
+  const parsed = sharedSchema.safeParse(raw);
+  if (!parsed.success) return invalid;
+  const stored = parsed.data;
   const a = stored.analysis;
   if (stored.digest !== hash(a) || a.id !== pointer.id || a.fingerprint !== inputs.fingerprint || a.completedAt !== pointer.completedAt || a.report.root !== ws.root || a.report.branch !== ws.branch || a.report.head !== inputs.head || hash(a.report.baselinePaths) !== hash(state.baselines.map((b) => b.path))) {
-    throw new Error("Invalid shared automation evidence; run a new check.");
+    return invalid;
   }
   if (a.baselineDigest !== await baselineDigest(ws, state)) throw new Error("Repair baseline was modified; use the original baseline.");
-  return a;
+  return { analysis: a };
 }
 async function verifyInputs(ws, inputs) {
-  const [after, currentWs] = await Promise.all([readInputs(ws.root), workspace(ws.root)]);
-  if (after.fingerprint !== inputs.fingerprint || currentWs.directory !== ws.directory) {
-    throw new Error("Repository inputs or branch changed during automation; no current verification was recorded. Retry on a stable checkout.");
-  }
+  return profilePhase("automation.revalidate", async () => {
+    const [after, currentWs] = await Promise.all([readInputs(ws.root), workspace(ws.root)]);
+    if (after.fingerprint !== inputs.fingerprint || currentWs.directory !== ws.directory) {
+      throw new Error("Repository inputs or branch changed during automation; no current verification was recorded. Retry on a stable checkout.");
+    }
+  });
 }
-async function computeAnalysis(ws, state, inputs, event) {
+async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDiagnostic) {
   const baselines = [...state.baselines];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const empty = {
@@ -4074,7 +4200,7 @@ async function computeAnalysis(ws, state, inputs, event) {
     }
   }
   let cached = null;
-  const diagnostics = [];
+  const diagnostics = cacheDiagnostic ? [cacheDiagnostic] : [];
   try {
     cached = await readStoreJson(ws.root, ws.directory + "/cache.json");
   } catch {
@@ -4082,19 +4208,26 @@ async function computeAnalysis(ws, state, inputs, event) {
   }
   const cache = checkCache(cached, inputs);
   if (cache.diagnostic) diagnostics.push(cache.diagnostic);
-  const saveBaseline = async () => {
-    if (baselines.length >= 128) throw new Error("128 retained baselines need review; automatic capture stopped without discarding original evidence.");
-    const prepared = await prepareRepair(ws.root, ALL_CHECKS, cache.options);
-    baselines.push({ path: prepared.baselinePath, at: now, event: event.event, fingerprint: inputs.fingerprint });
-  };
-  if (!baselines.length) await saveBaseline();
-  const verifications = [];
-  for (const baseline of baselines) verifications.push(await verifyRepair(ws.root, baseline.path, cache.options));
-  const known = new Set(verifications.flatMap((v) => v.findings.map((f) => f.id)));
-  if (verifications.some((v) => v.newFindings.some((f) => !known.has(findingId(f))))) {
-    await saveBaseline();
-    verifications.push(await verifyRepair(ws.root, baselines.at(-1).path, cache.options));
-  }
+  const cachedAudit = previousAudit?.gitAvailable && previousAudit.headHash === inputs.head && previousAudit.root === ws.root && !previousAudit.skippedChecks.length && ALL_CHECKS.every((name) => previousAudit.checksRun?.includes(name) && cache.has(name)) ? previousAudit : void 0;
+  if (cachedAudit) for (const name of ALL_CHECKS) cache.reused.add(name);
+  let currentAudit = null;
+  const verifications = await withRepairSession(ws.root, cache.options, async (repairs) => {
+    const saveBaseline = async () => {
+      if (baselines.length >= 128) throw new Error("128 retained baselines need review; automatic capture stopped without discarding original evidence.");
+      const prepared = await repairs.prepare();
+      baselines.push({ path: prepared.baselinePath, at: now, event: event.event, fingerprint: inputs.fingerprint });
+    };
+    if (!baselines.length) await saveBaseline();
+    const verifications2 = [];
+    for (const baseline of baselines) verifications2.push(await repairs.verify(baseline.path));
+    const known = new Set(verifications2.flatMap((v) => v.findings.map((f) => f.id)));
+    if (verifications2.some((v) => v.newFindings.some((f) => !known.has(findingId(f))))) {
+      await saveBaseline();
+      verifications2.push(await repairs.verify(baselines.at(-1).path));
+    }
+    currentAudit = await repairs.currentAudit();
+    return verifications2;
+  }, cachedAudit);
   const merged = /* @__PURE__ */ new Map();
   for (const verification of verifications) {
     for (const finding of verification.findings) {
@@ -4115,20 +4248,20 @@ async function computeAnalysis(ws, state, inputs, event) {
     reportPath: "",
     findings: [...merged.values()],
     diagnostics: [...new Set(diagnostics)],
-    checks: { ran: [...cache.ran], reused: [...cache.reused].filter((name) => !cache.ran.has(name)), skipped: verifications.at(-1).currentAudit?.skippedChecks ?? [] },
+    checks: { ran: [...cache.ran], reused: [...cache.reused].filter((name) => !cache.ran.has(name)), skipped: verifications.at(-1).currentAudit?.skippedChecks ?? [], ...cachedAudit ? { auditReused: true } : {} },
     counts,
     capture: "unknown",
     scope: SCOPE
   };
-  return { baselines, report, cache: cache.ran.size || cached === null || cache.diagnostic ? cache.serialize() : null };
+  return { baselines, report, currentAudit, cache: cache.ran.size || cached === null || cache.diagnostic ? cache.serialize() : null };
 }
 async function analyze(ws, inputs, event, startedAt) {
   return withLock(ws.root, ws.directory + "/analysis/" + inputs.fingerprint, async () => {
     const before = await loadState(ws);
-    const shared = await sharedAnalysis(ws, before, inputs, startedAt);
-    if (shared) return { analysis: shared, shared: true };
+    const { analysis: previous, diagnostic } = await matchingAnalysis(ws, before, inputs);
+    if (previous && previous.completedAt >= startedAt) return { analysis: previous, shared: true };
     const originalDigest = await baselineDigest(ws, before);
-    const computed = await computeAnalysis(ws, before, inputs, event);
+    const computed = await computeAnalysis(ws, before, inputs, event, previous?.currentAudit, diagnostic);
     await verifyInputs(ws, inputs);
     if (originalDigest !== await baselineDigest(ws, before)) throw new Error("Repair baseline was modified during automation; original evidence must be inspected.");
     const id = randomUUID5();
@@ -4137,7 +4270,8 @@ async function analyze(ws, inputs, event, startedAt) {
       fingerprint: inputs.fingerprint,
       completedAt: Date.now(),
       baselineDigest: await baselineDigest(ws, { ...before, baselines: computed.baselines }),
-      report: computed.report
+      report: computed.report,
+      currentAudit: computed.currentAudit
     });
     const analysisPath = ws.directory + "/checks/analysis-" + inputs.fingerprint + ".json";
     await withLock(ws.root, ws.directory, async () => {
@@ -4156,17 +4290,17 @@ async function analyze(ws, inputs, event, startedAt) {
 }
 async function automate(dir, event) {
   const startedAt = Date.now();
-  const ws = await workspace(dir);
+  const ws = await profilePhase("automation.workspace", () => workspace(dir));
   return recordExecution(ws.root, ws.directory, event.event, async () => {
     const inputs = await readInputs(ws.root);
-    const result = await analyze(ws, inputs, event, startedAt);
+    const result = await profilePhase("automation.analysis", () => analyze(ws, inputs, event, startedAt));
     if (result.shared) {
       await verifyInputs(ws, inputs);
       if (result.analysis.baselineDigest !== await baselineDigest(ws, await loadState(ws))) {
         throw new Error("Repair baseline was modified during shared automation; original evidence must be inspected.");
       }
     }
-    return withLock(ws.root, ws.directory, async () => {
+    return profilePhase("automation.publish", () => withLock(ws.root, ws.directory, async () => {
       const state = await loadState(ws);
       if (state.analysis?.id !== result.analysis.id) throw new Error("Automation evidence changed during publication; retry against the current inputs.");
       const report = structuredClone(result.analysis.report);
@@ -4229,11 +4363,11 @@ async function automate(dir, event) {
       if (persistReport) await writeStoreJson(ws.root, report.reportPath, report);
       await writeStoreJson(ws.root, ws.directory + "/state.json", state);
       return { report, message: notify ? summarize(report) : null, continueOnce };
-    });
+    }));
   });
 }
 async function automationStatus(dir) {
-  const ws = await workspace(dir);
+  const ws = await profilePhase("automation.workspace", () => workspace(dir));
   const execution = await executionStatus(ws.root, ws.directory);
   const notifications = await failureNotifications(ws.root, ws.directory);
   const raw = await readStoreJson(ws.root, ws.directory + "/state.json");
@@ -4267,6 +4401,7 @@ var SCOPE, priority, cleanText, analysisSchema, sharedSchema, baselineDigest;
 var init_runtime = __esm({
   "src/automation/runtime.ts"() {
     "use strict";
+    init_profile();
     init_execution();
     init_repair();
     init_types();
@@ -4281,6 +4416,7 @@ var init_runtime = __esm({
       fingerprint: z13.string(),
       completedAt: z13.number(),
       baselineDigest: z13.string(),
+      currentAudit: reportSchema.nullable().optional(),
       report: z13.object({
         version: z13.literal(1),
         status: z13.enum(["verified", "issues-remain", "incomplete", "unavailable"]),
@@ -4294,7 +4430,8 @@ var init_runtime = __esm({
         checks: z13.object({
           ran: z13.array(z13.string()),
           reused: z13.array(z13.string()),
-          skipped: z13.array(z13.object({ check: z13.string(), reason: z13.string(), doc: z13.string().optional() }))
+          skipped: z13.array(z13.object({ check: z13.string(), reason: z13.string(), doc: z13.string().optional() })),
+          auditReused: z13.boolean().optional()
         }),
         counts: z13.object({ resolved: z13.number(), unresolved: z13.number(), "review-required": z13.number(), unverified: z13.number() }),
         capture: z13.enum(["observed", "unknown"]),
@@ -4302,9 +4439,9 @@ var init_runtime = __esm({
       })
     });
     sharedSchema = z13.object({ analysis: analysisSchema, digest: z13.string() });
-    baselineDigest = async (ws, state) => hash(await Promise.all(
+    baselineDigest = async (ws, state) => profilePhase("automation.baselines", async () => hash(await Promise.all(
       state.baselines.map(async (b) => [b.path, await readStoreJson(ws.root, b.path)])
-    ));
+    )));
   }
 });
 
@@ -9226,7 +9363,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.17.2"
+      version: "0.17.3"
     },
     {
       instructions: (setupNotice ? setupNotice + "\n\n" : "") + 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, failed verification needs correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'