@indigoai-us/hq-cli 5.289.0 → 5.291.0

package/dist/commands/cloud.js

@@ -22,6 +22,10 @@ import { resolveUploadAuthor } from "../utils/upload-author.js";
 import { companyFolderExceedsThreshold, emitNarrowHint, isStrictRefusal, resolveBannerLevel, resolveNarrowHintPresentationLevel, resolveNarrowHintMinBytes, } from "../lib/narrow-hint-banner.js";
 import { beginSyncHealthReport, } from "../utils/client-health.js";
 import { recordFirstWorkBearingSync } from "../lib/first-sync-next-step.js";
+import { createPlanLimitRefusalTracker, describeRefusedCount, describeRefusedFiles, mergePlanLimitRefusals, renderPlanLimitRefusalLines, trackingProgressRecorder, } from "../lib/billing/plan-limit-refusals.js";
+import { formatPlanGateError, planGateErrorFromVaultError, } from "../utils/plan-gate-error.js";
+import { personalTargetedPushPathsEnabled } from "./personal-targeted-push-flag.js";
+import { resolveExplicitPersonalPushPaths } from "./personal-targeted-push-paths.js";
 /**
  * Terminal-failure signal for the sync fanout runners. The runners
  * (`runPushAll` / `runPullAll` / `runPullPersonal` / `runNowSingle` /
@@ -35,10 +39,18 @@ import { recordFirstWorkBearingSync } from "../lib/first-sync-next-step.js";
  */
 export class SyncExitError extends Error {
     code;
-    constructor(code) {
+    /**
+     * The client-health outcome to record for this exit. A run whose only
+     * problem was a plan-limit refusal exits non-zero (it did not upload what
+     * was asked) but is not a sync failure: the engine worked and the refusal
+     * is plan state, so it must not count toward `consecutiveFailures`.
+     */
+    health;
+    constructor(code, opts = {}) {
         super(`sync command exit ${code}`);
         this.code = code;
         this.name = "SyncExitError";
+        this.health = opts.health ?? "failed";
     }
 }
 /**
@@ -47,6 +59,16 @@ export class SyncExitError extends Error {
  * CLI are released independently.
  */
 export function formatSyncFailure(err) {
+    // A plan-limit refusal the runner threw (a 402 on the whole request) renders
+    // with the same reason, fix options and upgrade link as every other refusal.
+    const planGate = planGateErrorFromVaultError(err);
+    if (planGate) {
+        const refusedPath = typeof err.path === "string"
+            ? err.path
+            : undefined;
+        return (formatPlanGateError(planGate) +
+            (refusedPath ? `\nNot uploaded: ${refusedPath}` : ""));
+    }
     if (isAccessDeniedError(err)) {
         const key = accessDeniedKeyOf(err);
         const base = err instanceof Error ? err.message : String(err);
@@ -92,7 +114,12 @@ export async function withSyncHealthReport(run) {
         return result;
     }
     catch (err) {
-        await health.failed();
+        if (err instanceof SyncExitError && err.health === "succeeded") {
+            await health.succeeded();
+        }
+        else {
+            await health.failed();
+        }
         if (err instanceof SyncExitError)
             process.exit(err.code);
         throw err;
@@ -418,6 +445,7 @@ export async function pushAll(options, deps) {
             companyUid: m.companyUid,
             shareOptions: {
                 company: m.companyUid,
+                targetSlug: slug,
                 hqRoot: options.hqRoot,
                 paths: [path.join(options.hqRoot, "companies", slug)],
                 skipUnchanged: true,
@@ -526,21 +554,15 @@ export async function resolveCanonicalPersonUid(vaultClient) {
     return pick.uid;
 }
 /**
- * Refuse `hq sync push --personal <path>` — the combination silently
- * bypasses `PERSONAL_VAULT_EXCLUDED_TOP_LEVEL` (which is only applied by
- * `computePersonalVaultPaths`), risking cross-scope upload of `companies/`,
- * `repos/`, `workspace/`, or `.git/` content to the personal vault. Real
- * incident (2026-05-21): a single command uploaded 196 `companies/{slug}/**`
- * objects to a personal vault before being killed. Cleanup required a
- * hand-rolled S3 sweep. Closes hq-cli#25.
- *
- * Refusal — not silent filtering — is intentional: explicit is better than
- * implicit guesswork, and the legitimate "I want to push a subset of my
- * personal vault" use case has a clean workaround (drop `--personal`, the
- * subset upload targets the active company via standard semantics).
+ * Keep `hq sync push --personal <path>` refused by default. Positional paths
+ * bypass `computePersonalVaultPaths` and can send excluded `companies/`,
+ * `repos/`, `workspace/`, or `.git/` content to the personal vault. The
+ * default-off targeted-paths gate allows the combination only after every
+ * path is realpath-normalized and checked against the computed personal scope
+ * and its file exclusions. Closes hq-cli#25.
  */
-export function assertNoPersonalPositionalPaths(opts, paths) {
-    if (opts.personal && paths && paths.length > 0) {
+export function assertNoPersonalPositionalPaths(opts, paths, targetedPersonalPathsEnabled = false) {
+    if (opts.personal && paths && paths.length > 0 && !targetedPersonalPathsEnabled) {
         throw new Error("`--personal` cannot be combined with explicit [paths]: " +
             "positional paths bypass the PERSONAL_VAULT_EXCLUDED_TOP_LEVEL " +
             "guard (skips .git/, companies/, repos/, workspace/), risking " +
@@ -670,6 +692,32 @@ async function resolveCliPullScope(client, companyRef, hqRoot) {
     }
     return resolvePullScope(client, companyUid, slug, hqRoot);
 }
+/**
+ * The progress-snapshot label share()'s default recorder would use: the
+ * target's slug, or null for a personal-vault push. A pre-vended context
+ * carries its slug; otherwise the caller's company reference is the best the
+ * CLI knows before share() resolves it.
+ */
+function shareProgressCompany(input) {
+    if (input.personalMode)
+        return null;
+    if (input.entityContext) {
+        return input.entityContext.uid.startsWith("prs_")
+            ? null
+            : input.entityContext.slug;
+    }
+    return input.companyRef ?? null;
+}
+/** Only a real slug builds a company billing link; a raw uid does not. */
+function companySlugForBilling(label) {
+    return label && !/^(?:cmp|prs)_/.test(label) ? { companySlug: label } : {};
+}
+/** Print one push leg's refusal block under its row. */
+function printPlanLimitRefusal(summary, indent = "    ") {
+    for (const line of renderPlanLimitRefusalLines(summary, indent)) {
+        console.log(chalk.yellow(line));
+    }
+}
 export function registerCloudCommands(program) {
     program
         .command("push")
@@ -736,7 +784,13 @@ export function registerCloudCommands(program) {
             // the fanout" — wired through to `pushAll.skipPersonal`. Outside
             // `--all` the flag has no effect (logged above as part of the
             // option's help text).
-            await withSyncHealthReport(() => runPushAll(options.hqRoot, options.message, options.onConflict, options.personal === false));
+            await withSyncHealthReport(async () => {
+                const refused = await runPushAll(options.hqRoot, options.message, options.onConflict, options.personal === false);
+                // A plan-limit refusal is not a sync failure, but the push did
+                // not upload everything it was asked to: exit non-zero.
+                if (refused)
+                    throw new SyncExitError(1, { health: "succeeded" });
+            });
             return;
         }
         const jsonMode = options.json === true;
@@ -752,6 +806,7 @@ export function registerCloudCommands(program) {
         // Assigned right before the sync engine runs, so option-validation
         // failures never count as a sync attempt (US-003).
         let syncHealth;
+        let explicitPersonalPaths;
         try {
             if (options.personal && options.credsFromStdin) {
                 throw new Error("`--personal` cannot be combined with --creds-from-stdin: " +
@@ -760,7 +815,11 @@ export function registerCloudCommands(program) {
                     "to have already resolved entity + credentials. Pick one.");
             }
             // Closes hq-cli#25 — see `assertNoPersonalPositionalPaths` doc-block.
-            assertNoPersonalPositionalPaths(options, paths);
+            const targetedPersonalPathsEnabled = Boolean(options.personal && paths && paths.length > 0 && personalTargetedPushPathsEnabled());
+            assertNoPersonalPositionalPaths(options, paths, targetedPersonalPathsEnabled);
+            if (targetedPersonalPathsEnabled) {
+                explicitPersonalPaths = resolveExplicitPersonalPushPaths(options.hqRoot, paths);
+            }
             log(chalk.bold("\nHQ Sync — Push"));
             log(`  HQ root:  ${options.hqRoot}`);
             // Resolve credentials. Two paths:
@@ -818,11 +877,13 @@ export function registerCloudCommands(program) {
             // Otherwise preserve the historical "default to cwd" semantics so
             // `hq sync push <file>` and bare `hq sync push` from inside the
             // company tree both work as before.
-            const targetPaths = paths && paths.length > 0
-                ? paths
-                : options.personal
-                    ? computePersonalVaultPaths(options.hqRoot)
-                    : [process.cwd()];
+            const targetPaths = explicitPersonalPaths
+                ? explicitPersonalPaths
+                : paths && paths.length > 0
+                    ? paths
+                    : options.personal
+                        ? computePersonalVaultPaths(options.hqRoot)
+                        : [process.cwd()];
             log(`  Company:  ${options.personal
                 ? `(personal: ${targetCompany})`
                 : (options.company ?? "(from .hq/config.json or stdin)")}`);
@@ -846,6 +907,16 @@ export function registerCloudCommands(program) {
                 const scope = await resolveCliPullScope(scopeClient, targetCompany, options.hqRoot);
                 pushPrefixSet = scope?.prefixSet;
             }
+            // Collect plan-limit refusals from the runner's events through the
+            // progress-recorder seam, which (unlike onEvent) leaves share()'s own
+            // console output untouched. The snapshot label mirrors share()'s
+            // default recorder: the target slug, or null for the personal vault.
+            const progressCompany = shareProgressCompany({
+                personalMode,
+                entityContext,
+                companyRef: targetCompany ?? readActiveCompany(options.hqRoot),
+            });
+            const planLimitTracker = createPlanLimitRefusalTracker(companySlugForBilling(progressCompany));
             syncHealth = beginSyncHealthReport();
             const result = await share({
                 paths: targetPaths,
@@ -859,16 +930,20 @@ export function registerCloudCommands(program) {
                 }),
                 hqRoot: options.hqRoot,
                 onEvent,
+                progressRecorder: trackingProgressRecorder(planLimitTracker, progressCompany),
                 ...(personalMode ? { personalMode: true } : {}),
                 ...(journalSlug !== undefined ? { journalSlug } : {}),
                 ...(author ? { author } : {}),
                 ...(pushPrefixSet !== undefined ? { prefixSet: pushPrefixSet } : {}),
             });
+            const planLimitRefused = planLimitTracker.summary();
             if (jsonMode) {
                 // Synthetic terminal event so subprocess consumers can read final
                 // counts without summing per-file events. Distinguished from
                 // SyncProgressEvent by `type:"complete"` (not in the share()
-                // event schema — added at the CLI seam).
+                // event schema — added at the CLI seam). `planLimitRefused` is
+                // additive: present only when a plan limit refused new files, so a
+                // consumer never has to infer a refusal from the counts.
                 emitJson({
                     type: "complete",
                     filesUploaded: result.filesUploaded,
@@ -876,6 +951,7 @@ export function registerCloudCommands(program) {
                     filesSkipped: result.filesSkipped,
                     conflictPaths: result.conflictPaths,
                     aborted: result.aborted,
+                    ...(planLimitRefused ? { planLimitRefused } : {}),
                 });
             }
             if (result.aborted) {
@@ -888,6 +964,26 @@ export function registerCloudCommands(program) {
                 filesDeleted: result.filesDeleted,
                 aborted: result.aborted,
             });
+            if (planLimitRefused) {
+                // Never a success line over a refusal: say what was pushed, what
+                // was refused and how to fix it, then exit non-zero. The sync
+                // itself worked, so client health records a success. `--json`
+                // callers read `planLimitRefused` on the complete event instead
+                // and keep their exit status.
+                log(chalk.yellow(`\n⚠ Pushed ${result.filesUploaded} file(s) (${formatBytes(result.bytesUploaded)}, ` +
+                    `${result.filesSkipped} skipped), but ${describeRefusedFiles(planLimitRefused)} ` +
+                    "refused by your plan limit."));
+                for (const line of renderPlanLimitRefusalLines(planLimitRefused)) {
+                    log(chalk.yellow(line));
+                }
+                for (const line of scopeExcludedLines(result.filesExcludedByScope, pushPrefixSet)) {
+                    log(chalk.yellow(line));
+                }
+                await syncHealth.succeeded();
+                if (!jsonMode)
+                    process.exit(1);
+                return;
+            }
             if (result.filesExcludedByScope > 0) {
                 log(chalk.yellow(`\n⚠ Pushed ${result.filesUploaded} file(s) (${formatBytes(result.bytesUploaded)}, ` +
                     `${result.filesSkipped} skipped, ${result.filesExcludedByScope} scope-excluded)`));
@@ -1398,6 +1494,11 @@ export async function runPullPersonal(hqRoot, onConflict) {
         throw new SyncExitError(1);
     }
 }
+/**
+ * Run `push --all` and print its per-target report. Returns the files a plan
+ * limit refused across every target (null when none were), so the caller can
+ * refuse to report success; hard failures still throw {@link SyncExitError}.
+ */
 async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
     console.log(chalk.bold("\nHQ Sync — Push (all)"));
     console.log(`  HQ root:  ${hqRoot}`);
@@ -1432,31 +1533,39 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
         }, {
             vaultClient: adapter,
             resolveScope: (companyUid, slug) => resolvePullScope(realClient, companyUid, slug, hqRoot),
-            share: (opts) => share({
-                paths: opts.paths,
-                company: opts.company,
-                vaultConfig,
-                hqRoot: opts.hqRoot,
-                ...(opts.onConflict ? { onConflict: opts.onConflict } : {}),
-                ...(opts.personalMode !== undefined
-                    ? { personalMode: opts.personalMode }
-                    : {}),
-                ...(opts.journalSlug !== undefined
-                    ? { journalSlug: opts.journalSlug }
-                    : {}),
-                ...(opts.message !== undefined ? { message: opts.message } : {}),
-                ...(opts.skipUnchanged !== undefined
-                    ? { skipUnchanged: opts.skipUnchanged }
-                    : {}),
-                ...(opts.propagateDeletes !== undefined
-                    ? { propagateDeletes: opts.propagateDeletes }
-                    : {}),
-                ...(opts.propagateDeletePolicy !== undefined
-                    ? { propagateDeletePolicy: opts.propagateDeletePolicy }
-                    : {}),
-                ...(opts.prefixSet !== undefined ? { prefixSet: opts.prefixSet } : {}),
-                ...(author ? { author } : {}),
-            }),
+            share: async (opts) => {
+                const progressCompany = opts.personalMode
+                    ? null
+                    : (opts.targetSlug ?? opts.company);
+                const tracker = createPlanLimitRefusalTracker(companySlugForBilling(progressCompany));
+                const shareResult = await share({
+                    paths: opts.paths,
+                    company: opts.company,
+                    vaultConfig,
+                    hqRoot: opts.hqRoot,
+                    progressRecorder: trackingProgressRecorder(tracker, progressCompany),
+                    ...(opts.onConflict ? { onConflict: opts.onConflict } : {}),
+                    ...(opts.personalMode !== undefined
+                        ? { personalMode: opts.personalMode }
+                        : {}),
+                    ...(opts.journalSlug !== undefined
+                        ? { journalSlug: opts.journalSlug }
+                        : {}),
+                    ...(opts.message !== undefined ? { message: opts.message } : {}),
+                    ...(opts.skipUnchanged !== undefined
+                        ? { skipUnchanged: opts.skipUnchanged }
+                        : {}),
+                    ...(opts.propagateDeletes !== undefined
+                        ? { propagateDeletes: opts.propagateDeletes }
+                        : {}),
+                    ...(opts.propagateDeletePolicy !== undefined
+                        ? { propagateDeletePolicy: opts.propagateDeletePolicy }
+                        : {}),
+                    ...(opts.prefixSet !== undefined ? { prefixSet: opts.prefixSet } : {}),
+                    ...(author ? { author } : {}),
+                });
+                return { ...shareResult, planLimit: tracker.summary() };
+            },
         });
     }
     catch (err) {
@@ -1465,28 +1574,42 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
         // terminal sync_failure before exiting on our behalf.
         throw new SyncExitError(1);
     }
+    let refused = null;
+    let refusedTargets = 0;
     for (const row of result.perCompany) {
         if (row.error) {
             console.log(chalk.red(`  ✗ ${row.slug}: ${row.error}`));
         }
         else if (row.result) {
             const r = row.result;
-            const status = r.aborted || r.filesExcludedByScope > 0
+            const legRefused = r.planLimit ?? null;
+            const status = r.aborted || r.filesExcludedByScope > 0 || legRefused
                 ? chalk.yellow("⚠")
                 : chalk.green("✓");
             console.log(`  ${status} ${row.slug}: ${r.filesUploaded} file(s), ` +
                 `${formatBytes(r.bytesUploaded)}, ${r.filesSkipped} skipped, ` +
                 `${r.filesDeleted} deleted, ${r.filesExcludedByScope} scope-excluded, ` +
                 `${r.conflictPaths.length} conflict(s)` +
-                (r.aborted ? " — aborted" : ""));
+                (r.aborted ? " — aborted" : "") +
+                (legRefused
+                    ? ` — ${describeRefusedCount(legRefused)} refused by plan limit`
+                    : ""));
+            if (legRefused) {
+                printPlanLimitRefusal(legRefused);
+                refused = mergePlanLimitRefusals(refused, legRefused);
+                refusedTargets += 1;
+            }
         }
     }
     const errored = result.errors.length;
     const summary = `\nPushed ${result.filesUploaded} file(s) ` +
         `(${formatBytes(result.bytesUploaded)}) across ${result.attempted} ` +
         `target(s); ${result.filesDeleted} deleted; ${errored} error(s); ` +
-        `${result.filesExcludedByScope} scope-excluded`;
-    console.log(errored > 0 || result.filesExcludedByScope > 0
+        `${result.filesExcludedByScope} scope-excluded` +
+        (refusedTargets > 0
+            ? `; new files refused by a plan limit on ${refusedTargets} target(s)`
+            : "");
+    console.log(errored > 0 || result.filesExcludedByScope > 0 || refusedTargets > 0
         ? chalk.yellow(summary)
         : chalk.green(summary));
     for (const row of result.perCompany) {
@@ -1506,6 +1629,7 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
     }
     if (errored > 0)
         throw new SyncExitError(1);
+    return refused;
 }
 async function runNowSingle(hqRoot, company, personal, message, onConflict, modeAllOverride, forceScopeShrink) {
     console.log(chalk.bold("\nHQ Sync — Now"));
@@ -1523,6 +1647,7 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
         let personalMode = false;
         let journalSlug;
         let pushPaths;
+        let pushSlug;
         if (personal) {
             const client = new VaultClient(vaultConfig);
             targetCompany = await resolveCanonicalPersonUid({
@@ -1547,6 +1672,7 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
                     "Use --company <slug>, --personal, or set up .hq/config.json.");
             }
             pushPaths = [path.join(hqRoot, "companies", slug)];
+            pushSlug = slug;
         }
         // Push first so the subsequent pull doesn't redownload files we were
         // about to broadcast (matches hq-sync-runner ordering).
@@ -1557,11 +1683,14 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
             const pushScope = await resolveCliPullScope(scopeClient, targetCompany, hqRoot);
             nowPushPrefixSet = pushScope?.prefixSet;
         }
+        const pushProgressCompany = personalMode ? null : (pushSlug ?? null);
+        const planLimitTracker = createPlanLimitRefusalTracker(companySlugForBilling(pushProgressCompany));
         const pushResult = await share({
             paths: pushPaths,
             company: targetCompany,
             vaultConfig,
             hqRoot,
+            progressRecorder: trackingProgressRecorder(planLimitTracker, pushProgressCompany),
             skipUnchanged: true,
             propagateDeletes: true,
             propagateDeletePolicy: resolveDeletePolicy(),
@@ -1572,13 +1701,19 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
             ...(author ? { author } : {}),
             ...(nowPushPrefixSet !== undefined ? { prefixSet: nowPushPrefixSet } : {}),
         });
-        const pushStatus = pushResult.aborted || pushResult.filesExcludedByScope > 0
+        const pushRefused = planLimitTracker.summary();
+        const pushStatus = pushResult.aborted || pushResult.filesExcludedByScope > 0 || pushRefused
             ? chalk.yellow("⚠")
             : chalk.green("✓");
         console.log(`    ${pushStatus} ` +
             `${pushResult.filesUploaded} uploaded, ${pushResult.filesSkipped} skipped, ` +
             `${pushResult.filesDeleted} deleted, ${pushResult.filesExcludedByScope} scope-excluded` +
-            (pushResult.aborted ? " — aborted" : ""));
+            (pushResult.aborted ? " — aborted" : "") +
+            (pushRefused
+                ? ` — ${describeRefusedCount(pushRefused)} refused by plan limit`
+                : ""));
+        if (pushRefused)
+            printPlanLimitRefusal(pushRefused, "      ");
         if (pushResult.filesExcludedByScope > 0) {
             for (const line of scopeExcludedLines(pushResult.filesExcludedByScope, nowPushPrefixSet)) {
                 console.log(chalk.yellow(line));
@@ -1698,6 +1833,12 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
                 level: bannerLevel,
             });
         }
+        if (pushRefused) {
+            // The pull ran, but the push did not upload everything: no success line.
+            console.log(chalk.yellow(`\n⚠ Sync now finished, but ${describeRefusedFiles(pushRefused)} ` +
+                "refused by your plan limit (listed above)."));
+            throw new SyncExitError(1, { health: "succeeded" });
+        }
         console.log(chalk.green("\n✓ Sync now complete"));
     }
     catch (err) {
@@ -1719,12 +1860,22 @@ async function runNowAll(hqRoot, message, onConflict, modeAllOverride, skipPerso
     // so the per-target rendering, error isolation, and exit codes are
     // identical to running `push --all` then `pull --all` back-to-back.
     console.log(chalk.dim("→ push --all"));
-    await runPushAll(hqRoot, message, onConflict, skipPersonal);
+    const refused = await runPushAll(hqRoot, message, onConflict, skipPersonal);
     console.log(chalk.dim("\n→ pull --all"));
     // US-011: forward --mode-all so the strict refusal applies to the
     // pull leg (push doesn't need a narrow-hint — the narrow ritual is
     // pull-side).
     await runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, forceScopeShrink);
+    if (refused) {
+        // A plan-limit refusal does not stop the pull, but the run must not end
+        // looking like a clean sync: say so last and exit non-zero.
+        console.log(chalk.yellow(`\n⚠ Sync finished, but ${describeRefusedFiles(refused)} refused ` +
+            "by your plan limit (listed under push --all above)."));
+        if (refused.upgradeUrl) {
+            console.log(chalk.yellow(`  Upgrade: ${refused.upgradeUrl}`));
+        }
+        throw new SyncExitError(1, { health: "succeeded" });
+    }
 }
 /**
  * Best-effort read of the active company slug from `<hqRoot>/.hq/config.json`.

package/dist/commands/core-handoff.d.ts

@@ -0,0 +1,22 @@
+/** Native implementations of the handoff scaffold command family. */
+import { Command } from "commander";
+type RunResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type HandoffContext = {
+    root: string;
+    cwd: string;
+    now?: () => Date;
+    /** Test-only override for the finalizer's historical fixed /tmp paths. */
+    tmpDir?: string;
+};
+export declare function runHandoffOpenSteps(args: string[], context: HandoffContext): RunResult;
+export declare function runHandoffFinalize(args: string[], context: HandoffContext): RunResult;
+export declare function runHandoffPost(args: string[], context: HandoffContext): RunResult | Promise<RunResult>;
+export declare function runHandoffPostWorker(args: string[], context: HandoffContext): RunResult;
+/** Register native handoff commands behind the shared default-off flag. */
+export declare function registerCoreHandoffCommand(core: Command): void;
+export {};
+//# sourceMappingURL=core-handoff.d.ts.map