@wirecat/cli-core 0.590.0 → 0.591.0

package/CHANGELOG.md

@@ -7,6 +7,64 @@ shape of this file.
 
 ## Unreleased
 
+## 0.591.0 — 06.11.2026
+
+### Added
+
+- **`patiently` and `waitForTurn` are public.** `patiently` (`@wirecat/cli-core/services`) sits out a provider's
+  short "wait N seconds" a few times and ends the run on a long one. `waitForTurn(pacer, { name, operation, warn,
+  sleep })` (`@wirecat/cli-core/sends`) waits for a call's turn in the profile's shared pace, warns on a wait a person
+  would notice and refuses one longer than five minutes as `rate_limited`; the messenger layer uses the same one.
+- **`store.crm` writes a CRM account's copies.** `savePipelines` and `saveItems` upsert pipelines, stages, deals and
+  leads by the CRM's ids, with no review. A pipeline is keyed by its account, kind and id. An item's status is the
+  CRM's own when it gives one (Pipedrive keeps won and lost on the deal), else its stage's outcome. Money keeps its
+  minor units, the people on an item are `links` with their role, and the stage history counts from the CRM's own
+  times. `savePeople` stores contacts as identities through `savePeople`, joined to a person by exact email only,
+  their ids kept apart per account and type (`crmIdentityId`, `<account>/contact/<id>`; `<account>/user/<id>` is
+  kept for the CRM's users). `saveOrganizations` keeps each company as a source record whose organization is made
+  for it on first sight, never one found by name (WC-DATA-6). `remove` and `removeUnlisted` mark rows deleted
+  (WC-DATA-7), never one the CRM changed after the list began. An item whose stage is not stored, or whose money the
+  store refuses, is skipped and named. Neutral types (`CrmItem`, `CrmPipeline`, `CrmPerson`, `CrmOrganization`) are
+  in `@wirecat/cli-core`.
+- **`DealFilter.account` and `offset`, `pipelines({ account })`.** A list reads the owner's own (`"own"`) or one CRM
+  account's copies, a page at a time.
+
+- **`syncCrm` and the `CrmSource` port, in `@wirecat/cli-core/crm`.** A CRM CLI writes an adapter (`pipelines(kind)`,
+  `changes(kind, cursor, page)` answering a page or `{ reset: true }`, and `ids(kind, page)` when the CRM does not name
+  deletions) and the engine copies the account into the store: both kinds' pipelines, then companies, contacts, deals
+  and leads, each kind from its own cursor (`store.sync`, `crm:<kind>`), a page at a time, saved as it comes, so a
+  run its request budget, deadline or cancel stops goes on from there. A dead cursor starts a full round. An item
+  whose stage arrived after the pipelines were read gets them read again once; one still not kept is an issue, and
+  the round goes on. Deletions come from `changes()`, or from a list of every id that marks rows deleted only once
+  its last page arrived (resumable across runs), never a row changed since the list began, and never most of a kind
+  without `--rescan`: a sign-in that lost its rights lists no ids. `crmStatus` gives each kind's progress in the
+  shared shape.
+- **`@wirecat/cli-core/crm/testing`:** `crmSourceContract` for a CRM adapter, `crmSyncContract` for the engine over
+  a store, and `fakeCrmSource`, a CRM in memory with a change feed.
+- **`addCrmCommands(program, { app, open, leads? })`, in `@wirecat/cli-core/crm/cli`.** One set of commands for
+  every CRM CLI: root `sync` (`--rescan`, `--max-pages`, partial and cooperative, a safe next step), `store status`,
+  and `deals list|show`, `leads list|show`, `pipelines list|show` (with the funnel) and `stages list`, which read the
+  store, as the calendar's lists do, and only the profile's account. Lists take `status:`, `stage:`, `pipeline:` and
+  `organization:` (`DEALS_QUERY`, `LEADS_QUERY`), `--limit` and `--page`; what the CRM's users typed is marked
+  untrusted. `search all` reads the account's deals and leads beside the stored messages, notes and events, and
+  takes `--only crm`.
+- **Shared answer entities `deal`, `lead`, `pipeline` and `stage`.** memo's `deals`, `leads` and `pipelines` and every
+  CRM CLI answer them in one shape: a deal or lead as the store gives it, a pipeline with its stages and, from
+  `pipelines show`, its funnel.
+- **`schedule agent` and `schedule command` take `--notify-on always|failures|never`.** The value is kept as `notify` in
+  the schedule file and shown by `schedule list`. A schedule without it keeps working: an agent that repeats with
+  `--every` notifies on failures only, any other schedule as before. A schedule's `last.skipped` carries a dotted
+  `reason` next to `why`: `cost.day-cap`, `mail.none-new`, `mail.below-threshold`; `schedule run` answers with the same
+  `reason` when it skips.
+
+### Changed — may break callers
+
+- **`answerEntity` refuses `deal`, `lead`, `pipeline` and `stage`**, now shared entities: a CLI that declared its own
+  under those names answers the shared shape instead.
+- **`store.deals.add`, `move` and `close` leave a CRM's copies alone.** Moving or closing a copy is refused
+  (`deal.copy`): the CRM is where it changes. A stage or a pipeline named in `add` is looked up among the owner's own
+  pipelines only, so a synced CRM stage never makes it ambiguous.
+
 ## 0.590.0 — 06.11.2026
 
 ### Changed — may break callers

package/dist/background/schedules.d.ts

@@ -24,7 +24,13 @@ export interface Schedule {
     mailBatch?: number;
     /** An agent's: no run starts for the rest of the local day once its runs cost this much, in US dollars. */
     maxCostPerDay?: number;
+    /** When a finished run shows a desktop notice; absent means `notifyOf`'s default. */
+    notify?: Notify;
 }
+export declare const NOTIFY_WHEN: readonly ["always", "failures", "never"];
+export type Notify = (typeof NOTIFY_WHEN)[number];
+/** A repeating agent would otherwise notify on every tick; any other schedule runs rarely enough to say each result. */
+export declare const notifyOf: (schedule: Pick<Schedule, "kind" | "when" | "notify">) => Notify;
 /** What a gated agent waits for, and what a day of its runs may cost, when neither its flags nor the config say. */
 export declare const SCHEDULE_DEFAULTS: {
     readonly mailWaitMinutes: 30;
@@ -63,8 +69,16 @@ export interface LastRun {
     skipped?: {
         at: string;
         why: string;
+        reason?: SkipReason;
     };
 }
+/** Why a timer left a run out, as an id a translation can key on; `why` stays the English sentence. */
+export declare const SKIP_REASONS: {
+    readonly costDayCap: "cost.day-cap";
+    readonly mailNone: "mail.none-new";
+    readonly mailBelowThreshold: "mail.below-threshold";
+};
+export type SkipReason = (typeof SKIP_REASONS)[keyof typeof SKIP_REASONS];
 /**
  * Why a failed run failed, from the error object the CLI printed last: its code and reason id. Never the
  * message, which can name a chat or a person; the run's log keeps that. Any other line is another program's
@@ -90,7 +104,7 @@ export declare const recordRun: (path: string, run: {
     costUsd?: number;
 }) => LastRun;
 /** Notes on the last run that the timer left this one out, keeping that run's result. */
-export declare const recordSkip: (file: string, why: string, at?: Date) => void;
+export declare const recordSkip: (file: string, why: string, reason: SkipReason, at?: Date) => void;
 /**
  * One stderr line per failing background job, or nothing: `tg: scheduled digest failing since … (3 runs):
  * <reason> — tg schedule list`. A status the owner has to ask for is how a broken timer goes unnoticed.

package/dist/background/schedules.js

@@ -5,6 +5,9 @@ import { CliError, errorCodes, writeSecurely } from "@wirecat/cli-base";
 import { mailHolderVariable, readOnlyLockOf } from "../ports/app.js";
 import { recordLogFor } from "../runs/record-log.js";
 import { childTrace } from "../runs/scope.js";
+export const NOTIFY_WHEN = ["always", "failures", "never"];
+/** A repeating agent would otherwise notify on every tick; any other schedule runs rarely enough to say each result. */
+export const notifyOf = (schedule) => schedule.notify ?? (schedule.kind === "agent" && "every" in schedule.when ? "failures" : "always");
 /** What a gated agent waits for, and what a day of its runs may cost, when neither its flags nor the config say. */
 export const SCHEDULE_DEFAULTS = { mailWaitMinutes: 30, mailBatch: 10, maxCostPerDay: 5 };
 export const localDay = (at) => `${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, "0")}-${String(at.getDate()).padStart(2, "0")}`;
@@ -49,6 +52,12 @@ const reportOf = (stdout) => {
         return { text: stdout };
     }
 };
+/** Why a timer left a run out, as an id a translation can key on; `why` stays the English sentence. */
+export const SKIP_REASONS = {
+    costDayCap: "cost.day-cap",
+    mailNone: "mail.none-new",
+    mailBelowThreshold: "mail.below-threshold",
+};
 const REASON_ID = /^[a-z0-9][a-z0-9.-]{0,79}$/;
 /**
  * Why a failed run failed, from the error object the CLI printed last: its code and reason id. Never the
@@ -97,12 +106,13 @@ export const recordRun = (path, run) => {
     return last;
 };
 /** Notes on the last run that the timer left this one out, keeping that run's result. */
-export const recordSkip = (file, why, at = new Date()) => {
+export const recordSkip = (file, why, reason, at = new Date()) => {
     const path = join(file, "..", "last.json");
     const before = readRun(path);
-    if (!before)
+    // A timer ticking every few minutes would rewrite the file for the same cause each time.
+    if (!before || before.skipped?.reason === reason)
         return;
-    writeSecurely(path, `${JSON.stringify({ ...before, skipped: { at: at.toISOString(), why } }, null, 2)}\n`, 0o600);
+    writeSecurely(path, `${JSON.stringify({ ...before, skipped: { at: at.toISOString(), why, reason } }, null, 2)}\n`, 0o600);
 };
 const shortTime = (iso) => {
     const at = new Date(iso);
@@ -435,13 +445,14 @@ export const runSchedule = async (app, system, env, file, { now = () => new Date
         if (!kept.has(stampOf(file)))
             rmSync(join(runs, file), { force: true });
     const title = `${app.command} ${schedule.name}`;
-    if (agent && exitCode === 0) {
+    const mode = notifyOf(schedule);
+    if (agent && exitCode === 0 && mode === "always") {
         const first = readFileSync(output, "utf8")
             .split("\n")
             .find((line) => line.trim()) ?? "report ready";
         await notify(system, env, title, `${first.trim().slice(0, 180)}\n${join(folder, "latest.md")}`);
     }
-    else if (exitCode !== 0) {
+    else if (exitCode !== 0 && mode !== "never") {
         await notify(system, env, title, `failed (exit ${exitCode}) — ${errors}`);
     }
     if ("once" in schedule.when) {

package/dist/cli/messenger/flooded.d.ts

@@ -1,7 +1,7 @@
 import { type MessengerAdapter } from "../../ports/messenger.js";
 import { type Warn } from "../../runs/events.js";
 import { type FloodMemory } from "../../sends/flood.js";
-import type { Pacer } from "../../sends/pace.js";
+import { type Pacer } from "../../sends/pace.js";
 /**
  * The adapter, refusing a call the messenger already said to hold off on, before it is asked again;
  * remembering each new "wait" it answers; and stopping writes once it says the account may not write.

package/dist/cli/messenger/flooded.js

@@ -3,14 +3,11 @@ import { isCliFailure } from "../../errors/failures.js";
 import { throughWrapper } from "../../ports/messenger.js";
 import { providerErrorKey } from "../../runs/events.js";
 import { holdEnd } from "../../sends/flood.js";
+import { waitForTurn } from "../../sends/pace.js";
 const LONG_LIVED = new Set(["self", "newSendId", "close", "formatMarkdown", "formatHtml", "storedChats"]);
 /** Neither held nor paced, as they listen for as long as the run does; what ends them is still remembered. */
 const LISTENING = new Set(["watch", "feed", "listen", "listenHistory"]);
 const BLOCKING = new Set(["frozen", "limited", "banned"]);
-/** Shorter waits for the pace pass unannounced; a person at a terminal would not notice them. */
-const ANNOUNCE_WAIT_MS = 5_000;
-/** Longer than this the pace refuses instead of waiting, as a run already ends at a wait this long. */
-const LONGEST_PACE_WAIT_MS = 5 * 60_000;
 const chatOf = (args) => typeof args[0] === "string" && /^-?\d+$/.test(args[0]) ? args[0] : undefined;
 /**
  * The adapter, refusing a call the messenger already said to hold off on, before it is asked again;
@@ -73,28 +70,8 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
             await kept(operation, () => pacer.holdFor(waitMs));
     };
     const turn = async (operation) => {
-        if (!pacer)
-            return;
-        let at = Date.now();
-        await kept(operation, async () => {
-            at = await pacer.reserve();
-        });
-        const waitMs = at - Date.now();
-        if (waitMs <= 0)
-            return;
-        if (waitMs > LONGEST_PACE_WAIT_MS) {
-            throw new CliError("rate_limited", `${name} asked this profile to wait, ${Math.ceil(waitMs / 1000)} s are left — nothing was sent to ${name}`, { retry_after_ms: waitMs, retry_at: new Date(at).toISOString(), remembered: true });
-        }
-        if (waitMs >= ANNOUNCE_WAIT_MS) {
-            const seconds = Math.ceil(waitMs / 1000);
-            warn(`waiting ${seconds} s to keep this profile's pace with ${name}`, {
-                event: "warning",
-                code: "pace_wait",
-                operation,
-                counts: { seconds },
-            });
-        }
-        await new Promise((resolve) => setTimeout(resolve, waitMs));
+        if (pacer)
+            await waitForTurn(pacer, { name, operation, warn });
     };
     return throughWrapper(messenger, {}, (operation, call) => {
         if (LONG_LIVED.has(operation))

package/dist/cli/messenger/search-command.d.ts

@@ -2,14 +2,15 @@ import { Command } from "commander";
 import type { SearchAllIncludingMeetingsFound } from "../../services/search-all-meetings.js";
 import { type Messenger } from "./context.js";
 import { type SourceSearched } from "./search-answers.js";
-export declare const searchAllOnlyOf: (value: string) => SourceSearched[];
+export declare const searchAllOnlyOf: (value: string, allowed?: readonly string[]) => SourceSearched[];
 /** One `search all` hit as a person reads it. */
 export declare const searchAllLine: (item: SearchAllIncludingMeetingsFound["items"][number]) => string;
 /**
  * `search all`'s scope, paging and matching options, the same in every CLI that mounts it (WC-ACCT-8): a messenger's
  * and a calendar's.
  */
-export declare const searchAllOptions: (command: Command) => Command;
+/** `allowed`: the resources `--only` takes, a CRM CLI's with `crm`. */
+export declare const searchAllOptions: (command: Command, allowed?: readonly string[]) => Command;
 /**
  * `search <resource>`: every search of the tool, one leaf per resource (STANDARD.md, "Search
  * hierarchy"). `topics` only where the CLI has forum topics.

package/dist/cli/messenger/search-command.js

@@ -16,13 +16,13 @@ import { messagesSearchCommand } from "./messages-search-command.js";
 import { allAnswer, meaningNote, notesAnswer, offsetOf, SOURCE_SEARCHED, shownOf, } from "./search-answers.js";
 import { backendOptions, backendRequest, noteServer } from "./search-backend-options.js";
 import { topicsSearchCommand } from "./topics-command.js";
-export const searchAllOnlyOf = (value) => {
+export const searchAllOnlyOf = (value, allowed = SOURCE_SEARCHED) => {
     const chosen = value.split(",").map((one) => one.trim());
     if (chosen.includes("mail"))
         throw new CliError("validation_error", "mail is searched by the separate memo CLI: install @wirecat/cli-memo, then `memo search mail …`");
-    const unknown = chosen.find((one) => !SOURCE_SEARCHED.includes(one));
+    const unknown = chosen.find((one) => !allowed.includes(one));
     if (unknown !== undefined || chosen.length === 0)
-        throw new CliError("validation_error", `--only takes ${SOURCE_SEARCHED.join(", ")}, separated by commas; meetings when --source names a meeting account`);
+        throw new CliError("validation_error", `--only takes ${allowed.join(", ")}, separated by commas; meetings when --source names a meeting account`);
     return [...new Set(chosen)];
 };
 /** One `search all` hit as a person reads it. */
@@ -40,8 +40,10 @@ const maxMeetingsOf = (value) => {
  * `search all`'s scope, paging and matching options, the same in every CLI that mounts it (WC-ACCT-8): a messenger's
  * and a calendar's.
  */
-export const searchAllOptions = (command) => command
-    .option("--only <resources>", "only these resources, separated by commas: messages, notes, events; meetings when --source names a meeting account", searchAllOnlyOf)
+/** `allowed`: the resources `--only` takes, a CRM CLI's with `crm`. */
+export const searchAllOptions = (command, allowed = SOURCE_SEARCHED) => command
+    .option("--only <resources>", `only these resources, separated by commas: ${allowed.filter((one) => one !== "meetings").join(", ")}; ` +
+    "meetings when --source names a meeting account", (value) => searchAllOnlyOf(value, allowed))
     .option("--source <accounts>", "only these accounts, separated by commas: provider:account as a hit shows it, a provider, a kind or " +
     "group:<name>; each resource reads the ones of its kind, and meetings only when it names one")
     .option("--max-meetings <n>", "how many of the meeting account's meetings to look through, newest first, or all for every one (default 100)", maxMeetingsOf)

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/schedule/schedule-command.js

@@ -3,7 +3,7 @@ import { dirname, join } from "node:path";
 import { CliError, resolvePaths, writeSecurely } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Argument, Command, Option } from "commander";
-import { describeWhen, findProgram, lastRun, listSchedules, readSchedule, recordSkip, runSchedule, SCHEDULE_DEFAULTS, scheduleFile, scheduleName, spentToday, timerFor, } from "../../background/schedules.js";
+import { describeWhen, findProgram, lastRun, listSchedules, NOTIFY_WHEN, notifyOf, readSchedule, recordSkip, runSchedule, SCHEDULE_DEFAULTS, SKIP_REASONS, scheduleFile, scheduleName, spentToday, timerFor, } from "../../background/schedules.js";
 import { thisMachine } from "../../background/system.js";
 import { locationVariables } from "../../background/units.js";
 import { parseDuration } from "../../domain/duration.js";
@@ -79,7 +79,8 @@ const scheduleAnswer = ({ environment, createdAt, ...schedule }, extra) => ({
 const withWhen = (command) => command
     .option("--every <duration>", "repeat: 30m, 2h, 1d")
     .option("--at <HH:MM>", "every day at this local time")
-    .option("--at-time <time>", "one run: 30m, 2d from now, or an ISO time; the schedule removes itself after it");
+    .option("--at-time <time>", "one run: 30m, 2d from now, or an ISO time; the schedule removes itself after it")
+    .addOption(new Option("--notify-on <when>", "desktop notice after a run (default failures for an agent that repeats with --every, else always)").choices(NOTIFY_WHEN));
 /** What the schedule command needs of a CLI: who it is and, per command, where it prints and which profile runs. */
 /** `skill show follow-ups` exists only for messenger CLIs; any other CLI gets a read-only summary it can run. */
 const promptExample = (app) => app.messenger === false
@@ -209,8 +210,8 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             const spent = spentToday(file);
             if (spent >= maxCostPerDay) {
                 const why = `today's runs cost ${usd(spent)}, the ${usd(maxCostPerDay)} a day allowed; it runs again tomorrow`;
-                recordSkip(file, why);
-                return why;
+                recordSkip(file, why, SKIP_REASONS.costDayCap);
+                return { why, reason: SKIP_REASONS.costDayCap };
             }
         }
         const holder = schedule.onNewMail;
@@ -219,13 +220,18 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
         const waiting = await newMail(self, holder);
         if (waiting.unmarked)
             return undefined;
-        if (waiting.emails === 0)
-            return `no mail stored past ${holder}'s mark`;
+        if (waiting.emails === 0) {
+            const why = `no mail stored past ${holder}'s mark`;
+            recordSkip(file, why, SKIP_REASONS.mailNone);
+            return { why, reason: SKIP_REASONS.mailNone };
+        }
         const waited = waiting.oldestStoredAt === null ? 0 : Date.now() - waiting.oldestStoredAt;
         if (!timed || waiting.emails >= mailBatch || waited >= mailWaitMinutes * 60_000)
             return undefined;
-        return (`${waiting.emails} email(s) wait past ${holder}'s mark; it starts at ${mailBatch}, ` +
-            `or once the oldest has waited ${mailWaitMinutes}m`);
+        const why = `${waiting.emails} email(s) wait past ${holder}'s mark; it starts at ${mailBatch}, ` +
+            `or once the oldest has waited ${mailWaitMinutes}m`;
+        recordSkip(file, why, SKIP_REASONS.mailBelowThreshold);
+        return { why, reason: SKIP_REASONS.mailBelowThreshold };
     };
     withWhen(grantsAuthority(annotate(command.command("command"), {
         literal_after_dashes: true,
@@ -248,6 +254,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             when: whenOf(this.opts(), COMMAND_MINIMUM_MINUTES),
             environment: environment(),
             createdAt: new Date().toISOString(),
+            ...(this.opts().notifyOn ? { notify: this.opts().notifyOn } : {}),
         });
     });
     withWhen(grantsAuthority(annotate(command.command("agent"), {
@@ -329,6 +336,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             ...(mailWaitMinutes === undefined ? {} : { mailWaitMinutes }),
             ...(mailBatch === undefined ? {} : { mailBatch }),
             ...(options.maxCostPerDay === undefined ? {} : { maxCostPerDay: options.maxCostPerDay }),
+            ...(options.notifyOn ? { notify: options.notifyOn } : {}),
         });
     });
     if (newMail)
@@ -349,6 +357,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             name: schedule.name,
             kind: schedule.kind,
             when: describeWhen(schedule.when),
+            notify: notifyOf(schedule),
             last: lastRun(scheduleFile(state, schedule.name)) ?? null,
             ...(schedule.kind === "agent"
                 ? {
@@ -369,10 +378,11 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
                 return "";
             }
             return rows
-                .map(({ name, kind, when, last, spentTodayUsd, maxCostPerDayUsd }) => [
+                .map(({ name, kind, when, notify, last, spentTodayUsd, maxCostPerDayUsd }) => [
                 name,
                 kind,
                 when,
+                `notify ${notify}`,
                 last
                     ? `last ${last.at.slice(0, 16).replace("T", " ")} exit ${last.exitCode}` +
                         (last.failures
@@ -398,9 +408,10 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
         .argument("<name>", "the schedule's name, as `schedule list` shows it")
         .action(async function (name) {
         const { context, system, state, say, timer } = prepare(this);
-        const why = await waits(this, scheduleFile(state, scheduleName(name)), { timed: false });
-        if (why !== undefined)
-            return say({ name, skipped: true, why }, [`${name}: skipped — ${why}`]);
+        const skip = await waits(this, scheduleFile(state, scheduleName(name)), { timed: false });
+        if (skip !== undefined) {
+            return say({ name, skipped: true, why: skip.why, reason: skip.reason }, [`${name}: skipped — ${skip.why}`]);
+        }
         const last = await untilChildEnds(this, (signal) => runSchedule(app, system, context.env, scheduleFile(state, scheduleName(name)), {
             timer: timer(),
             agentRuns,

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

@@ -0,0 +1,57 @@
+import { type Command } from "commander";
+import { type Body } from "../../cli/envelope.js";
+import type { AppIdentity } from "../../ports/app.js";
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { CrmSource } from "../source.js";
+/**
+ * The selected profile's CRM account, opened by the app for one command and closed once its answer is built, before
+ * anything is printed (WC-LIFE-4).
+ */
+export interface CrmRun {
+    /** The profile's name, which `store status` gives as each sync's `profile`. */
+    profile: string;
+    /** The profile's CRM account as the shared store names it: every command reads and syncs only it. */
+    account: AccountKey;
+    store: MessageStore;
+    /** The CRM, built on first use: a command that only reads the store never reads the sign-in. */
+    source: () => CrmSource;
+    /** A profile lock pins the process (WC-ACCT-5): `search all` then reads only this account's deals. */
+    locked?: boolean;
+    env?: NodeJS.ProcessEnv;
+    close?: () => Promise<void>;
+}
+export interface CrmCommandOptions {
+    /** The CLI itself: the first word of examples, and `search all`. */
+    app: AppIdentity;
+    /** Opens the selected profile for one command; `readOnly` when the command only reads the store. */
+    open: (command: Command, access: {
+        readOnly: boolean;
+    }) => Promise<CrmRun>;
+    /** The CRM has leads: mounts `leads list|show`. True when absent. */
+    leads?: boolean;
+    now?: () => number;
+}
+/** What `deals list` and `leads list` narrow by, the same in memo and every CRM CLI (WC-OUT-11). */
+export declare const DEALS_QUERY: {
+    readonly entity: "deal";
+    readonly backend: "native";
+    readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
+};
+export declare const LEADS_QUERY: {
+    readonly entity: "lead";
+    readonly backend: "native";
+    readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
+};
+export declare const PIPELINES_QUERY: {
+    readonly entity: "pipeline";
+    readonly backend: "native";
+    readonly fields: readonly [import("@wirecat/cli-base/query").FieldSpec];
+};
+export declare const STAGES_QUERY: {
+    readonly entity: "stage";
+    readonly backend: "native";
+    readonly fields: readonly [import("@wirecat/cli-base/query").FieldSpec, import("@wirecat/cli-base/query").FieldSpec];
+};
+export type CrmWithin = (command: Command, work: (run: CrmRun) => Promise<Body>) => Promise<void>;
+export declare const addCrmCommands: (program: Command, options: CrmCommandOptions) => void;