@indigoai-us/hq-cli 5.345.191 → 5.345.193

package/dist/commands/core-jobs-schedule.js

@@ -91,6 +91,16 @@ function parseNaturalLanguage(text) {
             return [null, "hour interval must be 1..23"];
         return [`0 */${hours} * * *`, `Every ${hours} hours`];
     }
+    // "every morning at 6" / "every evening at 7": a bare hour takes the part of
+    // day's meridiem (morning = am, afternoon/evening/night = pm).
+    match = /^(?:every\s+)?(morning|afternoon|evening|night)\s+(?:at\s+)?(\d{1,2}(?::\d{2})?)$/.exec(normalized);
+    if (match) {
+        const clock = parseClock(match[2] + (match[1] === "morning" ? "am" : "pm"));
+        if (!clock)
+            return [null, "could not parse time: " + match[2]];
+        const [hour, minute] = clock;
+        return [String(minute) + " " + String(hour) + " * * *", "Every day at " + formatClock(hour, minute)];
+    }
     match = /^(?:every\s+)?(weekday|weekdays|day|daily)\s+(?:at\s+)?(.+)$/.exec(normalized);
     if (match) {
         const clock = parseClock(match[2]);

package/dist/commands/daemon.js

@@ -136,6 +136,7 @@ async function loadDefaults(over) {
                     windowsSid: over.windowsSid ?? readWindowsSid(run),
                     windowsUser: over.windowsUser ?? mesh.resolveWindowsUser(env),
                 }).state,
+                windowsRecordedMeshTask: platform === "win32" && mesh ? () => mesh.recordedWindowsMeshTaskName(dir ?? home, env) : undefined,
             })),
         resolveHqRoot: over.resolveHqRoot ?? ((flag) => resolveDaemonHqRoot(flag, { env, cwd: process.cwd(), home })),
         userHome: over.userHome ?? ((user) => loginHome(user, run)),
@@ -1549,6 +1550,42 @@ export function registerDaemonCommand(program, over = {}) {
         .command("self-update")
         .description("Update the hq CLI, Claude, Codex and Grok, then restart the daemon onto a new CLI")
         .action(wrap((d) => runServiceSelfUpdate(d)));
+    service
+        .command("fleet-bots-update")
+        .description("Move each installed HQ Fleet bot to the current runtime release while it is idle, and restart it")
+        .action(wrap(async (d) => {
+        const [{ runFleetBotsUpdate, listFleetBots }, local, bot, { botsRoot }, { hasPromotionHold }] = await Promise.all([
+            import("../lib/bot/fleet-watch.js"),
+            import("../lib/bot/fleet-local.js"),
+            import("./bot.js"),
+            import("../lib/bot/paths.js"),
+            import("../lib/bot/promotion-hold.js"),
+        ]);
+        const alive = (pid) => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch (error) {
+                return error.code === "EPERM";
+            }
+        };
+        await runFleetBotsUpdate({
+            listBots: () => listFleetBots(botsRoot()),
+            target: () => local.resolveFleetLocalPointerTarget(),
+            installed: (b) => {
+                if (b.config.enabled === false)
+                    return false;
+                const pid = local.fleetLocalGatewayPid(b.config.agentUid);
+                return pid !== null && alive(pid);
+            },
+            heldForPromotion: (b) => hasPromotionHold(b.dir),
+            needsAdoption: (b, release) => local.fleetLocalProfileNeedsAdoption(b.config.agentUid, { release }),
+            busy: (b) => local.fleetLocalBusyReason(b.config.agentUid),
+            update: (b) => bot.updateFleetRuntimeBot(b.name, { busy: () => local.fleetLocalBusyReason(b.config.agentUid) }),
+            log: (line) => d.out(line),
+        });
+    }));
     service
         .command("sync-core-reconcile")
         .description("Read each company's new-sync-engine switch and write this machine's engine homes and legacy off-switches")

package/dist/commands/files.d.ts

@@ -242,14 +242,41 @@ export declare function runFilesRestore(params: {
 }, deps?: {
     confirm?: ConfirmFn;
 }): Promise<FilesRestoreResponse | undefined>;
-export interface FilesPurgeResponse {
+/** Grace period hq-pro applies before a scheduled version purge runs. */
+export declare const PURGE_GRACE_DAYS = 7;
+/**
+ * Outcome of `hq files purge`. A current hq-pro schedules the purge
+ * (`scheduled`); a server from before the 7-day window deletes the version
+ * at once (`purged`), and the CLI reports that rather than a schedule.
+ */
+export type FilesPurgeResult = {
+    key: string;
+    versionId: string;
+    status: "scheduled";
+    purgeAt: string;
+} | {
     key: string;
-    purgedVersionId: string;
+    versionId: string;
+    status: "purged";
+};
+export interface FilesPurgeCancelResult {
+    key: string;
+    versionId: string;
+    status: "cancelled";
 }
+/** The exact command that cancels this purge, including the scope flags. */
+export declare function formatPurgeCancelCommand(params: {
+    key: string;
+    versionId: string;
+    personal: boolean;
+    companySlug: string | undefined;
+}): string;
 /**
- * feedback_fc711fc3: permanently delete one noncurrent version. The server
- * (hq-pro POST /v1/files/restore, action "purge") enforces owner-only access,
- * refuses the current version and delete markers, and audits before deleting.
+ * feedback_fc711fc3: schedule permanent deletion of one noncurrent version.
+ * The server (hq-pro POST /v1/files/restore, action "purge") enforces
+ * owner-only access, refuses the current version and delete markers, audits,
+ * and schedules the deletion PURGE_GRACE_DAYS out (cancelable). An older
+ * server deletes immediately; the CLI reports what the server says it did.
  */
 export declare function runFilesPurge(params: {
     key: string;
@@ -259,7 +286,15 @@ export declare function runFilesPurge(params: {
     companySlug: string | undefined;
 }, deps?: {
     confirm?: ConfirmFn;
-}): Promise<FilesPurgeResponse | undefined>;
+    now?: () => Date;
+}): Promise<FilesPurgeResult | undefined>;
+/** Cancel a scheduled purge (hq-pro action "cancel-purge"). */
+export declare function runFilesPurgeCancel(params: {
+    key: string;
+    versionId: string;
+    personal: boolean;
+    companySlug: string | undefined;
+}): Promise<FilesPurgeCancelResult>;
 export declare function runFilesTrash(params: {
     prefix: string;
     cursor?: string;

package/dist/commands/files.js

@@ -733,15 +733,25 @@ export function registerFilesCommand(program) {
     });
     files
         .command("purge <path>")
-        .description("Permanently delete ONE retained (noncurrent) version of an exact vault key, for example a version that held data which must not live in HQ. Owner only; audited; cannot be undone. Delete the file first if the version is current. Use --personal for your personal vault.")
+        .description("Schedule permanent deletion of ONE retained (noncurrent) version of an exact vault key, for example a version that held data which must not live in HQ. The version is deleted 7 days later and can be cancelled until then with --cancel. Owner only; audited. Delete the file first if the version is current. Use --personal for your personal vault.")
         .option("--personal", "Target your own personal vault instead of a company vault (mutually exclusive with --company)")
         .requiredOption("--version-id <id>", "Exact version ID to purge (see `hq files versions`)")
+        .option("--cancel", "Cancel a scheduled purge of this version instead of scheduling one")
         .option("-y, --yes", "Skip the confirmation prompt (for scripts)")
         .action(async (path, opts) => {
         try {
             const companySlug = files.opts().company;
             const personal = opts.personal === true;
             assertRecoveryScope(personal, companySlug);
+            if (opts.cancel === true) {
+                await runFilesPurgeCancel({
+                    key: path,
+                    versionId: opts.versionId,
+                    personal,
+                    companySlug,
+                });
+                return;
+            }
             await runFilesPurge({
                 key: path,
                 versionId: opts.versionId,
@@ -1791,31 +1801,39 @@ export async function runFilesRestore(params, deps = {}) {
     console.log(chalk.dim("New version: " + data.newVersionId));
     return data;
 }
-/**
- * feedback_fc711fc3: permanently delete one noncurrent version. The server
- * (hq-pro POST /v1/files/restore, action "purge") enforces owner-only access,
- * refuses the current version and delete markers, and audits before deleting.
- */
-export async function runFilesPurge(params, deps = {}) {
-    assertExactRecoveryKey(params.key);
-    if (typeof params.versionId !== "string" || params.versionId.trim() === "") {
+/** Grace period hq-pro applies before a scheduled version purge runs. */
+export const PURGE_GRACE_DAYS = 7;
+function formatPurgeDate(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return iso;
+    return d.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC");
+}
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+/** The exact command that cancels this purge, including the scope flags. */
+export function formatPurgeCancelCommand(params) {
+    const scope = params.personal
+        ? ""
+        : params.companySlug
+            ? " --company " + shellQuote(params.companySlug)
+            : "";
+    return ("hq files" + scope + " purge --cancel " + shellQuote(params.key) +
+        " --version-id " + shellQuote(params.versionId) +
+        (params.personal ? " --personal" : ""));
+}
+function assertPurgeVersionId(versionId) {
+    if (typeof versionId !== "string" || versionId.trim() === "") {
         throw new Error("--version-id is required and must not be empty.");
     }
-    const confirm = deps.confirm ?? realConfirm;
-    if (!params.yes) {
-        const ok = await confirm("Permanently delete version '" + params.versionId + "' of '" + params.key + "'" +
-            (params.personal ? " in your personal vault" : "") +
-            "? This cannot be undone.");
-        if (!ok) {
-            console.log(chalk.dim("Aborted — nothing was purged."));
-            return undefined;
-        }
-    }
+}
+async function postPurgeAction(params, action) {
     const scope = await resolveRecoveryScope(params);
     const body = scope.personal
         ? { personal: true, key: params.key }
         : { company: scope.companyUid, key: params.key };
-    body.action = "purge";
+    body.action = action;
     body.purgeVersionId = params.versionId;
     // Tripwire: a server without purge support rejects `versionId: null` with
     // 400 instead of ignoring `action` and restoring (re-publishing) the version.
@@ -1829,16 +1847,79 @@ export async function runFilesPurge(params, deps = {}) {
     if (!res.ok) {
         const errBody = (await res.json().catch(() => ({})));
         const err = new FilesRecoveryHttpError(res.status, errBody.message ?? errBody.error ?? res.statusText, errBody.code);
+        if (action === "cancel-purge" && res.status === 400) {
+            throw new Error("The server rejected the cancellation: " + err.message + ". If the server predates the 7-day purge window it cannot cancel. Check `hq files versions` to see whether the version still exists.");
+        }
         throw new Error(formatFilesRecoveryError(err, params.key));
     }
-    const data = (await res.json());
-    // Belt and braces with the tripwire above: only a server that echoes the
-    // purged version id has purged it.
-    if (data.purgedVersionId !== params.versionId) {
-        throw new Error("The server did not confirm the purge (it may not support purge yet). Check `hq files versions` before retrying.");
+    const parsed = await res.json().catch(() => ({}));
+    return parsed !== null && typeof parsed === "object" ? parsed : {};
+}
+/**
+ * feedback_fc711fc3: schedule permanent deletion of one noncurrent version.
+ * The server (hq-pro POST /v1/files/restore, action "purge") enforces
+ * owner-only access, refuses the current version and delete markers, audits,
+ * and schedules the deletion PURGE_GRACE_DAYS out (cancelable). An older
+ * server deletes immediately; the CLI reports what the server says it did.
+ */
+export async function runFilesPurge(params, deps = {}) {
+    assertExactRecoveryKey(params.key);
+    assertPurgeVersionId(params.versionId);
+    const confirm = deps.confirm ?? realConfirm;
+    if (!params.yes) {
+        const now = (deps.now ?? (() => new Date()))();
+        const expected = new Date(now.getTime() + PURGE_GRACE_DAYS * 24 * 60 * 60 * 1000);
+        const ok = await confirm("Version '" + params.versionId + "' of '" + params.key + "'" +
+            (params.personal ? " in your personal vault" : "") +
+            " will be permanently deleted on " + formatPurgeDate(expected.toISOString()) +
+            " and can be cancelled until then with `hq files purge --cancel`." +
+            " (A server without the 7-day window deletes it immediately.) Continue?");
+        if (!ok) {
+            console.log(chalk.dim("Aborted — nothing was purged."));
+            return undefined;
+        }
     }
-    console.log(chalk.green("Purged version '" + data.purgedVersionId + "' of '" + params.key + "'."));
-    return { key: data.key ?? params.key, purgedVersionId: data.purgedVersionId };
+    const data = await postPurgeAction(params, "purge");
+    const key = typeof data.key === "string" ? data.key : params.key;
+    const saysScheduled = data.status === "scheduled" || data.scheduled === true;
+    const scheduled = saysScheduled &&
+        typeof data.purgeAt === "string" &&
+        !Number.isNaN(new Date(data.purgeAt).getTime()) &&
+        data.purgeVersionId === params.versionId;
+    if (saysScheduled && !scheduled) {
+        // The server says something is scheduled but the response is incomplete.
+        // Do not report "nothing happened": a deletion may be pending.
+        throw new Error("The server reported a scheduled purge but did not return a valid purge date and version id. A purge of this version may be pending. To cancel it, run: " +
+            formatPurgeCancelCommand(params));
+    }
+    if (scheduled) {
+        const purgeAt = data.purgeAt;
+        console.log(chalk.green("Version '" + params.versionId + "' of '" + key + "' will be permanently deleted on " +
+            formatPurgeDate(purgeAt) + ". It can be cancelled until then:"));
+        console.log(chalk.dim("  " + formatPurgeCancelCommand(params)));
+        return { key, versionId: params.versionId, status: "scheduled", purgeAt };
+    }
+    // Older server: it purged at once and echoes purgedVersionId. Say so plainly.
+    if (data.purgedVersionId === params.versionId) {
+        console.log(chalk.yellow("The server deleted version '" + params.versionId + "' of '" + key +
+            "' immediately (it does not support the 7-day purge window yet). This cannot be cancelled."));
+        return { key, versionId: params.versionId, status: "purged" };
+    }
+    throw new Error("The server did not confirm the purge (it may not support purge yet). Check `hq files versions` before retrying.");
+}
+/** Cancel a scheduled purge (hq-pro action "cancel-purge"). */
+export async function runFilesPurgeCancel(params) {
+    assertExactRecoveryKey(params.key);
+    assertPurgeVersionId(params.versionId);
+    const data = await postPurgeAction(params, "cancel-purge");
+    const key = typeof data.key === "string" ? data.key : params.key;
+    const confirmed = (data.status === "cancelled" || data.cancelled === true) &&
+        data.purgeVersionId === params.versionId;
+    if (!confirmed) {
+        throw new Error("The server did not confirm the cancellation (it may not support the 7-day purge window yet). Check `hq files versions` to see whether the version still exists.");
+    }
+    console.log(chalk.green("Cancelled the scheduled purge of version '" + params.versionId + "' of '" + key + "'."));
+    return { key, versionId: params.versionId, status: "cancelled" };
 }
 export async function runFilesTrash(params) {
     if (params.prefix.includes("*")) {

package/dist/commands/pack-start-bot.d.ts

@@ -7,14 +7,12 @@
 import type { InstallPackResult } from "./pack-install.js";
 import { type StartPackBotDeps, type StartPackBotResult } from "../lib/packages/start-bot.js";
 /**
- * The model and thinking level a pack's setup bot runs on. Left unset, Claude
- * Code used the account's default model (Claude Fable 5.1 in a 2026-10-12
- * walkthrough), and one setup turn took nine minutes. Pack setup is guided
- * reading and writing: Opus 5.5 at medium thinking does it well and faster.
- * The person can still change either with `hq bot set`.
+ * The model a pack's setup bot runs on. Left unset, Claude Code used the
+ * account's default model (Claude Fable 5.1 in a 2026-10-12 walkthrough), and
+ * one setup turn took nine minutes. Pack setup is guided reading and writing:
+ * Opus 5.5 does it well and faster.
  */
 export declare const PACK_BOT_MODEL = "claude-opus-5-5";
-export declare const PACK_BOT_EFFORT = "medium";
 export declare function defaultStartPackBotDeps(): StartPackBotDeps;
 /**
  * Start the pack's setup bot after a successful install. Never throws: a bot

package/dist/commands/pack-start-bot.js

@@ -32,14 +32,12 @@ async function dmOwner(name, body) {
     await new BotApi({ token: async () => token }).sendDm({ toPersonUid: owner, body });
 }
 /**
- * The model and thinking level a pack's setup bot runs on. Left unset, Claude
- * Code used the account's default model (Claude Fable 5.1 in a 2026-10-12
- * walkthrough), and one setup turn took nine minutes. Pack setup is guided
- * reading and writing: Opus 5.5 at medium thinking does it well and faster.
- * The person can still change either with `hq bot set`.
+ * The model a pack's setup bot runs on. Left unset, Claude Code used the
+ * account's default model (Claude Fable 5.1 in a 2026-10-12 walkthrough), and
+ * one setup turn took nine minutes. Pack setup is guided reading and writing:
+ * Opus 5.5 does it well and faster.
  */
 export const PACK_BOT_MODEL = "claude-opus-5-5";
-export const PACK_BOT_EFFORT = "medium";
 export function defaultStartPackBotDeps() {
     return {
         botExists,
@@ -48,9 +46,7 @@ export function defaultStartPackBotDeps() {
             displayName: opts.displayName,
             intro: opts.intro,
             kickoff: opts.kickoff,
-            lean: true,
             model: PACK_BOT_MODEL,
-            effort: PACK_BOT_EFFORT,
         }),
         restartBot: (name) => runBotRestart(name, { output: "text" }),
         sendIntro: (name) => runBotIntro(name),

package/dist/commands/signals-run.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `hq signals run` — local signals engine (Hot-Signal Sync US-002).
+ *
+ * Loops over every company in scope whose signals_capture or
+ * ontology_capture preference is on and runs the fixed step order
+ * garden -> adapters -> extract -> garden -> upload, writing a run record
+ * under workspace/signals/runs/{date}/. The engine lives in
+ * src/lib/signals/engine.ts and is callable as runSignals().
+ */
+import { Command } from "commander";
+import { type RunSignalsResult, type SignalsStepChoice, type SignalsTrigger } from "../lib/signals/engine.js";
+import type { SignalsRunAlertSenders } from "../lib/signals/failure-alert.js";
+interface RunCliOptions {
+    company?: string;
+    dryRun?: boolean;
+    step: SignalsStepChoice;
+    trigger: SignalsTrigger;
+    force?: boolean;
+    catchUp?: boolean;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    json?: boolean;
+    reportFound?: boolean;
+    hqRoot: string;
+}
+export declare function formatRunResult(result: RunSignalsResult, dryRun: boolean): string;
+export declare function foundSignalsReply(result: RunSignalsResult, company: string | undefined, timeZone: string): string | null;
+/**
+ * The terminal alert sender for `hq signals run` (US-018). The CLI has no
+ * owner-DM sender, so the terminal is the primary alert, as in
+ * `hq sources sync`. A printed alert does not record the hourly dedupe entry,
+ * so it never holds back the bot's owner DM for the same company.
+ */
+export declare function terminalSignalsAlert(write?: (text: string) => void): SignalsRunAlertSenders;
+/**
+ * Exit codes (run record contract v2): 0 complete, partial, skipped or the
+ * job already ran today; 1 failed; 2 usage or config error; 3 another run
+ * holds a company's lock (stdout then carries {"status":"running",...}).
+ */
+export declare function runSignalsCli(options: RunCliOptions, overrides?: {
+    signalsAlert?: SignalsRunAlertSenders;
+}): Promise<void>;
+export declare function registerSignalsRunSubcommand(signals: Command): void;
+export {};
+//# sourceMappingURL=signals-run.d.ts.map

package/dist/commands/signals-run.js

@@ -0,0 +1,175 @@
+/**
+ * `hq signals run` — local signals engine (Hot-Signal Sync US-002).
+ *
+ * Loops over every company in scope whose signals_capture or
+ * ontology_capture preference is on and runs the fixed step order
+ * garden -> adapters -> extract -> garden -> upload, writing a run record
+ * under workspace/signals/runs/{date}/. The engine lives in
+ * src/lib/signals/engine.ts and is callable as runSignals().
+ */
+import { InvalidArgumentError, Option } from "commander";
+import chalk from "chalk";
+import { DEFAULT_HQ_ROOT } from "../utils/cognito-session.js";
+import { Sentry } from "../sentry.js";
+import { runSignals, signalsExitCode, SignalsUsageError, SIGNALS_STEP_CHOICES, SIGNALS_TRIGGERS, } from "../lib/signals/engine.js";
+import { formatRunReply } from "../lib/signals/reply.js";
+function parsePositiveInt(v) {
+    const n = Number(v);
+    if (!Number.isInteger(n) || n <= 0)
+        throw new InvalidArgumentError("must be a positive integer");
+    return n;
+}
+function parseNonNegative(v) {
+    const n = Number(v);
+    if (!Number.isFinite(n) || n < 0)
+        throw new InvalidArgumentError("must be a non-negative number");
+    return n;
+}
+function envCatchUp() {
+    const v = process.env.HQ_SIGNALS_CATCH_UP;
+    return v === "1" || v === "true";
+}
+export function formatRunResult(result, dryRun) {
+    const lines = [];
+    lines.push(`${dryRun ? "Dry run" : "Signals run"} ${result.date}: ${result.summary.status}`);
+    if (result.records.length === 0 && result.locked.length === 0)
+        lines.push("  no companies in scope");
+    for (const l of result.locked) {
+        lines.push(`  ${l.company}: running (another ${l.trigger} run started ${l.startedAt}; nothing started)`);
+    }
+    for (const r of result.records) {
+        let head = `  ${r.company}: ${r.status}`;
+        if (r.skipReason)
+            head += ` (${r.skipReason})`;
+        if (r.alreadyRanToday)
+            head += " (already ran today)";
+        if (r.partialReason)
+            head += ` (${r.partialReason})`;
+        lines.push(head);
+        if (r.failureReason && !r.alreadyRanToday)
+            lines.push(`    ${r.failureReason}`);
+        if (r.nextRetryAt && !r.alreadyRanToday)
+            lines.push(`    next retry after ${r.nextRetryAt}`);
+        for (const s of r.steps) {
+            if (dryRun) {
+                lines.push(`    would run ${s.name}`);
+                for (const p of s.plan ?? [])
+                    lines.push(`      ${p}`);
+                continue;
+            }
+            const extra = s.skippedReason ? ` ${s.skippedReason}` : s.error ? ` ${s.error}` : "";
+            const up = s.uploaded ? ` uploaded=${s.uploaded.count} (${s.uploaded.bytes}B)` : "";
+            lines.push(`    ${s.name.padEnd(9)} ${s.status} in=${s.itemsIn} out=${s.itemsOut}${up}${extra}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function foundSignalsReply(result, company, timeZone) {
+    const record = result.records.find((r) => !company || r.company === company);
+    if (!record || record.alreadyRanToday || (record.status !== "complete" && record.status !== "partial"))
+        return null;
+    const extract = record.steps.find((s) => s.name === "extract" && s.status !== "skipped");
+    if (!extract || extract.itemsOut <= 0)
+        return null;
+    return formatRunReply(record, result.summary, { timeZone }).text;
+}
+function localTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    }
+    catch {
+        return "UTC";
+    }
+}
+/**
+ * The terminal alert sender for `hq signals run` (US-018). The CLI has no
+ * owner-DM sender, so the terminal is the primary alert, as in
+ * `hq sources sync`. A printed alert does not record the hourly dedupe entry,
+ * so it never holds back the bot's owner DM for the same company.
+ */
+export function terminalSignalsAlert(write = (text) => void process.stderr.write(text)) {
+    return {
+        sendOwnerDm: async (text) => {
+            write(chalk.red(`${text}\n`));
+        },
+        log: (message) => write(chalk.yellow(`${message}\n`)),
+        // A printed alert is not a delivered owner DM: leave the hourly dedupe to the bot.
+        recordsDelivery: false,
+    };
+}
+/**
+ * Exit codes (run record contract v2): 0 complete, partial, skipped or the
+ * job already ran today; 1 failed; 2 usage or config error; 3 another run
+ * holds a company's lock (stdout then carries {"status":"running",...}).
+ */
+export async function runSignalsCli(options, overrides = {}) {
+    const result = await runSignals({
+        hqRoot: options.hqRoot,
+        company: options.company,
+        dryRun: options.dryRun === true,
+        step: options.step,
+        trigger: options.trigger,
+        force: options.force === true,
+        catchUp: options.catchUp === true || envCatchUp(),
+        maxTurns: options.maxTurns,
+        maxBudgetUsd: options.maxBudgetUsd,
+        signalsAlert: overrides.signalsAlert ?? terminalSignalsAlert(),
+    });
+    const code = signalsExitCode(result);
+    if (options.reportFound) {
+        const reply = foundSignalsReply(result, options.company, localTimeZone());
+        if (reply)
+            process.stdout.write(`${reply}\n`);
+        if (code !== 0)
+            process.exitCode = code;
+        return;
+    }
+    const onlyLocked = result.records.length === 0 && result.locked.length === 1 ? result.locked[0] : undefined;
+    if (onlyLocked) {
+        const { status, startedAt, trigger } = onlyLocked;
+        process.stdout.write(`${JSON.stringify({ status, startedAt, trigger })}\n`);
+    }
+    else if (options.json) {
+        const payload = options.company && result.records.length === 1 ? result.records[0] : result;
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(formatRunResult(result, options.dryRun === true));
+    }
+    if (code !== 0)
+        process.exitCode = code;
+}
+export function registerSignalsRunSubcommand(signals) {
+    const run = signals.command("run");
+    // Usage errors (bad flag or choice) exit 2, not commander's default 1.
+    run.exitOverride((err) => process.exit(err.exitCode === 0 ? 0 : 2));
+    run
+        .description("Run the local signals engine (garden, adapters, extract, garden, upload) for companies with capture on")
+        .option("--company <slug>", "Run one company (default: every company listed in the companies manifest)")
+        .option("--dry-run", "Print what would run; run no mutating step and write nothing")
+        .addOption(new Option("--step <step>", "Run one step").choices([...SIGNALS_STEP_CHOICES]).default("all"))
+        .addOption(new Option("--trigger <trigger>", "What started the run").choices([...SIGNALS_TRIGGERS]).default("manual"))
+        .option("--force", "Rerun a job trigger that already ran today")
+        .option("--catch-up", "Mark the run as a catch-up run (also HQ_SIGNALS_CATCH_UP=1)")
+        .option("--max-turns <n>", "Model turn cap for the extract step (default from core/settings/signals.yaml, else 40)", parsePositiveInt)
+        .option("--max-budget-usd <x>", "Spend cap in USD for the extract step (default from core/settings/signals.yaml, else 2.00)", parseNonNegative)
+        .option("--json", "Print the run record as JSON")
+        .option("--report-found", "Print the owner's run reply only when the run found new signals; print nothing otherwise")
+        .option("--hq-root <path>", `HQ root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
+        .action(async (options) => {
+        try {
+            await runSignalsCli(options);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(chalk.red(`✗ ${message}\n`));
+            if (err instanceof SignalsUsageError) {
+                process.exitCode = 2;
+                return;
+            }
+            Sentry.captureException(err);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=signals-run.js.map

package/dist/commands/signals.d.ts

@@ -12,6 +12,7 @@
  *   hq signals get       Fetch one signal by id.
  *   hq signals types     Print the canonical SIGNAL_TYPES enum.
  *   hq signals entities  List entities the caller has access to.
+ *   hq signals run       Run the local signals engine (signals-run.ts).
  *
  * Mirrors `hq sources` exactly — same flags, same TTY-aware defaults,
  * same error/Sentry plumbing. Defense-in-depth signal-type validation

package/dist/commands/signals.js

@@ -12,6 +12,7 @@
  *   hq signals get       Fetch one signal by id.
  *   hq signals types     Print the canonical SIGNAL_TYPES enum.
  *   hq signals entities  List entities the caller has access to.
+ *   hq signals run       Run the local signals engine (signals-run.ts).
  *
  * Mirrors `hq sources` exactly — same flags, same TTY-aware defaults,
  * same error/Sentry plumbing. Defense-in-depth signal-type validation
@@ -25,6 +26,7 @@ import chalk from "chalk";
 import { SIGNAL_TYPES, assertSignalType, resolveEntity, listAvailableEntities, listSignals, getSignal, VaultClient, } from "@indigoai-us/hq-cloud";
 import { ensureCognitoToken, buildVaultConfig, DEFAULT_HQ_ROOT, } from "../utils/cognito-session.js";
 import { Sentry } from "../sentry.js";
+import { registerSignalsRunSubcommand } from "./signals-run.js";
 // ---------------------------------------------------------------------------
 // Access token resolution — honors HQ_ACCESS_TOKEN for tests + CI smoke
 // ---------------------------------------------------------------------------
@@ -262,5 +264,6 @@ export function registerSignalsCommand(program) {
         .description("List entities (companies/personal) your account has access to")
         .option("--format <fmt>", "Output format: table | json (default: table for TTY, json piped)")
         .action(withErrorHandling(async (options) => runEntities(options)));
+    registerSignalsRunSubcommand(signals);
 }
 //# sourceMappingURL=signals.js.map

package/dist/commands/sources.d.ts

@@ -23,7 +23,9 @@
 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 AdapterFlagReader } from "../lib/signals/adapters-catalog.js";
 import { type SelectionLoader } from "../lib/hot-channels/selection.js";
+import { type FleetCronOps } from "../lib/bot/fleet-cron.js";
 import { type ScheduleReport } from "../lib/hot-channels/schedule.js";
 import { type OnDemandSyncDeps, type OnDemandSyncReport } from "../lib/hot-channels/run.js";
 type ListFormat = "table" | "json";
@@ -74,6 +76,13 @@ export interface CompanyHotChannelSyncInput {
     hqRoot: string;
     company: string;
     adapter?: string;
+    /** Registered adapter ids allowed to run; see OnDemandSyncInput.onlyAdapters. */
+    onlyAdapters?: readonly string[];
+    /**
+     * Company flag reader for the adapter gate. Defaults to the shared hq-flags
+     * evaluator for this company with the signed-in session.
+     */
+    isFlagOn?: AdapterFlagReader;
     registry?: HotChannelRegistry;
     now?: () => Date;
     /** `scheduled` for the bot's hot-signal-sync job; `on-demand` by default. */
@@ -131,6 +140,8 @@ export interface ScheduleOverrides {
     botsRoot?: string;
     /** Whose ledger to read; defaults to the signed-in person. */
     email?: string;
+    /** The HQ Fleet Runtime schedule of one bot; defaults to the bot's own runtime. */
+    fleetOps?: (agentUid: string) => FleetCronOps;
 }
 export declare class NoHotSignalSyncJobError extends Error {
     readonly company: string;