mason-context 0.17.2 → 0.17.3

package/dist/mason-auto.js

@@ -346,6 +346,39 @@ var init_store = __esm({
   }
 });
 
+// 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;
+  }
+}
+async function withProfile(run, emit) {
+  const phases = {};
+  const start = performance.now();
+  return profiles.run(phases, async () => {
+    try {
+      return await run();
+    } finally {
+      emit(JSON.stringify({ kind: "mason-profile", version: 1, totalMs: performance.now() - start, phases }));
+    }
+  });
+}
+var profiles;
+var init_profile = __esm({
+  "src/utils/profile.ts"() {
+    "use strict";
+    profiles = new AsyncLocalStorage();
+  }
+});
+
 // src/audit/commands.ts
 import path4 from "path";
 function splitCommands(line) {
@@ -949,16 +982,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) {
@@ -1039,21 +1083,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;
 }
@@ -1061,6 +1114,7 @@ var exec3, DOC_CANDIDATES;
 var init_docs = __esm({
   "src/audit/docs.ts"() {
     "use strict";
+    init_profile();
     init_claims();
     init_git();
     init_inputs();
@@ -2586,6 +2640,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;
@@ -2612,11 +2669,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 {
@@ -2650,6 +2707,7 @@ async function computeAudit(rootDir, options = {}) {
 var init_audit = __esm({
   "src/audit/audit.ts"() {
     "use strict";
+    init_profile();
     init_drift();
     init_snapshot();
     init_docs();
@@ -2685,6 +2743,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 });
@@ -2693,10 +2754,44 @@ async function stableAudit(root, checks, options = {}) {
   }
   return report;
 }
-async function prepareRepair(rootDir, checks = ALL_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);
@@ -2721,24 +2816,24 @@ async function loadRepairBaseline(rootDir, baselinePath) {
   const original = stored.report;
   return { root, relative, original };
 }
-async function verifyRepair(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) {
@@ -2763,7 +2858,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 };
@@ -2778,7 +2873,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) {
@@ -2818,6 +2913,7 @@ var count2, reportSchema, baselineSchema, repairFindingSchema;
 var init_repair = __esm({
   "src/audit/repair.ts"() {
     "use strict";
+    init_profile();
     init_audit();
     init_docs();
     init_snapshot();
@@ -2878,20 +2974,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"),
@@ -2908,21 +3004,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");
@@ -2944,7 +3048,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]),
@@ -2969,21 +3073,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();
@@ -2996,7 +3108,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() });
@@ -3190,7 +3302,7 @@ var init_execution = __esm({
 import { randomUUID as randomUUID4 } from "crypto";
 import { z as z10 } 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);
@@ -3237,24 +3349,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 = {
@@ -3283,7 +3412,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 {
@@ -3291,19 +3420,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) {
@@ -3324,20 +3460,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 = randomUUID4();
@@ -3346,7 +3482,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 () => {
@@ -3365,17 +3502,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);
@@ -3438,11 +3575,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");
@@ -3476,6 +3613,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();
@@ -3490,6 +3628,7 @@ var init_runtime = __esm({
       fingerprint: z10.string(),
       completedAt: z10.number(),
       baselineDigest: z10.string(),
+      currentAudit: reportSchema.nullable().optional(),
       report: z10.object({
         version: z10.literal(1),
         status: z10.enum(["verified", "issues-remain", "incomplete", "unavailable"]),
@@ -3503,7 +3642,8 @@ var init_runtime = __esm({
         checks: z10.object({
           ran: z10.array(z10.string()),
           reused: z10.array(z10.string()),
-          skipped: z10.array(z10.object({ check: z10.string(), reason: z10.string(), doc: z10.string().optional() }))
+          skipped: z10.array(z10.object({ check: z10.string(), reason: z10.string(), doc: z10.string().optional() })),
+          auditReused: z10.boolean().optional()
         }),
         counts: z10.object({ resolved: z10.number(), unresolved: z10.number(), "review-required": z10.number(), unverified: z10.number() }),
         capture: z10.enum(["observed", "unknown"]),
@@ -3511,9 +3651,9 @@ var init_runtime = __esm({
       })
     });
     sharedSchema = z10.object({ analysis: analysisSchema, digest: z10.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)])
-    ));
+    )));
   }
 });
 
@@ -3650,7 +3790,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`;
   }
@@ -5663,6 +5803,7 @@ function createProgress(options = {}) {
 }
 
 // src/automation/cli.ts
+init_profile();
 var TEARDOWN_USAGE = `Usage: mason teardown [options]
 
 Disconnect Mason from this Git project. Defaults to all project hosts.
@@ -5690,6 +5831,7 @@ var USAGE = `Usage: mason-auto <setup|teardown|install|config|status|check|hook>
   --command <prefix>          Installed executable prefix for install/config
   --dry-run                   Preview teardown without writing
   --json                      Machine-readable output (status also uses JSON when piped)
+  --profile                   Local phase timings on stderr for check/hook; no file contents
 
 check exits 0 for verified checks, 1 for issues, 2 for incomplete/unavailable.
 teardown exits 0 for complete/no-op, 2 when cleanup needs attention (also in dry runs).
@@ -5701,7 +5843,8 @@ var parseCli = (argv2) => parseArgs({ args: argv2, allowPositionals: true, optio
   command: { type: "string" },
   json: { type: "boolean" },
   help: { type: "boolean", short: "h" },
-  "dry-run": { type: "boolean" }
+  "dry-run": { type: "boolean" },
+  profile: { type: "boolean" }
 } });
 function isHookCommand(argv2) {
   try {
@@ -5726,6 +5869,8 @@ async function runAutomationCli(argv2, stdin = "", io = defaultIo, options = {})
     }
     if (positionals.length !== 1) throw new Error("Expected one command.");
     [action] = positionals;
+    if (values.profile && !["check", "hook"].includes(action)) throw new Error("--profile applies only to check/hook.");
+    const measured = (run) => values.profile ? withProfile(run, io.err) : run();
     const dir = values.dir ?? process.cwd();
     if (values["dry-run"] !== void 0 && action !== "teardown") throw new Error("--dry-run applies only to teardown.");
     if (action === "teardown") {
@@ -5738,7 +5883,7 @@ async function runAutomationCli(argv2, stdin = "", io = defaultIo, options = {})
     if (action === "hook") {
       const host = hostSchema.parse(values.host);
       if (options.managedHost && options.managedHost !== host) throw new Error("Managed hook --host does not match its launcher.");
-      const output = await runAutomationHook(host, stdin, { managed: !!options.managedHost });
+      const output = await measured(() => runAutomationHook(host, stdin, { managed: !!options.managedHost }));
       if (output) io.out(JSON.stringify(output));
       return 0;
     }
@@ -5769,7 +5914,7 @@ async function runAutomationCli(argv2, stdin = "", io = defaultIo, options = {})
       return 0;
     }
     if (action !== "check") throw new Error("Unknown automation command: " + action);
-    const { report } = await automate(dir, { event: "task_end" });
+    const { report } = await measured(() => automate(dir, { event: "task_end" }));
     io.out(values.json ? JSON.stringify(report, null, 2) : summarize(report));
     return report.status === "verified" ? 0 : report.status === "issues-remain" ? 1 : 2;
   } catch (error) {