minutes-mcp 0.25.5 → 0.26.0

package/dist/autoInstall.d.ts

@@ -2,6 +2,12 @@ type ExecFileAsync = (file: string, args: readonly string[], options?: {
     timeout?: number;
     env?: NodeJS.ProcessEnv;
 }) => Promise<unknown>;
+export declare const MACOS_SHERPA_ARCHIVE = "minutes-macos-arm64-sherpa.tar.gz";
+export declare const MACOS_BARE_BINARY = "minutes-macos-arm64";
+export declare class ReleaseAssetUnavailableError extends Error {
+    readonly assetName: string;
+    constructor(assetName: string, message: string);
+}
 export type Sha256Entry = {
     filename: string;
     sha256: string;
@@ -10,6 +16,49 @@ export declare function parseSha256Sums(raw: string): Sha256Entry[];
 export declare function findSha256ForAsset(raw: string, assetName: string): string | null;
 export declare function computeFileSha256(path: string): Promise<string>;
 export declare function verifyDownloadedAsset(path: string, expectedSha256: string): Promise<void>;
+/**
+ * Extract the two files from the macOS sherpa release archive.
+ *
+ * The release archive has one fixed directory and two fixed regular files.
+ * Keeping this reader deliberately narrow avoids a package dependency and,
+ * more importantly, prevents path traversal, links, devices, or unexpected
+ * files from ever being materialized. The archive itself is SHA-256 verified
+ * before this function is called.
+ */
+export declare function extractMacSherpaArchive(options: {
+    archivePath: string;
+    destDir: string;
+}): Promise<{
+    binaryPath: string;
+    pluginPath: string;
+}>;
+/**
+ * Commit a verified binary/plugin pair. The binary rename is the commit point:
+ * it is never touched until the staged binary passes `--version`. If that
+ * final rename fails, restore the previous plugin so callers never observe a
+ * completed-but-partial install.
+ */
+export declare function atomicReplaceMacSherpaFiles(options: {
+    stagedBinaryPath: string;
+    stagedPluginPath: string;
+    targetBinaryPath: string;
+    targetPluginPath: string;
+    backupDir: string;
+}): Promise<void>;
+export type MacSherpaInstallResult = {
+    assetName: string;
+    usedFallback: boolean;
+};
+/** Install the signed macOS sherpa archive, falling back only when unavailable. */
+export declare function installMacSherpaArchiveWithFallback(options: {
+    installDir: string;
+    execFileAsync: ExecFileAsync;
+    baseUrl?: string;
+    log?: (message: string) => void;
+    downloadAsset?: typeof downloadReleaseBinaryWithChecksum;
+    extractArchive?: typeof extractMacSherpaArchive;
+    verifyExecutable?: (binaryPath: string) => Promise<void>;
+}): Promise<MacSherpaInstallResult>;
 /**
  * Extract a zip on Windows via PowerShell's Expand-Archive.
  *

package/dist/autoInstall.js

@@ -1,6 +1,19 @@
 import { createHash } from "crypto";
-import { basename } from "path";
-import { readFile, rename, rm } from "fs/promises";
+import { gunzip } from "zlib";
+import { promisify } from "util";
+import { basename, join } from "path";
+import { chmod, copyFile, mkdir, mkdtemp, readFile, rename, rm, stat, writeFile, } from "fs/promises";
+const gunzipAsync = promisify(gunzip);
+export const MACOS_SHERPA_ARCHIVE = "minutes-macos-arm64-sherpa.tar.gz";
+export const MACOS_BARE_BINARY = "minutes-macos-arm64";
+export class ReleaseAssetUnavailableError extends Error {
+    assetName;
+    constructor(assetName, message) {
+        super(message);
+        this.name = "ReleaseAssetUnavailableError";
+        this.assetName = assetName;
+    }
+}
 export function parseSha256Sums(raw) {
     const entries = [];
     for (const line of raw.split(/\r?\n/)) {
@@ -36,6 +49,174 @@ export async function verifyDownloadedAsset(path, expectedSha256) {
         throw new Error(`checksum mismatch: expected ${expectedSha256.toLowerCase()}, got ${actual}`);
     }
 }
+function tarString(header, offset, length) {
+    const field = header.subarray(offset, offset + length);
+    const nul = field.indexOf(0);
+    return field.subarray(0, nul === -1 ? field.length : nul).toString("utf8").trim();
+}
+function tarSize(header) {
+    const raw = tarString(header, 124, 12).replace(/\0/g, "").trim();
+    if (!/^[0-7]+$/.test(raw)) {
+        throw new Error(`invalid tar entry size ${JSON.stringify(raw)}`);
+    }
+    return Number.parseInt(raw, 8);
+}
+/**
+ * Extract the two files from the macOS sherpa release archive.
+ *
+ * The release archive has one fixed directory and two fixed regular files.
+ * Keeping this reader deliberately narrow avoids a package dependency and,
+ * more importantly, prevents path traversal, links, devices, or unexpected
+ * files from ever being materialized. The archive itself is SHA-256 verified
+ * before this function is called.
+ */
+export async function extractMacSherpaArchive(options) {
+    const compressed = await readFile(options.archivePath);
+    const tar = await gunzipAsync(compressed);
+    const expected = new Map();
+    const root = "minutes-macos-arm64-sherpa";
+    const expectedNames = new Set([
+        `${root}/minutes`,
+        `${root}/libminutes_sherpa.dylib`,
+    ]);
+    let offset = 0;
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every((byte) => byte === 0))
+            break;
+        const name = tarString(header, 0, 100);
+        const prefix = tarString(header, 345, 155);
+        const archivePath = `${prefix ? `${prefix}/` : ""}${name}`.replace(/^\.\//, "");
+        const size = tarSize(header);
+        const type = String.fromCharCode(header[156] || 0);
+        const dataStart = offset + 512;
+        const dataEnd = dataStart + size;
+        if (dataEnd > tar.length) {
+            throw new Error(`truncated tar entry ${archivePath}`);
+        }
+        if (type === "\0" || type === "0") {
+            if (!expectedNames.has(archivePath)) {
+                throw new Error(`unexpected file in macOS sherpa archive: ${archivePath}`);
+            }
+            if (expected.has(archivePath)) {
+                throw new Error(`duplicate file in macOS sherpa archive: ${archivePath}`);
+            }
+            expected.set(archivePath, Buffer.from(tar.subarray(dataStart, dataEnd)));
+        }
+        else if (type !== "5" && type !== "x" && type !== "g") {
+            throw new Error(`unsupported tar entry type ${JSON.stringify(type)} for ${archivePath}`);
+        }
+        offset = dataStart + Math.ceil(size / 512) * 512;
+    }
+    for (const name of expectedNames) {
+        if (!expected.has(name)) {
+            throw new Error(`macOS sherpa archive is missing ${name}`);
+        }
+    }
+    await mkdir(options.destDir, { recursive: true });
+    const binaryPath = join(options.destDir, "minutes");
+    const pluginPath = join(options.destDir, "libminutes_sherpa.dylib");
+    await writeFile(binaryPath, expected.get(`${root}/minutes`), { mode: 0o755 });
+    await writeFile(pluginPath, expected.get(`${root}/libminutes_sherpa.dylib`), {
+        mode: 0o755,
+    });
+    return { binaryPath, pluginPath };
+}
+/**
+ * Commit a verified binary/plugin pair. The binary rename is the commit point:
+ * it is never touched until the staged binary passes `--version`. If that
+ * final rename fails, restore the previous plugin so callers never observe a
+ * completed-but-partial install.
+ */
+export async function atomicReplaceMacSherpaFiles(options) {
+    const pluginBackup = join(options.backupDir, "previous-libminutes_sherpa.dylib");
+    let hadPlugin = false;
+    try {
+        await stat(options.targetPluginPath);
+        hadPlugin = true;
+        await copyFile(options.targetPluginPath, pluginBackup);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let pluginReplaced = false;
+    try {
+        await rename(options.stagedPluginPath, options.targetPluginPath);
+        pluginReplaced = true;
+        await rename(options.stagedBinaryPath, options.targetBinaryPath);
+    }
+    catch (error) {
+        if (pluginReplaced) {
+            if (hadPlugin) {
+                await rename(pluginBackup, options.targetPluginPath).catch(() => { });
+            }
+            else {
+                await rm(options.targetPluginPath, { force: true }).catch(() => { });
+            }
+        }
+        throw error;
+    }
+    finally {
+        await rm(pluginBackup, { force: true }).catch(() => { });
+    }
+}
+/** Install the signed macOS sherpa archive, falling back only when unavailable. */
+export async function installMacSherpaArchiveWithFallback(options) {
+    const log = options.log ?? (() => { });
+    const downloadAsset = options.downloadAsset ?? downloadReleaseBinaryWithChecksum;
+    const extractArchive = options.extractArchive ?? extractMacSherpaArchive;
+    await mkdir(options.installDir, { recursive: true });
+    const temporaryDir = await mkdtemp(join(options.installDir, ".minutes-sherpa-install-"));
+    try {
+        const archivePath = join(temporaryDir, MACOS_SHERPA_ARCHIVE);
+        try {
+            await downloadAsset({
+                binaryName: MACOS_SHERPA_ARCHIVE,
+                targetPath: archivePath,
+                execFileAsync: options.execFileAsync,
+                baseUrl: options.baseUrl,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof ReleaseAssetUnavailableError))
+                throw error;
+            log(`[Minutes] ${MACOS_SHERPA_ARCHIVE} is unavailable in this release (${error.message}); ` +
+                `falling back to the bare ${MACOS_BARE_BINARY} asset`);
+            const targetBinaryPath = join(options.installDir, "minutes");
+            await downloadAsset({
+                binaryName: MACOS_BARE_BINARY,
+                targetPath: targetBinaryPath,
+                execFileAsync: options.execFileAsync,
+                baseUrl: options.baseUrl,
+            });
+            await chmod(targetBinaryPath, 0o755);
+            return { assetName: MACOS_BARE_BINARY, usedFallback: true };
+        }
+        const extractedDir = join(temporaryDir, "extracted");
+        await mkdir(extractedDir, { recursive: true });
+        const { binaryPath, pluginPath } = await extractArchive({
+            archivePath,
+            destDir: extractedDir,
+        });
+        await chmod(binaryPath, 0o755);
+        const verifyExecutable = options.verifyExecutable ?? (async (path) => {
+            await options.execFileAsync(path, ["--version"], { timeout: 5000 });
+        });
+        await verifyExecutable(binaryPath);
+        await atomicReplaceMacSherpaFiles({
+            stagedBinaryPath: binaryPath,
+            stagedPluginPath: pluginPath,
+            targetBinaryPath: join(options.installDir, "minutes"),
+            targetPluginPath: join(options.installDir, "libminutes_sherpa.dylib"),
+            backupDir: temporaryDir,
+        });
+        return { assetName: MACOS_SHERPA_ARCHIVE, usedFallback: false };
+    }
+    finally {
+        await rm(temporaryDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
 /**
  * Extract a zip on Windows via PowerShell's Expand-Archive.
  *
@@ -82,11 +263,20 @@ export async function downloadReleaseBinaryWithChecksum(options) {
         const sums = await readFile(tempSumsPath, "utf8");
         const expectedSha256 = findSha256ForAsset(sums, binaryName);
         if (!expectedSha256) {
-            throw new Error(`SHA256SUMS.txt has no entry for ${binaryName}`);
+            throw new ReleaseAssetUnavailableError(binaryName, `SHA256SUMS.txt has no entry for ${binaryName}`);
+        }
+        try {
+            await execFileAsync("curl", ["-fSL", "-o", tempBinaryPath, binaryUrl], {
+                timeout: 120000,
+            });
+        }
+        catch (error) {
+            const stderr = String(error?.stderr ?? "");
+            if (/\b404\b|not found/i.test(stderr)) {
+                throw new ReleaseAssetUnavailableError(binaryName, `${binaryName} returned HTTP 404`);
+            }
+            throw error;
         }
-        await execFileAsync("curl", ["-fSL", "-o", tempBinaryPath, binaryUrl], {
-            timeout: 120000,
-        });
         await verifyDownloadedAsset(tempBinaryPath, expectedSha256);
         await rename(tempBinaryPath, targetPath);
     }

package/dist/corpus-lease.d.ts

@@ -133,6 +133,17 @@ export type CorpusLeaseHooks = {
 export declare function awaitDeferredCorpusReleasesForTests(timeoutMs?: number): Promise<boolean>;
 /** Test-only: the live retained-corpus charge, for leak assertions. */
 export declare function reservedCorpusMemoryBytesForTests(): number;
+/** @internal Pure policy seam for test-harness gate regression coverage. */
+export declare function resolveAuthorizationTimeoutMsForTest(timeoutMs: number | undefined, environment: Readonly<NodeJS.ProcessEnv>): number;
+/** @internal Pure policy seam that pins the derived production envelope. */
+export declare function authorizationWorkEnvelopeForTest(): Readonly<{
+    maxCorpusBytes: number;
+    manifestsPerAttempt: 3;
+    physicalReadsPerManifest: 2;
+    maxAttempts: 2;
+    minimumReadBytesPerSecond: number;
+    timeoutMs: number;
+}>;
 export type CorpusLeaseWorkerRequest = Readonly<{
     root: string;
     budgets: Readonly<CorpusReadBudgets>;

package/dist/corpus-lease.js

@@ -8,7 +8,7 @@ import { decodePolicyUtf8, fingerprintTextFileFromBoundParent, readTextFileWithR
 import { nodeChildEnvironment } from "./node-child.js";
 const MAX_AUTHORIZATION_ATTEMPTS = 2;
 const DEFAULT_FENCE_TIMEOUT_MS = 5_000;
-const DEFAULT_AUTHORIZATION_TIMEOUT_MS = 15_000;
+const MAX_TEST_HARNESS_AUTHORIZATION_TIMEOUT_MS = 120_000;
 const MAX_ACTIVE_WATCHERS = 64;
 // Snapshot content is retained as JavaScript strings, whose backing storage
 // may require two bytes per source byte. Reserve that worst case for the full
@@ -53,6 +53,30 @@ export const DEFAULT_CORPUS_READ_BUDGETS = Object.freeze({
     maxWatcherCount: 512,
     maxReaderCount: 64,
 });
+// One successful attempt materializes a baseline, verifies it before the
+// final fence, then verifies it again at the authorization point. Every
+// manifest reads each file twice to prove the bytes were stable while its
+// descriptor was held. The complete sequence may retry once under the same
+// cumulative deadline.
+const CORPUS_MANIFESTS_PER_AUTHORIZATION_ATTEMPT = 3;
+const CORPUS_PHYSICAL_READS_PER_MANIFEST = 2;
+// Match the native corpus reader's documented storage floor. Meeting libraries
+// may live on synced folders, external disks, and ordinary spinning disks; a
+// corpus inside every published resource ceiling must not require fast local
+// SSD throughput merely to pass authorization.
+const MIN_ASSUMED_CORPUS_READ_BYTES_PER_SECOND = 16 * 1024 * 1024;
+// This deadline is a backstop, not the primary safety control. File, byte,
+// directory, watcher, reader, retained-memory, and worker-process ceilings
+// still bound what one request may consume. Deriving the wall-clock ceiling
+// from that work envelope keeps those promises consistent when a pass count or
+// byte ceiling changes. At today's limits this is 60 seconds, rather than the
+// old hardcoded 15 seconds that denied valid large or slow corpora (#933).
+const DEFAULT_AUTHORIZATION_TIMEOUT_MS = Math.ceil((DEFAULT_CORPUS_READ_BUDGETS.maxCorpusBytes *
+    CORPUS_MANIFESTS_PER_AUTHORIZATION_ATTEMPT *
+    CORPUS_PHYSICAL_READS_PER_MANIFEST *
+    MAX_AUTHORIZATION_ATTEMPTS *
+    1_000) /
+    MIN_ASSUMED_CORPUS_READ_BYTES_PER_SECOND);
 let activeWatcherCount = 0;
 let reservedCorpusMemoryBytes = 0;
 let retainedSentinelUseSequence = 0;
@@ -185,12 +209,53 @@ function resolveFenceTimeout(timeoutMs) {
     }
     return Math.min(requested, DEFAULT_FENCE_TIMEOUT_MS);
 }
-function authorizationDeadline(timeoutMs) {
-    const requested = timeoutMs ?? DEFAULT_AUTHORIZATION_TIMEOUT_MS;
+function resolveAuthorizationTimeoutMs(timeoutMs, environment = process.env) {
+    const configuredOverride = environment.MINUTES_CORPUS_AUTH_TIMEOUT_MS;
+    // A deadline beyond the derived production envelope is test infrastructure,
+    // not application configuration. Requiring both markers keeps an ambient
+    // production environment variable from relaxing the fail-closed cap. Only
+    // the repository's test harness sets this pair; the spawned lease worker
+    // inherits it from the parent. Invalid gated values fail closed instead of
+    // silently relaxing or changing the requested budget.
+    const testHarnessOverride = environment.NODE_ENV === "test" &&
+        environment.MINUTES_TEST_HARNESS === "1" &&
+        configuredOverride !== undefined
+        ? configuredOverride
+        : undefined;
+    if (testHarnessOverride !== undefined &&
+        !/^[1-9]\d*$/.test(testHarnessOverride)) {
+        throw new Error("Access denied: invalid meeting corpus authorization timeout");
+    }
+    const cap = testHarnessOverride === undefined
+        ? DEFAULT_AUTHORIZATION_TIMEOUT_MS
+        : Math.min(Number(testHarnessOverride), MAX_TEST_HARNESS_AUTHORIZATION_TIMEOUT_MS);
+    const requested = timeoutMs ?? cap;
     if (!Number.isSafeInteger(requested) || requested < 1) {
         throw new Error("Access denied: invalid meeting corpus authorization timeout");
     }
-    return process.hrtime.bigint() + BigInt(Math.min(requested, DEFAULT_AUTHORIZATION_TIMEOUT_MS)) * 1000000n;
+    return Math.min(requested, cap);
+}
+/** @internal Pure policy seam for test-harness gate regression coverage. */
+export function resolveAuthorizationTimeoutMsForTest(timeoutMs, environment) {
+    return resolveAuthorizationTimeoutMs(timeoutMs, environment);
+}
+/** @internal Pure policy seam that pins the derived production envelope. */
+export function authorizationWorkEnvelopeForTest() {
+    return Object.freeze({
+        maxCorpusBytes: DEFAULT_CORPUS_READ_BUDGETS.maxCorpusBytes,
+        manifestsPerAttempt: CORPUS_MANIFESTS_PER_AUTHORIZATION_ATTEMPT,
+        physicalReadsPerManifest: CORPUS_PHYSICAL_READS_PER_MANIFEST,
+        maxAttempts: MAX_AUTHORIZATION_ATTEMPTS,
+        minimumReadBytesPerSecond: MIN_ASSUMED_CORPUS_READ_BYTES_PER_SECOND,
+        timeoutMs: DEFAULT_AUTHORIZATION_TIMEOUT_MS,
+    });
+}
+function authorizationWindow(timeoutMs) {
+    const budgetMs = resolveAuthorizationTimeoutMs(timeoutMs);
+    return {
+        budgetMs,
+        deadline: process.hrtime.bigint() + BigInt(budgetMs) * 1000000n,
+    };
 }
 function remainingAuthorizationMs(deadline) {
     const remainingNs = deadline - process.hrtime.bigint();
@@ -1012,7 +1077,7 @@ class WatchedCorpusAttempt {
  */
 async function withStableCorpusLeaseInProcess(root, operation, hooks = {}) {
     const budgets = resolveCorpusReadBudgets(hooks.budgets);
-    const deadline = authorizationDeadline(hooks.timeoutMs);
+    const { deadline } = authorizationWindow(hooks.timeoutMs);
     const fenceTimeoutMs = resolveFenceTimeout(hooks.timeoutMs);
     const memoryReservation = reserveCorpusMemory(budgets);
     try {
@@ -1358,8 +1423,16 @@ function parentControls(commands, pauses) {
  * those name a caller-actionable limit rather than an authorization outcome.
  */
 export async function withStableCorpusLease(root, operation, hooks = {}) {
+    const authorizationStarted = process.hrtime.bigint();
     try {
-        return await dispatchStableCorpusLease(root, operation, hooks);
+        const result = await dispatchStableCorpusLease(root, operation, hooks);
+        const durationMs = Number((process.hrtime.bigint() - authorizationStarted + 999999n) / 1000000n);
+        // Match denial diagnostics: content-free, operator-visible, deferred, and
+        // unable to turn an authorization result into an application failure.
+        setImmediate(() => {
+            writeOperatorDiagnostic(`[corpus-lease] authorized (authorization duration ${durationMs}ms)\n`);
+        });
+        return result;
     }
     catch (error) {
         if (error instanceof CorpusLeaseChangedError) {
@@ -1379,7 +1452,7 @@ async function dispatchStableCorpusLease(root, operation, hooks = {}) {
         throw new Error("Access denied: a meeting corpus worker was killed without confirming it died");
     }
     const budgets = resolveCorpusReadBudgets(hooks.budgets);
-    const deadline = authorizationDeadline(hooks.timeoutMs);
+    const { budgetMs: authorizationBudgetMs, deadline } = authorizationWindow(hooks.timeoutMs);
     const timeoutMs = remainingAuthorizationMs(deadline);
     const invocation = corpusWorkerInvocation(hooks.workerScriptForTest);
     const reservation = reserveCorpusMemory(budgets);
@@ -1502,14 +1575,20 @@ async function dispatchStableCorpusLease(root, operation, hooks = {}) {
                         // "0ms remained" rather than an overrun.
                         const overran = remainingNs < 0n;
                         const magnitudeMs = Number((overran ? -remainingNs : remainingNs) / 1000000n);
-                        const budget = overran
+                        const remainingBudget = overran
                             ? `authorization budget overrun by ${magnitudeMs}ms`
                             : `${magnitudeMs}ms of authorization budget remained`;
                         // Shared with the bound-reader refusal path, because a plain
                         // try/catch here never covered an asynchronous EPIPE: that
                         // arrives as an 'error' event on a later tick and is fatal
                         // without a listener.
-                        writeOperatorDiagnostic(`[corpus-lease] denied: ${message} (${budget})\n`);
+                        const elapsedMs = overran
+                            ? authorizationBudgetMs + magnitudeMs
+                            : Math.max(0, authorizationBudgetMs - magnitudeMs);
+                        writeOperatorDiagnostic(`[corpus-lease] denied: ${message} (` +
+                            `authorization duration ${elapsedMs}ms; ` +
+                            `${authorizationBudgetMs}ms authorization budget; ` +
+                            `${remainingBudget})\n`);
                     }
                     catch {
                         // A broken stderr must never turn a clean denial into a crash.

package/dist/index.d.ts

@@ -315,6 +315,7 @@ export declare function liveMeetingSnippet(body: string, query?: string): string
 export declare function shouldRunMainEntry(argv1: string | null | undefined, moduleFilename: string): boolean;
 export declare function parseKnowledgeConfig(configContent: string): KnowledgeConfigStatus | null;
 export declare function createCapabilityRepairCoordinator(repair: () => Promise<boolean>, maximumAttempts?: number): () => Promise<boolean>;
+export declare function getReleaseBinaryName(platform?: NodeJS.Platform, arch?: string): string | null;
 export type HealthItem = {
     label?: unknown;
     state?: unknown;
@@ -325,6 +326,7 @@ export type HealthOutput = {
     items: HealthItem[] | null;
     engine?: string;
     effectiveEngine?: string;
+    reason?: string;
     model?: string;
 };
 export declare function parseHealthOutput(stdout: string): HealthOutput;
@@ -332,10 +334,11 @@ type WhisperModelCheckState = {
     done: boolean;
 };
 export type EnsureWhisperModelOptions = {
+    autoSetup?: string;
     checkState?: WhisperModelCheckState;
     health?: () => Promise<string>;
     configFileExists?: () => Promise<boolean>;
-    setup?: (model: string) => Promise<void>;
+    setup?: (model?: string) => Promise<void>;
     log?: (message: string) => void;
 };
 export declare function ensureWhisperModel(options?: EnsureWhisperModelOptions): Promise<void>;

package/dist/index.js

@@ -54,7 +54,7 @@ import { canonicalizeRoot, expandHomeLikePath, readTextFileInDirectory, validate
 import { isCliCompatible, parseVersion } from "./version.js";
 import { nodeChildEnvironment } from "./node-child.js";
 import { hasFeature, probeCapabilitiesSync, } from "./capabilities.js";
-import { downloadReleaseBinaryWithChecksum, extractZipWithPowerShell, } from "./autoInstall.js";
+import { downloadReleaseBinaryWithChecksum, extractZipWithPowerShell, installMacSherpaArchiveWithFallback, MACOS_SHERPA_ARCHIVE, } from "./autoInstall.js";
 import { attachCaptureRelay, } from "./captureRelay.js";
 import { withStableCorpusLease, } from "./corpus-lease.js";
 import { HTTP_BIND_HOST, DEFAULT_HTTP_PORT, DEFAULT_MAX_SESSIONS, startMinutesHttpServer, } from "./httpTransport.js";
@@ -104,6 +104,7 @@ function handleDemoSetup() {
                 args: ["minutes-mcp"],
                 env: {
                     MEETINGS_DIR: demoDir,
+                    MINUTES_MCP_AUTO_SETUP: "0",
                 },
             },
         },
@@ -122,7 +123,7 @@ function handleDemoSetup() {
     console.log("  • What action items are still open, and who owns each?");
     console.log("  • Summarize the Northwind customer thread.");
     console.log("");
-    console.log("Note: some structured tools (consistency report, person profile) auto-install the Minutes CLI on first use.");
+    console.log("The server installs the Minutes CLI if needed to enforce meeting access rules. This demo config disables speech model auto-downloads.");
     console.log("Full setup (real audio capture, transcription, real meetings): https://useminutes.app");
     console.log("");
     process.exit(0);
@@ -1570,7 +1571,7 @@ const COPILOT_SUPPORTED = hasFeature(CLI_CAPABILITIES, "copilot_realtime");
 // `./version.ts` (see issue #183). Hosted `.mcpb` bundles will run
 // against CLIs with different minor/patch numbers within the same
 // major; that is explicitly supported.
-const MCP_SERVER_VERSION = "0.25.5";
+const MCP_SERVER_VERSION = "0.26.0";
 export function parseKnowledgeConfig(configContent) {
     const knowledgeMatch = configContent.match(/\[knowledge\][\s\S]*?(?=\n\[|$)/);
     if (!knowledgeMatch) {
@@ -1617,17 +1618,15 @@ export function createCapabilityRepairCoordinator(repair, maximumAttempts = MAX_
     };
 }
 const runCapabilityRepair = createCapabilityRepairCoordinator(() => tryAutoInstallAttempt(true));
-function getReleaseBinaryName() {
-    const platform = process.platform;
-    const arch = process.arch;
+export function getReleaseBinaryName(platform = process.platform, arch = process.arch) {
     if (platform === "darwin" && arch === "arm64")
-        return "minutes-macos-arm64";
+        return MACOS_SHERPA_ARCHIVE;
     if (platform === "darwin" && arch === "x64")
-        return "minutes-macos-arm64"; // Rosetta handles it
+        return MACOS_SHERPA_ARCHIVE; // Rosetta runs arm64 CLI
     if (platform === "linux" && arch === "x64")
         return "minutes-linux-x64";
     if (platform === "win32" && arch === "x64")
-        return "minutes-windows-x64.exe";
+        return "minutes-windows-x64.zip";
     return null;
 }
 function getInstallDir() {
@@ -1662,7 +1661,20 @@ async function tryAutoInstallAttempt(capabilityRepair = false) {
             const targetPath = join(installDir, targetName);
             // Ensure install directory exists
             await mkdir(installDir, { recursive: true });
-            if (isWindows) {
+            if (binaryName === MACOS_SHERPA_ARCHIVE) {
+                console.error(`[Minutes] Selected ${MACOS_SHERPA_ARCHIVE}: Apple Silicon auto-install ` +
+                    "includes the Parakeet plugin beside the CLI");
+                const result = await installMacSherpaArchiveWithFallback({
+                    installDir,
+                    execFileAsync,
+                    log: (message) => console.error(message),
+                });
+                if (!result.usedFallback) {
+                    console.error(`[Minutes] Verified ${result.assetName}, validated its CLI with --version, ` +
+                        "and atomically installed the binary + sherpa plugin");
+                }
+            }
+            else if (isWindows) {
                 // The Windows binary imports the MSVC runtime (VCRUNTIME140.dll,
                 // MSVCP140.dll and friends), which is not part of Windows. On a PC
                 // that has never had the Visual C++ Redistributable, the bare .exe
@@ -1673,11 +1685,10 @@ async function tryAutoInstallAttempt(capabilityRepair = false) {
                 // resolves the application's own directory ahead of the system path,
                 // so extracting them next to the executable is sufficient and needs no
                 // installer and no admin rights. Verified on a clean Windows 11 VM.
-                const archiveName = "minutes-windows-x64.zip";
-                const archivePath = join(installDir, archiveName);
-                console.error(`[Minutes] Downloading ${archiveName} from latest release...`);
+                const archivePath = join(installDir, binaryName);
+                console.error(`[Minutes] Selected ${binaryName}: Windows needs the bundled MSVC runtime DLLs`);
                 await downloadReleaseBinaryWithChecksum({
-                    binaryName: archiveName,
+                    binaryName,
                     targetPath: archivePath,
                     execFileAsync,
                 });
@@ -1693,7 +1704,7 @@ async function tryAutoInstallAttempt(capabilityRepair = false) {
                 await stat(targetPath);
             }
             else {
-                console.error(`[Minutes] Downloading ${binaryName} from latest release...`);
+                console.error(`[Minutes] Selected ${binaryName}: this platform uses the standalone CLI asset`);
                 // Download with curl, verify SHA256SUMS.txt, then move the verified
                 // binary into place.
                 await downloadReleaseBinaryWithChecksum({
@@ -1821,6 +1832,7 @@ export function parseHealthOutput(stdout) {
         ...(typeof dataRecord.effective_engine === "string"
             ? { effectiveEngine: dataRecord.effective_engine }
             : {}),
+        ...(typeof dataRecord.reason === "string" ? { reason: dataRecord.reason } : {}),
         ...(typeof dataRecord.model === "string" ? { model: dataRecord.model } : {}),
     };
 }
@@ -1837,6 +1849,10 @@ async function configFileExists() {
     }
 }
 export async function ensureWhisperModel(options = {}) {
+    // Reading existing transcripts does not need a speech model. Demo and
+    // recall-only hosts can opt out without changing the user's capture config.
+    if ((options.autoSetup ?? process.env.MINUTES_MCP_AUTO_SETUP) === "0")
+        return;
     const checkState = options.checkState;
     if (checkState ? checkState.done : modelCheckDone)
         return;
@@ -1853,7 +1869,8 @@ export async function ensureWhisperModel(options = {}) {
         return stdout;
     });
     const setup = options.setup ?? (async (model) => {
-        await execFileAsync(MINUTES_BIN, ["setup", "--model", model], {
+        const args = model === undefined ? ["setup"] : ["setup", "--model", model];
+        await execFileAsync(MINUTES_BIN, args, {
             timeout: 300000,
             env: mcpCliChildEnv(),
         });
@@ -1872,6 +1889,28 @@ export async function ensureWhisperModel(options = {}) {
         log("[Minutes] Unrecognized health --json output — skipping Whisper auto-setup");
         return;
     }
+    const parakeetModelMissing = healthOutput.engine?.toLowerCase() === "auto" &&
+        healthOutput.effectiveEngine?.toLowerCase() === "whisper" &&
+        healthOutput.reason === "whisper: parakeet model missing — run minutes setup";
+    if (parakeetModelMissing) {
+        log("[Minutes] Auto found the sherpa plugin but Parakeet is missing — running minutes setup...");
+        try {
+            await setup();
+            log("[Minutes] ✓ Parakeet and Whisper fallback models downloaded — recording is ready");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log(`[Minutes] Model download failed: ${message}. Run manually: minutes setup`);
+        }
+        return;
+    }
+    // Auto may resolve to sherpa when Parakeet v3 is installed. In that case
+    // Whisper readiness is irrelevant to MCP startup and must not trigger the
+    // legacy `setup --model tiny` path.
+    if (healthOutput.effectiveEngine?.toLowerCase() === "sherpa") {
+        log("[Minutes] Auto transcription resolved to sherpa — skipping Whisper auto-setup");
+        return;
+    }
     const modelItem = healthOutput.items.find((item) => item.label === "Speech model");
     if (!modelItem) {
         log("[Minutes] unrecognized health items — skipping Whisper auto-setup");
@@ -4363,7 +4402,12 @@ registerDocsAppTool("consistency_report", {
     if (!(await isCliAvailable())) {
         return { content: [{ type: "text", text: `Consistency reports require the full CLI for structured intent analysis.\n\n${CLI_INSTALL_MSG}` }] };
     }
-    const args = ["consistency", "--stale-after-days", String(stale_after_days)];
+    const capabilities = await ensureCliCapabilities(["consistency_corpus_root_v1"]);
+    if (capabilities.kind !== "report" || !hasFeature(capabilities, "consistency_corpus_root_v1")) {
+        throw new Error("Consistency reports require a Minutes CLI that supports the selected meeting folder. Update Minutes, then try again.");
+    }
+    const meetingsDir = await getEffectiveMeetingsDir();
+    const args = ["consistency", "--dir", meetingsDir, "--stale-after-days", String(stale_after_days)];
     if (owner)
         args.push("--owner", owner);
     const { stdout, stderr } = await runMinutes(args);

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "minutes-mcp",
-  "version": "0.25.5",
+  "version": "0.26.0",
+  "mcpName": "io.github.silverstein/minutes",
   "description": "MCP server for minutes \u2014 conversation memory for AI assistants. Works with Claude Desktop, Mistral Vibe, Cursor, Windsurf, and any MCP client.",
   "main": "dist/index.js",
   "type": "module",
@@ -32,20 +33,21 @@
   "scripts": {
     "build": "tsc && vite build",
     "build:ui": "vite build",
-    "test": "npm run build && node test/mcp_tools_test.mjs && node test/copilot_mcp_contract.mjs && node test/mcp_http_transport_test.mjs && node test/surface_parity_test.mjs",
-    "test:unit": "vitest run",
+    "test": "npm run build && node ../../scripts/run_corpus_test_harness.mjs npm run test:integration",
+    "test:integration": "node test/mcp_tools_test.mjs && node test/copilot_mcp_contract.mjs && node test/mcp_http_transport_test.mjs && node test/surface_parity_test.mjs && node test/first_recall_test.mjs",
+    "test:unit": "node ../../scripts/run_corpus_test_harness.mjs npx vitest run",
     "test:host-compat": "node test/live_events_host_compat.mjs",
     "test:copilot": "node test/copilot_mcp_contract.mjs",
     "test:http": "node test/mcp_http_transport_test.mjs",
     "test:surface-parity": "node test/surface_parity_test.mjs",
-    "test:all": "vitest run && npm run build && node test/mcp_tools_test.mjs && node test/copilot_mcp_contract.mjs && node test/mcp_http_transport_test.mjs && node test/surface_parity_test.mjs",
+    "test:all": "npm run test:unit && npm test",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.6.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "minutes-sdk": "0.25.5",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "minutes-sdk": "0.26.0",
     "yaml": "^2.8.3",
     "zod": "^3.25 || ^4.0"
   },