@indigoai-us/hq-cli 5.345.178 → 5.345.180

package/dist/commands/channels.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { suggestChannels, withChannelSuggestions } from "./channel-suggest.js";
-import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, } from "./dm.js";
+import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, matchContactByName, } from "./dm.js";
 /**
  * Human label for a channel row. Named channels (personal/company) show their
  * name + a `hq dm <slug>` hint; unnamed group DMs are identified by their
@@ -294,6 +294,176 @@ async function runChannelsDelete(channelName, opts) {
         process.exit(1);
     }
 }
+// ─── Channel membership: add / remove ────────────────────────────────────────
+/**
+ * Resolve the `<member>` argument of `hq channels add|remove` to a person or
+ * agent uid. Accepts a uid (`prs_…`, `agt_…`), an email, or a display name /
+ * @handle matched against the caller's DM contacts (which include the bots the
+ * caller owns). Pure → unit-testable. Returns an error sentence on no or
+ * ambiguous match so the caller never guesses. Feedback e165b286.
+ */
+export function resolveMemberTarget(contacts, raw) {
+    const target = raw.trim().replace(/^@/, "");
+    if (!target)
+        return { ok: false, error: "Name a member: a @handle, an email, or a prs_/agt_ uid." };
+    if (/^(prs|agt)_[A-Za-z0-9_-]+$/.test(target)) {
+        const known = contacts.find((c) => c.personUid === target);
+        return { ok: true, personUid: target, displayName: known?.displayName?.trim() || target };
+    }
+    if (target.includes("@")) {
+        const email = target.toLowerCase();
+        const hits = contacts.filter((c) => c.personUid && c.email?.trim().toLowerCase() === email);
+        const unique = [...new Map(hits.map((c) => [c.personUid, c])).values()];
+        if (unique.length === 1) {
+            return { ok: true, personUid: unique[0].personUid, displayName: unique[0].displayName?.trim() || email };
+        }
+        return {
+            ok: false,
+            error: unique.length === 0
+                ? `No contact with the email '${target}'. They must share a company with you; pass their prs_/agt_ uid to add them anyway.`
+                : `'${target}' matches ${unique.length} contacts. Pass the prs_/agt_ uid instead.`,
+        };
+    }
+    const match = matchContactByName(contacts, target);
+    if (match?.personUid) {
+        return { ok: true, personUid: match.personUid, displayName: match.displayName?.trim() || target };
+    }
+    const names = contacts
+        .map((c) => c.displayName?.trim())
+        .filter((n) => Boolean(n))
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        ok: false,
+        error: `No contact matches '${raw.trim()}'. Contacts: ${names.slice(0, 12).join(", ") || "(none)"}` +
+            `${names.length > 12 ? ", …" : ""}. Use the exact name, an email, or a prs_/agt_ uid.`,
+    };
+}
+async function fetchDmContacts(token) {
+    const res = await vaultApiFetch({ token, path: "/v1/notify/contacts" });
+    if (!res.ok)
+        return [];
+    const data = (await res.json().catch(() => ({})));
+    return Array.isArray(data.contacts) ? data.contacts : [];
+}
+async function resolveOneChannel(token, channelName) {
+    const channels = await fetchChannels(token);
+    const matches = matchChannelsByName(channels, channelName);
+    if (matches.length === 0) {
+        const message = `No channel named '${channelName}'. Run \`hq channels\` to see your channels.`;
+        throw new Error(withChannelSuggestions(message, suggestChannels(channels, channelName)));
+    }
+    if (matches.length > 1) {
+        const scopes = matches.map((match) => match.scope ?? "?").join(", ");
+        throw new Error(`'${channelName}' matches ${matches.length} channels (${scopes}). Name one of them.`);
+    }
+    return matches[0];
+}
+/** The server's refusal, as one plain sentence. */
+export async function channelMembershipError(res, verb, fallback) {
+    const err = (await res.json().catch(() => ({})));
+    switch (err.code) {
+        case "CHANNEL_NOT_MEMBER":
+            return "Join the channel before adding members (so far you only browse it). Post once with `hq dm <channel> \"…\"`, or add yourself first with your own uid.";
+        case "INVITEE_NOT_FOUND":
+            return "That person or bot is not reachable from this company.";
+        case "CHANNEL_NOT_OWNER":
+            return verb === "add"
+                ? "Only the channel owner or a company admin can add members."
+                : "Only the channel owner or a company admin can remove other members, and the channel owner cannot be removed.";
+        default: {
+            const detail = err.error ?? err.message;
+            return detail ? `${fallback} (HTTP ${res.status}): ${detail}` : `${fallback} (HTTP ${res.status})`;
+        }
+    }
+}
+/**
+ * `hq channels add <channel> <member…>`: POST /v1/notify/channels/{id}/members
+ * once per member. Agents (`agt_…`) are allowed; this is how an owner adds a
+ * personal bot to a channel so everyone there can @mention it. The server
+ * reports `alreadyMember` on a repeat, which is printed, not treated as an error.
+ */
+async function runChannelsAdd(channelName, members, opts) {
+    let failed;
+    try {
+        const token = await ensureCognitoToken();
+        const channel = await resolveOneChannel(token, channelName);
+        const contacts = await fetchDmContacts(token);
+        const results = [];
+        for (const raw of members) {
+            const target = resolveMemberTarget(contacts, raw);
+            if (!target.ok) {
+                results.push({ member: raw, ok: false, error: target.error });
+                continue;
+            }
+            const res = await vaultApiFetch({
+                token,
+                path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/members`,
+                method: "POST",
+                body: { toPersonUid: target.personUid },
+            });
+            if (!res.ok) {
+                results.push({ member: raw, personUid: target.personUid, ok: false, error: await channelMembershipError(res, "add", "Could not add the member") });
+                continue;
+            }
+            const data = (await res.json().catch(() => ({})));
+            results.push({ member: target.displayName, personUid: target.personUid, ok: true, alreadyMember: data.alreadyMember === true });
+        }
+        const label = channel.name ?? channelName;
+        if (opts.json) {
+            console.log(JSON.stringify({ channelId: channel.channelId, name: label, results }, null, 2));
+        }
+        else {
+            for (const r of results) {
+                if (r.ok) {
+                    console.log(r.alreadyMember ? chalk.dim(`${r.member} is already in #${label}.`) : chalk.green(`Added ${r.member} to #${label}.`));
+                }
+                else {
+                    console.error(chalk.red(`${r.member}: ${r.error}`));
+                }
+            }
+        }
+        failed = results.some((r) => !r.ok);
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        failed = true;
+    }
+    if (failed)
+        process.exit(1);
+}
+/** `hq channels remove <channel> <member>`: DELETE /v1/notify/channels/{id}/members/{uid}. */
+async function runChannelsRemove(channelName, member, opts) {
+    try {
+        const token = await ensureCognitoToken();
+        const channel = await resolveOneChannel(token, channelName);
+        // The member is in the channel, so resolve against the roster first, then contacts.
+        const roster = await fetchChannelMembers(token, channel.channelId);
+        const rosterContacts = roster.map((m) => ({ personUid: m.personUid, email: m.email, displayName: m.displayName }));
+        let target = resolveMemberTarget(rosterContacts, member);
+        if (!target.ok)
+            target = resolveMemberTarget(await fetchDmContacts(token), member);
+        if (!target.ok)
+            throw new Error(target.error);
+        const res = await vaultApiFetch({
+            token,
+            path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/members/${encodeURIComponent(target.personUid)}`,
+            method: "DELETE",
+        });
+        if (!res.ok)
+            throw new Error(await channelMembershipError(res, "remove", "Could not remove the member"));
+        const label = channel.name ?? channelName;
+        if (opts.json) {
+            console.log(JSON.stringify({ channelId: channel.channelId, personUid: target.personUid, removed: true }, null, 2));
+        }
+        else {
+            console.log(chalk.green(`Removed ${target.displayName} from #${label}.`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 export function registerChannelsCommand(program) {
     const channels = program
         .command("channels")
@@ -329,5 +499,19 @@ export function registerChannelsCommand(program) {
         .action(async (channelName, opts) => {
         await runChannelsDelete(channelName, opts);
     });
+    channels
+        .command("add <channel> <member...>")
+        .description("Add people or your own bots to a channel, by @handle, email, or prs_/agt_ uid.")
+        .option("--json", "Output the per-member results as JSON.")
+        .action(async (channelName, members, opts) => {
+        await runChannelsAdd(channelName, members, opts);
+    });
+    channels
+        .command("remove <channel> <member>")
+        .description("Remove a member or bot from a channel (owner or company admin), or leave it yourself.")
+        .option("--json", "Output the result as JSON.")
+        .action(async (channelName, member, opts) => {
+        await runChannelsRemove(channelName, member, opts);
+    });
 }
 //# sourceMappingURL=channels.js.map

package/dist/commands/daemon.d.ts

@@ -59,6 +59,8 @@ export interface DaemonCommandDeps {
     /** Reads stdin for the one-shot daemon machine login; never reads env or argv credentials. */
     readStdin?: () => Promise<string>;
     windowsUser?: string;
+    /** The Windows user's SID; the daemon's Scheduled Task name carries it so each user on a PC has their own task. */
+    windowsSid?: string;
     windowsHeadlessLauncher?: string;
     systemUnitDir?: string;
     systemRecordPath?: string;

package/dist/commands/daemon.js

@@ -24,7 +24,7 @@ import { DEFAULT_SERVICES, SERVICE_DESCRIPTIONS, enabledServices, hqCloudUnits }
 import { applyServiceToggle, effectiveSyncOwner, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
 import { daemonUnitInstalled } from "../lib/daemon/handoff.js";
 import { adoptLegacyUnits, readAdoptedUnits, restoreLegacyUnits } from "../lib/daemon/migrate.js";
-import { DAEMON_WINDOWS_TASK, ROOT_REFUSAL, SYSTEM_UNIT_DIR, WINDOWS_START_WAIT_MS, daemonRootRefusal, installDaemonUnit, installScopeFor, uninstallDaemonUnit, windowsInteractiveSession, } from "../lib/daemon/install.js";
+import { ROOT_REFUSAL, SYSTEM_UNIT_DIR, WINDOWS_START_WAIT_MS, daemonRootRefusal, installDaemonUnit, installScopeFor, classifyWindowsTask, legacyWindowsTask, readWindowsSid, uninstallDaemonUnit, windowsInteractiveSession, windowsTaskName, } from "../lib/daemon/install.js";
 import { describeLegacyUnit, findLegacyUnits } from "../lib/daemon/legacy.js";
 import { isDaemonProcess, liveDaemonLock, runningDaemonPid } from "../lib/daemon/lock.js";
 import { bundledHqCloud, managedHqCloud, managedHqCloudRoot, readHqCloudCopy, readHqCloudUpdateState } from "../lib/daemon/hq-cloud.js";
@@ -132,7 +132,10 @@ async function loadDefaults(over) {
                 existsSync: fs.existsSync,
                 listDir: (dir) => fs.readdirSync(dir),
                 launchdJobLoaded: (label) => run("launchctl", ["print", `gui/${process.getuid?.() ?? 0}/${label}`]).status === 0,
-                windowsTaskExists: (task) => run("schtasks.exe", ["/Query", "/TN", task]).status === 0,
+                windowsTaskOwner: (task) => classifyWindowsTask(run, task, {
+                    windowsSid: over.windowsSid ?? readWindowsSid(run),
+                    windowsUser: over.windowsUser ?? mesh.resolveWindowsUser(env),
+                }).state,
             })),
         resolveHqRoot: over.resolveHqRoot ?? ((flag) => resolveDaemonHqRoot(flag, { env, cwd: process.cwd(), home })),
         userHome: over.userHome ?? ((user) => loginHome(user, run)),
@@ -140,6 +143,7 @@ async function loadDefaults(over) {
         sleep: over.sleep,
         interactiveSession: over.interactiveSession,
         windowsUser: over.windowsUser ?? (platform === "win32" ? mesh.resolveWindowsUser(env) : ""),
+        windowsSid: over.windowsSid ?? (platform === "win32" ? readWindowsSid(run) : undefined),
         windowsHeadlessLauncher: over.windowsHeadlessLauncher ?? (platform === "win32" ? mesh.resolveWindowsHeadlessLauncher(env) : undefined),
         systemUnitDir: over.systemUnitDir ?? SYSTEM_UNIT_DIR,
         syncModeClient: over.syncModeClient,
@@ -196,6 +200,7 @@ function hostFor(d, paths, pathEnv) {
         uid: d.uid,
         isRoot: d.isRoot,
         windowsUser: d.windowsUser ?? "",
+        windowsSid: d.windowsSid,
         windowsHeadlessLauncher: d.windowsHeadlessLauncher,
         systemUnitDir: d.systemUnitDir ?? SYSTEM_UNIT_DIR,
         env,
@@ -306,6 +311,8 @@ async function runInstall(d, opts) {
         runningDaemon: () => liveDaemonLock(paths.lockPath, d.daemonAlive),
     });
     handOver(d, { paths, detected, runAsUser });
+    if (result.notice)
+        d.out(result.notice);
     if (result.warning)
         d.err(result.warning);
     if (result.kind === "manual") {
@@ -333,7 +340,7 @@ async function runInstall(d, opts) {
                 ? `Installed ${result.unitPath}, but the daemon did not start within ${seconds} seconds although you are signed in to Windows.`
                 : `Installed ${result.unitPath}, but the daemon did not start within ${seconds} seconds, and HQ could not check whether you are signed in to Windows.`,
             "Check it with: hq daemon status",
-            `The task's last result: powershell -NoProfile -Command "(Get-ScheduledTaskInfo -TaskName '${DAEMON_WINDOWS_TASK}').LastTaskResult"`,
+            `The task's last result: powershell -NoProfile -Command "(Get-ScheduledTaskInfo -TaskName '${windowsTaskName({ windowsSid: d.windowsSid, windowsUser: d.windowsUser ?? "" })}').LastTaskResult"`,
         ].join("\n"));
     }
     if (!result.running) {
@@ -386,6 +393,8 @@ async function runUninstall(d, opts) {
     }
     const result = uninstallDaemonUnit(hostFor(d, paths, false), { scope: installScopeFor(detected.type) }, { run: d.run });
     d.out(result.removed ? `Removed ${result.unitPath}` : "hq daemon was not installed.");
+    if (result.notice)
+        d.out(result.notice);
     if (result.warning)
         d.err(result.warning);
     if (opts.restoreLegacy) {
@@ -869,7 +878,9 @@ async function runMigrate(d, opts) {
             platform: d.platform,
             home: d.home,
             systemUnitDir: d.systemUnitDir,
+            windowsTaskName: windowsTaskName({ windowsSid: d.windowsSid, windowsUser: d.windowsUser ?? "" }),
             windowsTaskExists: (task) => d.run("schtasks.exe", ["/Query", "/TN", task]).status === 0,
+            windowsLegacyTaskIsMine: () => legacyWindowsTask(d.run, { windowsSid: d.windowsSid, windowsUser: d.windowsUser ?? "" }).state === "mine",
         });
         if (!installed) {
             throw new DaemonCommandError("hq daemon is not installed here yet. Run `hq daemon install` first, then `hq daemon migrate --apply`.");
@@ -893,7 +904,7 @@ async function runMigrate(d, opts) {
         if (u.migratable)
             d.out(`Would take over ${u.unitId} from ${describeLegacyUnit(u)}${u.path ? ` (${u.path})` : ""}`);
         else
-            d.out(`Leaving ${u.unitId} to ${describeLegacyUnit(u)} (owned by the HQ desktop app)`);
+            d.out(`Leaving ${u.unitId} to ${describeLegacyUnit(u)} (${u.notMineReason ?? "owned by the HQ desktop app"})`);
     }
     d.out("Nothing was changed. `hq daemon migrate --apply` takes them over.");
 }

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

@@ -299,6 +299,8 @@ export interface UsableApp {
      * provider, else `--connection <id>`.
      */
     selector: string;
+    /** The caller created this connection (`viewerAccess.isCreator`). */
+    ownedByCaller: boolean;
 }
 export interface UsableAppsResult {
     companyUid: string;

package/dist/commands/integrations-core.js

@@ -529,6 +529,7 @@ export async function fetchUsableApps(token, companyUid) {
                 status: row.status,
                 providerArg,
                 selector: shared ? `--connection ${row.id}` : `--provider ${providerArg}`,
+                ownedByCaller: row.viewerAccess?.isCreator === true,
             };
         })
             .sort((a, b) => compareNames(a.name, b.name))

package/dist/commands/lanes.d.ts

@@ -147,7 +147,7 @@ export declare function checkpointInstruction(worker: Pick<ResolvedLaneWorker, "
 export declare function composeWorkerBrief(worker: ResolvedLaneWorker, taskBrief: string, hqRoot: string): string;
 /**
  * A lane with no worker still carries the standing authorization paragraph,
- * the foreground-only rule and the temp-home rule.
+ * the foreground-only rule, the temp-home rule and the self-review rule.
  */
 export declare function composeGeneralBrief(taskBrief: string, hqRoot: string): string;
 export declare const DISPATCH_TERMINAL_REASON: "outpost_dispatch_failed";

package/dist/commands/lanes.js

@@ -108,7 +108,7 @@ import { resolveKrFreshnessForShow } from "../lib/lanes/kr-freshness.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
 import { readLaneClaudeCredential } from "../lib/lanes/claude-credential.js";
-import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, tempHomeRule, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, selfReviewRule, tempHomeRule, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
 export { spawnLaneWorker };
 export function openPullRequestsForProject(hqRoot, metadata) {
@@ -3041,11 +3041,13 @@ export function composeWorkerBrief(worker, taskBrief, hqRoot) {
         "",
         tempHomeRule(hqRoot),
         "",
+        selfReviewRule(hqRoot),
+        "",
     ].join("\n");
 }
 /**
  * A lane with no worker still carries the standing authorization paragraph,
- * the foreground-only rule and the temp-home rule.
+ * the foreground-only rule, the temp-home rule and the self-review rule.
  */
 export function composeGeneralBrief(taskBrief, hqRoot) {
     return [
@@ -3058,6 +3060,8 @@ export function composeGeneralBrief(taskBrief, hqRoot) {
         "",
         tempHomeRule(hqRoot),
         "",
+        selfReviewRule(hqRoot),
+        "",
     ].join("\n");
 }
 function parseMaxRuntimeSeconds(raw, workerId) {

package/dist/commands/mesh.js

@@ -3071,6 +3071,25 @@ export function registerMeshCommand(program, deps = {}) {
         .description("Report daemon running/MQTT/spool/held/dead-letter/outbox/flush health")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonDoctorCmd(opts))());
+    mesh
+        .command("push-status")
+        .description("Report whether the owner DM push signal is live or stale, with the last event time")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runMeshPushStatus(opts))());
+}
+async function runMeshPushStatus(opts) {
+    const { ownerPushStatusForAccount, readOwnerInboxPushState, formatOwnerPushStatus } = await import("../lib/mesh/live/daemon/owner-inbox-push.js");
+    const { describeCognitoTokenSource } = await import("../utils/cognito-session.js");
+    const { actorKind } = describeCognitoTokenSource({ home: os.homedir(), env: process.env });
+    const status = ownerPushStatusForAccount(readOwnerInboxPushState(workMeshRoot(undefined, process.env)), Date.now(), actorKind);
+    if (opts.json) {
+        console.log(JSON.stringify(status, null, 2));
+    }
+    else {
+        console.log(formatOwnerPushStatus(status));
+    }
+    if (status.status === "stale")
+        process.exitCode = 1;
 }
 async function runDaemonRun(opts = {}) {
     const { runMeshDaemon } = await import("../lib/mesh/live/daemon/run.js");

package/dist/commands/sources.d.ts

@@ -11,6 +11,8 @@
  *   hq sources get       Fetch one source by id.
  *   hq sources channels  Print the canonical SOURCE_CHANNELS enum.
  *   hq sources entities  List entities the caller has access to.
+ *   hq sources runs      Show the local hot-channel run ledger for one day.
+ *   hq sources sync      Run every hot channel now for the signed-in person.
  *
  * Defaults:
  *   --entity   falls back to .hq/config.json activeCompany (per sync.ts).
@@ -18,5 +20,92 @@
  *   --limit    50.
  */
 import { Command } from "commander";
+import { type RunLedgerAdapterSummary, type RunLedgerEntry, type RunTrigger, type SignalsGeneratedFn } from "../lib/hot-channels/ledger.js";
+import type { HotChannelRegistry } from "../lib/hot-channels/registry.js";
+import { type OnDemandSyncDeps, type OnDemandSyncReport } from "../lib/hot-channels/run.js";
+type ListFormat = "table" | "json";
+export interface RunsOptions {
+    today?: boolean;
+    date?: string;
+    company?: string;
+    email?: string;
+    format?: ListFormat;
+    hqRoot: string;
+}
+export interface RunsReport {
+    company: string;
+    personKey: string;
+    day: string;
+    adapters: RunLedgerAdapterSummary[];
+    entries: RunLedgerEntry[];
+    malformed: number;
+}
+/**
+ * Reads one day's run ledger (`sources/_runs/@{personKey}/{day}.jsonl` in the
+ * company folder of the local HQ tree). The person key is
+ * `audienceKey([email])` of the signed-in person. No network calls.
+ */
+export declare function runRuns(options: RunsOptions, now?: Date): Promise<RunsReport>;
+export interface SyncOptions {
+    adapter?: string;
+    company?: string;
+    hqRoot: string;
+    json?: boolean;
+}
+export interface SyncOverrides {
+    /** Adapters to run. This build registers none, so the default is empty. */
+    registry?: HotChannelRegistry;
+    now?: () => Date;
+    /** The signals pass; defaults to the local `claude -p` pass under the user's own login. */
+    signalsGenerated?: SignalsGeneratedFn;
+}
+/**
+ * Network access for one sync: the catalog, the person's usable connections,
+ * and tool calls through the HQ gateway. Integration tokens stay server-side;
+ * the gateway routes each call by connection id.
+ */
+export declare function gatewaySyncDeps(token: string, companyUid: string): OnDemandSyncDeps;
+export interface CompanyHotChannelSyncInput {
+    hqRoot: string;
+    company: string;
+    adapter?: string;
+    registry?: HotChannelRegistry;
+    now?: () => Date;
+    /** `scheduled` for the bot's hot-signal-sync job; `on-demand` by default. */
+    trigger?: RunTrigger;
+    catchUp?: boolean;
+    signalsGenerated?: SignalsGeneratedFn;
+    /** The signed-in person's `prs_` person uid in this company; defaults to a roster lookup by email. */
+    resolvePersonUid?: (token: string, companyUid: string, email: string) => Promise<string | null>;
+    /**
+     * Where the signals-failure alert goes (US-012). Unset = no alert check.
+     * The company-channel post defaults to the Slack channel in the company's
+     * `settings/signals/preferences.yaml`, through the HQ integrations gateway.
+     */
+    signalsAlert?: SignalsAlertSenders;
+}
+export interface SignalsAlertSenders {
+    /** The primary alert to the owner; throws when it was not delivered. */
+    sendOwnerDm: (text: string) => Promise<void>;
+    postCompanyChannel?: (text: string) => Promise<void>;
+    log?: (message: string) => void;
+}
+/**
+ * One hot-channel sync for the signed-in person in one company: each adapter
+ * once per usable connection. Writes under `companies/{company}/`: landed
+ * sources in `sources/`, index rows in `sources/_index/`, cursors in
+ * `sources/_cursors/`, one ledger line per adapter in `sources/_runs/`, and
+ * signals in `signals/@{key}/`. `hq sources sync` and the bot's scheduled
+ * hot-signal-sync job both call it. Only one run per person per company goes
+ * at a time: a second one writes a `skipped` ledger line and lands nothing.
+ */
+export declare function runCompanyHotChannelSync(input: CompanyHotChannelSyncInput): Promise<OnDemandSyncReport>;
+/**
+ * Run every hot channel for the signed-in person now: each adapter once per
+ * usable connection. Writes cursors, landed sources and an `on-demand` ledger
+ * line under `companies/{company}/sources/`, and nothing else.
+ */
+export declare function runSync(options: SyncOptions, overrides?: SyncOverrides): Promise<OnDemandSyncReport>;
 export declare function registerSourcesCommand(program: Command): void;
+export {};
 //# sourceMappingURL=sources.d.ts.map