@wirecat/cli-core 0.597.0 → 0.598.0

package/CHANGELOG.md

@@ -7,6 +7,35 @@ shape of this file.
 
 ## Unreleased
 
+## 0.598.0 — 07.11.2026
+
+### Added
+
+- **`runScopeCases`** (`@wirecat/cli-core/testing`): cases that each remote command of a program runs inside
+  cli-core's run, so `--record` keeps a run named after it, and that `--timeout` ends it when the service never
+  answers. A command beside the run answers under the process run and fails. `neverAnswers` is the `fetch` for the
+  silent run.
+- **`inCommandRun(command, body)`** (`@wirecat/cli-core/cli`): runs `body` inside cli-core's run with the settings of
+  the app `run()` was given, which `run()` now hands every command (`environment.resolveSettings`).
+
+### Changed — may break callers
+
+- **`addMeetingCommands` takes `inRun`**, which `meetings sync` runs inside: pass `inCommandRun` from
+  `@wirecat/cli-core/cli`. The meetings module cannot reach cli-core's run itself.
+
+### Fixed
+
+- **The shared CRM, calendar and meetings commands run inside cli-core's run.** `sync` and the deal and lead writes
+  from `addCrmCommands`, every command from `addCalendarCommands`, and `meetings sync` answered under the process
+  run: `--record` kept no run, and `runs show` could not find the id they answered. A CLI that wrapped them in a run
+  of its own can drop that.
+- **An MCP server's `--permission` levels refuse a messenger write before it connects.** The early refusal of a change
+  on the messenger read the command's flags only, so `mcp serve --permission messages.send=deny` let the command
+  connect and left the refusal to the send guard. It now merges the server's levels as `baseContext` does.
+  `withAgentLevels(command, flags)` (`@wirecat/cli-core/cli`) is that merge, for a CLI's own resolver.
+- **An app's `mcp serve` over stdio ends when it was stopped before it listened.** `serveAppOverStdio` waited only
+  for an abort event, which a signal that had already fired never sends, so the server hung with stdin open.
+
 ## 0.597.0 — 07.11.2026
 
 ### Added

package/dist/calendar/cli/index.js

@@ -3,7 +3,7 @@ import { annotate, metaOf, sharedCommand } from "@wirecat/cli-base/commands";
 import { timezoneOf } from "@wirecat/cli-base/query";
 import { clockMeta } from "@wirecat/cli-base/standards";
 import { Argument, InvalidArgumentError, Option } from "commander";
-import { environmentOf, outputFor, runBudgetOf } from "../../cli/context.js";
+import { environmentOf, inCommandRun, outputFor, runBudgetOf } from "../../cli/context.js";
 import { honoursDryRun } from "../../cli/dry-run-guard.js";
 import { changesStore, ownerOnlyOption, writesFileOnlyWith } from "../../cli/effects.js";
 import { renderAnswer } from "../../cli/envelope.js";
@@ -77,17 +77,10 @@ const addCalendarCommandsDefinition = (program, options) => {
         renderAnswer(command, output, body, view ?? ((shown) => localTimesView(shown, zone(), output.color)));
     };
     /** Opens the profile for `work` and closes it before the answer prints, also when `work` fails. */
-    const within = async (command, work, view) => {
+    const within = (command, work, view) => inCommandRun(command, async () => {
         const run = await options.open(command, { readOnly: readsOnly(command) });
-        let body;
-        try {
-            body = await work(run);
-        }
-        finally {
-            await run.close?.();
-        }
-        answer(command, body, view);
-    };
+        answer(command, await work(run).finally(() => run.close?.()), view);
+    });
     const example = (command, ...lines) => annotate(command, { examples: lines.map((line) => `${options.app.command} personal ${line}`) });
     const calendars = annotate(program.command("calendars").description("the account's calendars"), { effects: GROUP });
     withQuery(example(annotate(calendars.command("list"), { effects: FETCH, offline: false }).description("list the account's calendars from the provider, and which of them sync"), "calendars list --json", "calendars list synced:true"), CALENDARS_QUERY).action(async (words, _opts, command) => {

package/dist/cli/context.d.ts

@@ -34,6 +34,8 @@ export interface BaseEnvironment {
     answer?: (question: string) => Promise<string | null> | string | null;
     /** Set by `run()`; a command's run is recorded only when it is known whose run it is. */
     app?: AppIdentity;
+    /** Set by `run()`: the app's own, so a shared command group opens its run with the app's settings. */
+    resolveSettings?: (flags: GlobalFlags, options?: ResolveOptions) => Settings;
     /** Set by `run()` from `process.platform` unless a test hands one in: the OS a command's paths and units are for. */
     platform?: NodeJS.Platform;
     /** The local speech recognizer in place of the downloaded model; tests hand one in. */
@@ -120,6 +122,10 @@ export declare const runBudgetOf: (command: Command, requests?: number) => RunBu
 export declare const setExitCode: (command: Command, code: number) => void;
 export declare const provide: (program: Command, environment: BaseEnvironment) => void;
 export declare const environmentOf: <E extends BaseEnvironment = BaseEnvironment>(command: Command) => E;
+/** The command's flags with an MCP server's `--permission` levels first: they reach a run on its agent, never in argv. */
+export declare const withAgentLevels: <F extends {
+    permission?: string[];
+}>(command: Command, flags: F) => F;
 /**
  * The input and output `readSecret` uses for this command: the run's own, so a prompt goes where the run's other
  * output goes and a test that captures it sees it. `readSecret(prompt, { ...secretInputOf(this), echo: true })`.
@@ -166,4 +172,10 @@ export interface BaseContext {
 type Resolve = (flags: GlobalFlags, options?: ResolveOptions) => Settings;
 /** Everything a command needs that no messenger decides, resolved once. */
 export declare const baseContext: (command: Command, resolveSettings: Resolve) => BaseContext;
+/**
+ * A shared group's command inside cli-core's run, with the settings of the app `run()` was given: recorded, and ended
+ * by `--timeout` (WC-LIFE-5, WC-LIFE-15). The group's own opener still decides whether it needs a profile. A program
+ * parsed without `run()` has no run to open, so `body` just runs.
+ */
+export declare const inCommandRun: <T>(command: Command, body: (events: EventSink) => Promise<T>) => Promise<T>;
 export {};

package/dist/cli/context.js

@@ -37,6 +37,11 @@ export const provide = (program, environment) => {
     environments.set(program, environment);
 };
 export const environmentOf = (command) => (environments.get(rootOf(command)) ?? {});
+/** The command's flags with an MCP server's `--permission` levels first: they reach a run on its agent, never in argv. */
+export const withAgentLevels = (command, flags) => {
+    const overrides = environmentOf(command).agent?.overrides ?? [];
+    return overrides.length > 0 ? { ...flags, permission: [...overrides, ...(flags.permission ?? [])] } : flags;
+};
 /**
  * The input and output `readSecret` uses for this command: the run's own, so a prompt goes where the run's other
  * output goes and a test that captures it sees it. `readSecret(prompt, { ...secretInputOf(this), echo: true })`.
@@ -70,9 +75,7 @@ export const outputFor = (command) => {
 export const baseContext = (command, resolveSettings) => {
     const environment = environmentOf(command);
     const env = environment.env ?? process.env;
-    const flags = command.optsWithGlobals();
-    const overrides = environment.agent?.overrides ?? [];
-    const settings = resolveSettings(overrides.length > 0 ? { ...flags, permission: [...overrides, ...(flags.permission ?? [])] } : flags, { env });
+    const settings = resolveSettings(withAgentLevels(command, command.optsWithGlobals()), { env });
     const { renderer, format, color, streams, compact, full } = resolveOutput({
         ...settings,
         env,
@@ -141,6 +144,17 @@ export const baseContext = (command, resolveSettings) => {
         },
     };
 };
+/**
+ * A shared group's command inside cli-core's run, with the settings of the app `run()` was given: recorded, and ended
+ * by `--timeout` (WC-LIFE-5, WC-LIFE-15). The group's own opener still decides whether it needs a profile. A program
+ * parsed without `run()` has no run to open, so `body` just runs.
+ */
+export const inCommandRun = (command, body) => {
+    const { resolveSettings } = environmentOf(command);
+    if (!resolveSettings)
+        return body(() => { });
+    return baseContext(command, (flags, options) => resolveSettings(flags, { ...options, needsProfile: false })).run(body);
+};
 /** `messages send` — the words that name commands, never the arguments: those can be a message. */
 const commandPath = (command) => {
     const words = [];

package/dist/cli/contract-templates.js

@@ -41,6 +41,7 @@ export const sharedCommandTemplate = (app, name) => {
                 },
                 accountId: 0,
                 write: unavailable,
+                inRun: unavailable,
             });
             const meetings = root.commands.find((command) => command.name() === "meetings");
             if (!meetings)

package/dist/cli/early-refusal.js

@@ -7,7 +7,7 @@ import { SendJournal, sendsPathFor } from "../sends/journal.js";
 import { CEILING_KEY, keyForCommand, levelFor, writeOfKey } from "../sends/permissions.js";
 import { newOperationId } from "../sends/send-id.js";
 import { commandPathOf } from "./command-contract.js";
-import { environmentOf } from "./context.js";
+import { withAgentLevels } from "./context.js";
 import { changesMessenger } from "./effects.js";
 import { refuseUnknownPermissionKeys } from "./permission-keys.js";
 import { NONE_NAMED, settingsFor } from "./settings.js";
@@ -33,7 +33,7 @@ export const refuseWriteBeforeConnecting = (action, { app, env, dryRun, resolve
     const key = keyForCommand(path);
     if (!key)
         return;
-    const settings = (resolve ?? settingsFor(app).resolveSettings)(action.optsWithGlobals(), {
+    const settings = (resolve ?? settingsFor(app).resolveSettings)(withAgentLevels(action, action.optsWithGlobals()), {
         env,
         needsProfile: false,
         readOnly: true,
@@ -91,9 +91,11 @@ export const refuseByCommandPermissions = (action, permissions, { app, env, dryR
     const preview = dryRun && app.messenger === false;
     if (lock && effects?.remote === "write" && !preview)
         throw readOnlyRefusal(lock, `run ${commandPathOf(action).join(" ")}`);
-    const flags = action.optsWithGlobals();
-    const overrides = environmentOf(action).agent?.overrides ?? [];
-    const settings = resolve(overrides.length > 0 ? { ...flags, permission: [...overrides, ...(flags.permission ?? [])] } : flags, { env, needsProfile: false, readOnly: true });
+    const settings = resolve(withAgentLevels(action, action.optsWithGlobals()), {
+        env,
+        needsProfile: false,
+        readOnly: true,
+    });
     refuseUnknownPermissionKeys(action, settings, app.command, permissions);
     if (dryRun || settings.sources?.profile === NONE_NAMED)
         return;

package/dist/cli/index.d.ts

@@ -66,7 +66,7 @@ export { type CompactOptions, compactText, entityRows, GENERIC_ROW, type RowColu
 export { refuseUnknownKey } from "./config-command.js";
 export { type ConfigIssue, type ConfigIssueKind, checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";
-export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, runBudgetOf, secretInputOf, } from "./context.js";
+export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, inCommandRun, outputFor, provide, runBudgetOf, secretInputOf, withAgentLevels, } from "./context.js";
 export { addContractInfo, type ContractEvidenceOptions, contractEvidence } from "./contract-evidence.js";
 export { sharedCommandTemplate } from "./contract-templates.js";
 export { type Closeable, withDeadline } from "./deadline.js";

package/dist/cli/index.js

@@ -57,7 +57,7 @@ export { compactText, entityRows, GENERIC_ROW, rowShapeOf, rowsOfEntity, SHARED_
 export { refuseUnknownKey } from "./config-command.js";
 export { checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";
-export { baseContext, environmentOf, outputFor, provide, runBudgetOf, secretInputOf, } from "./context.js";
+export { baseContext, environmentOf, inCommandRun, outputFor, provide, runBudgetOf, secretInputOf, withAgentLevels, } from "./context.js";
 export { addContractInfo, contractEvidence } from "./contract-evidence.js";
 export { sharedCommandTemplate } from "./contract-templates.js";
 export { withDeadline } from "./deadline.js";

package/dist/cli/program.js

@@ -228,6 +228,9 @@ const runOnce = async (argv, definition, options) => {
         commandSignal: control.signal,
         trackCloseable: control.trackCloseable,
         app: definition.app,
+        // `settingsFor`'s, which every CLI passes; the definition's type is looser only so a test can stub it.
+        resolveSettings: (definition.configuration ?? settingsFor(definition.app))
+            .resolveSettings,
         ...(definition.rows ? { rows: definition.rows } : {}),
         platform: options.platform ?? process.platform,
         exit,

package/dist/crm/cli/index.js

@@ -3,7 +3,7 @@ import { annotate, metaOf, sharedCommand } from "@wirecat/cli-base/commands";
 import { Argument, InvalidArgumentError } from "commander";
 import * as v from "valibot";
 import { answerEntity } from "../../cli/answer-entity.js";
-import { environmentOf, outputFor, runBudgetOf } from "../../cli/context.js";
+import { environmentOf, inCommandRun, outputFor, runBudgetOf } from "../../cli/context.js";
 import { honoursDryRun } from "../../cli/dry-run-guard.js";
 import { FETCH, LOCAL_READ, NO_EFFECTS, REMOTE_WRITE } from "../../cli/effects.js";
 import { itemOf, listOf, renderAnswer, snakeKeys, snakeKeysKeeping } from "../../cli/envelope.js";
@@ -142,7 +142,7 @@ const dealKeys = snakeKeysKeeping(["providerMetadata"]);
 const marked = (items, untrusted) => items.map((item) => ({ ...dealKeys(item), untrusted }));
 const addCrmCommandsDefinition = (program, options) => {
     const now = () => options.now?.() ?? Date.now();
-    const within = async (command, work) => {
+    const within = (command, work) => inCommandRun(command, async () => {
         const run = await options.open(command, { readOnly: metaOf(command).effects?.local !== "write" });
         let body;
         try {
@@ -152,7 +152,7 @@ const addCrmCommandsDefinition = (program, options) => {
             await run.close?.();
         }
         renderAnswer(command, outputFor(command), body);
-    };
+    });
     const example = (command, ...lines) => annotate(command, { examples: lines.map((line) => `${options.app.command} work ${line}`) });
     example(answerEntity(annotate(program.command("sync"), { effects: FETCH, offline: false, cooperative: true, partial: true }), "crm_sync", crmSync).description("bring the CRM's copy in the local store up to date: pipelines, companies, contacts, deals and leads that " +
         "changed since the last sync, or everything with --rescan; a run stops before its deadline or --max-pages " +
@@ -444,7 +444,8 @@ const addCrmCommandsDefinition = (program, options) => {
         .description("the CRM's custom fields of one kind, in its order, with a list field's options")
         .argument("<kind>", fieldKinds.join(", "))
         .option("--limit <n>", `fields per page, 1–${MOST}`, integer(MOST), 50)
-        .option("--page <n>", "which page, starting at 1", integer(1_000_000), 1)
+        // No default: the run's settings refuse --all beside a --page, given or defaulted.
+        .option("--page <n>", "which page, starting at 1", integer(1_000_000))
         .option("--all", "every field, no paging"), FIELDS_QUERY), "fields list deals", "fields list people --json").action(async (kind, words, opts, command) => {
         if (!fieldKinds.includes(kind))
             throw new CliError("validation_error", `fields are listed for ${fieldKinds.join(", ")}; got ${kind}`, {
@@ -454,12 +455,13 @@ const addCrmCommandsDefinition = (program, options) => {
         queryTerms(words, FIELDS_QUERY, "fields list");
         await within(command, async (run) => {
             const found = await run.store.crm.fields(run.account, FIELD_KINDS[kind]);
-            const offset = opts.all ? 0 : (opts.page - 1) * opts.limit;
+            const page = opts.page ?? 1;
+            const offset = opts.all ? 0 : (page - 1) * opts.limit;
             const end = opts.all ? found.length : offset + opts.limit;
             return listOf(pathOf(command).join(" "), {
                 items: found.slice(offset, end).map((field) => ({ ...field, untrusted: FIELD_UNTRUSTED })),
                 limit: opts.all ? Math.max(1, found.length) : opts.limit,
-                page: opts.page,
+                page,
                 has_more: found.length > end,
                 ...(words.length ? { args: { query: words } } : {}),
             });

package/dist/kit/index.d.ts

@@ -2,5 +2,6 @@ export { ARGV_LOG, argvLogSetup } from "./argv-log.js";
 export { type ContractCase, type ContractOptions, contractCases, OPTIONAL_METHODS } from "./contract.js";
 export { type FakeAdapter, fakeAdapter } from "./fake.js";
 export { type McpStdio, type McpStdioStreams, type McpToolResult, mcpOverStdio } from "./mcp-stdio.js";
+export { neverAnswers, type RunScopeCase, type RunScopeOptions, runScopeCases } from "./run-scope.js";
 export { type SearchRecipes, searchRecipes, seedSearchRecipes } from "./search-recipes.js";
 export { BUSY_PAGE, contractSeed, digitIds, type IdKind, type IdMaker, type Seed, wordIds } from "./seed.js";

package/dist/kit/index.js

@@ -2,5 +2,6 @@ export { ARGV_LOG, argvLogSetup } from "./argv-log.js";
 export { contractCases, OPTIONAL_METHODS } from "./contract.js";
 export { fakeAdapter } from "./fake.js";
 export { mcpOverStdio } from "./mcp-stdio.js";
+export { neverAnswers, runScopeCases } from "./run-scope.js";
 export { searchRecipes, seedSearchRecipes } from "./search-recipes.js";
 export { BUSY_PAGE, contractSeed, digitIds, wordIds } from "./seed.js";

package/dist/kit/run-scope.d.ts

@@ -0,0 +1,34 @@
+import { type ProgramDefinition, type RunOptions } from "../cli/program.js";
+export interface RunScopeCase {
+    name: string;
+    /** Throws an `AssertionError` when the command does not run inside cli-core's run. */
+    run(): Promise<void>;
+}
+export interface RunScopeOptions {
+    /** The CLI's own program definition, as its `run()` hands it to cli-core. */
+    definition: ProgramDefinition;
+    /**
+     * The words that run each remote command to success against the answering fake, by command path:
+     * `{ "comments show": ["personal", "comments", "show", "c1"] }`. A write whose level is `ask` needs a profile that
+     * allows it, or its refusal fails the case.
+     */
+    commands: Record<string, readonly string[]>;
+    /** Remote commands left out, each with its reason: one that listens until stopped, one that asks npm. */
+    skip?: Record<string, string>;
+    /** What `run()` gets beside the streams: the keyring, and the fake that answers every request. */
+    answering: () => RunOptions;
+    /** The same, with a fake that takes every request and never settles it, `neverAnswers` for an HTTP service. */
+    silent: () => RunOptions;
+    /** The `--timeout` a silent run gets; 100 ms. */
+    timeoutMs?: number;
+}
+/** A `fetch` that never settles, not even on abort: only the run's own deadline can end the command. */
+export declare const neverAnswers: typeof fetch;
+/**
+ * Cases that each remote command runs inside cli-core's run — `baseContext(command, resolveSettings).run(body)` — and
+ * not beside it, so `--record` keeps a run named after the command (WC-LIFE-15); and that `--timeout` ends it when
+ * its service never answers, a write as `outcome_unknown` (WC-LIFE-5, WC-LIFE-9). The recorded case is the one that
+ * catches a command beside the run: `run()`'s own deadline still ends such a command on time. The first case fails
+ * on a remote command with no words and no skip.
+ */
+export declare const runScopeCases: (options: RunScopeOptions) => RunScopeCase[];

package/dist/kit/run-scope.js

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { metaOf } from "@wirecat/cli-base/commands";
+import { createProgram, run } from "../cli/program.js";
+import { findRun, runsDirFor } from "../runs/run.js";
+/** A `fetch` that never settles, not even on abort: only the run's own deadline can end the command. */
+export const neverAnswers = (() => new Promise(() => { }));
+const GRACE_MS = 2000;
+const remoteCommands = (program, path = []) => program.commands.flatMap((command) => {
+    const at = [...path, command.name()];
+    if (command.commands.length > 0)
+        return remoteCommands(command, at);
+    const meta = metaOf(command);
+    const remote = meta.effects?.remote;
+    return remote && remote !== "none" ? [{ path: at.join(" "), remote, partial: meta.partial === true }] : [];
+});
+const within = async (ms, what, body) => {
+    let timer;
+    const late = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new assert.AssertionError({ message: what })), ms);
+        timer.unref();
+    });
+    try {
+        return await Promise.race([body, late]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const parsed = (text) => {
+    try {
+        return JSON.parse(text.trim());
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Cases that each remote command runs inside cli-core's run — `baseContext(command, resolveSettings).run(body)` — and
+ * not beside it, so `--record` keeps a run named after the command (WC-LIFE-15); and that `--timeout` ends it when
+ * its service never answers, a write as `outcome_unknown` (WC-LIFE-5, WC-LIFE-9). The recorded case is the one that
+ * catches a command beside the run: `run()`'s own deadline still ends such a command on time. The first case fails
+ * on a remote command with no words and no skip.
+ */
+export const runScopeCases = (options) => {
+    const { definition, commands, skip = {}, timeoutMs = 100 } = options;
+    const { app } = definition;
+    const cli = async (argv, given) => {
+        const out = [];
+        const err = [];
+        const env = {
+            ...process.env,
+            ...given.env,
+            [`${app.envPrefix}_STATE_DIR`]: mkdtempSync(join(tmpdir(), "run-scope-")),
+        };
+        const code = await run(argv, definition, {
+            ...given,
+            env,
+            tty: false,
+            streams: { data: (text) => out.push(text), diagnostic: (text) => err.push(text) },
+        });
+        return { code, out: out.join(""), err: err.join(""), env };
+    };
+    const machine = (words) => words.some((word) => word === "--json" || word.startsWith("--json=")) ? [...words] : [...words, "--json"];
+    const recordedCase = (path, words) => ({
+        name: `${path} runs in a recorded run named after it`,
+        run: async () => {
+            const ran = await within(GRACE_MS, `${path} did not end against the answering fake`, (async () => cli(["--record", ...machine(words)], options.answering()))());
+            assert.equal(ran.code, 0, `${path} must succeed against the answering fake; it exited ${ran.code}: ${ran.err}`);
+            const runId = parsed(ran.out)?.meta?.run_id;
+            assert.equal(typeof runId, "string", `${path} answered without meta.run_id`);
+            assert.doesNotMatch(String(runId), /-process-/, `${path} answered outside a run of its own: ${runId}`);
+            const kept = findRun(runsDirFor(app, ran.env), String(runId));
+            assert.ok(kept, `--record kept no run ${runId} for ${path}`);
+            assert.equal(kept.metadata.command, path, `the run of ${path} is named ${kept.metadata.command}`);
+        },
+    });
+    const timeoutCase = ({ path, remote, partial }, words) => {
+        const expected = remote === "write" ? "outcome_unknown" : "timeout";
+        return {
+            name: `${path} ends in ${expected}${partial ? " or a partial answer" : ""} at --timeout when the service never answers`,
+            run: async () => {
+                const ran = await within(timeoutMs + GRACE_MS, `${path} was still running ${GRACE_MS} ms after its --timeout ${timeoutMs}ms`, cli(["--timeout", `${timeoutMs}ms`, ...machine(words)], options.silent()));
+                const answered = parsed(ran.out)?.meta?.complete;
+                if (partial && ran.code === 0 && answered === false)
+                    return;
+                const code = parsed(ran.err)?.error?.code;
+                assert.equal(code, expected, `${path} against a silent service ended in ${String(code)}: ${ran.out}${ran.err}`);
+            },
+        };
+    };
+    const remote = remoteCommands(createProgram(definition));
+    const coverage = {
+        name: "every remote command has its words or a reason to skip it",
+        run: async () => {
+            const missing = remote.map(({ path }) => path).filter((path) => !(path in commands) && !(path in skip));
+            assert.deepEqual(missing, [], `remote commands with no words in \`commands\` and no reason in \`skip\``);
+            const known = new Set(remote.map(({ path }) => path));
+            const stray = [...Object.keys(commands), ...Object.keys(skip)].filter((path) => !known.has(path));
+            assert.deepEqual(stray, [], "paths in `commands` or `skip` that are not remote commands of this program");
+        },
+    };
+    return [
+        coverage,
+        ...remote.flatMap((one) => {
+            const words = commands[one.path];
+            return words ? [recordedCase(one.path, words), timeoutCase(one, words)] : [];
+        }),
+    ];
+};

package/dist/mcp/app-server.js

@@ -124,8 +124,13 @@ export const serveAppOverStdio = async (command, context, options) => {
     });
     const ended = await new Promise((resolve) => {
         wire.ended.then(() => resolve("input"));
-        if (own)
-            signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+        if (own) {
+            // A stop that came before this line fires no abort event.
+            if (signal?.aborted)
+                resolve("stopped");
+            else
+                signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+        }
         else {
             process.once("SIGINT", () => resolve("stopped"));
             process.once("SIGTERM", () => resolve("stopped"));

package/dist/meetings/cli/index.d.ts

@@ -11,6 +11,11 @@ export interface MeetingCommandDeps {
     importHelp?: string;
     writeFile?: (path: string, content: string) => Promise<void>;
     write: (value: unknown, format: "json" | "jsonl" | "text") => void;
+    /**
+     * Runs a command that reaches the account inside cli-core's run, so it is recorded and ended by `--timeout`:
+     * `inCommandRun` from `@wirecat/cli-core/cli`. Required, since this module cannot reach the run itself.
+     */
+    inRun: <T>(command: Command, body: () => Promise<T>) => Promise<T>;
     now?: () => number;
 }
 export { addMeetingPassageCommand, createMeetingPassageCommand, type MeetingPassageFlags, meetingPassageRequest, } from "./passage.js";

package/dist/meetings/cli/index.js

@@ -121,14 +121,15 @@ const addMeetingCommandsDefinition = (program, deps) => {
         .option("--since-time <time>", "fetch meetings starting at or after this ISO 8601 date or time", date)
         .option("--lookback-days <days>", "revisit recent occurrences for late transcripts (0–31)", lookbackDays, 0)
         .action(async (opts, command) => {
-        if (!deps.source)
+        const source = deps.source;
+        if (!source)
             throw new MeetingError("configuration_error", "meeting source is unavailable");
-        print(await pull(deps.source, deps.store, {
+        await deps.inRun(command, async () => print(await pull(source, deps.store, {
             accountId: deps.accountId,
             since: opts.sinceTime === undefined ? undefined : new Date(opts.sinceTime).toISOString(),
             now: deps.now?.(),
             lookbackMs: opts.lookbackDays * 86400000,
-        }), command);
+        }), command));
     });
     const importCommand = annotate(group.command("import"), {
         effects: LOCAL_WRITE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.597.0",
+  "version": "0.598.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",