@indigoai-us/hq-cli 5.345.177 → 5.345.179

package/dist/lib/bot/fleet-local.js

@@ -7,20 +7,46 @@ import { HQ_FLEET_RUNTIME_ENGINE_ID, } from "./config.js";
 import { ensureFleetPython, fleetUvEnv } from "./fleet-python.js";
 import { ensureCognitoToken } from "../../utils/cognito-session.js";
 import { vaultApiFetch } from "../../utils/vault-api.js";
+/** The model the HQ Fleet Runtime asks for when a Claude bot names none. */
+export const FLEET_CLAUDE_DEFAULT_MODEL = "claude-opus-5-5";
+/**
+ * The runtime provider for a bot created from a model CLI choice. Claude uses
+ * the runtime's native Anthropic provider, which reads the owner's Claude Code
+ * login, so it needs no sign-in of its own; ChatGPT and Grok sign in with
+ * `hq bot auth`.
+ */
+export function fleetProviderForRuntime(runtime, model) {
+    if (runtime === "claude") {
+        const requested = model?.trim() ?? "";
+        return { id: "anthropic", model: /^claude-[a-z0-9.-]+$/.test(requested) ? requested : FLEET_CLAUDE_DEFAULT_MODEL };
+    }
+    const preset = providerProfiles[runtime === "grok" ? "grok" : "chatgpt"];
+    return {
+        id: preset.provider,
+        model: model?.trim() || preset.model,
+        credentialProvider: preset.runtimeProvider,
+        baseUrl: preset.baseUrl,
+        transport: preset.transport,
+    };
+}
+/** True when a bot with this provider still needs `hq bot auth` before it can answer. */
+export function fleetProviderNeedsSignIn(provider) {
+    return provider.id !== "anthropic";
+}
 export const HQ_FLEET_LOCAL_RELEASE = {
     repository: "indigoai-us/hq-fleet-local",
-    tag: "v0.4.6",
-    version: "0.4.6",
-    artifact: "hq-fleet-local-0.4.6.zip",
-    artifactSha256: "24e48887dd4450ad63eda11e61f78363b0cc53b3fc87e3fd21bfe97e4a430865",
+    tag: "v0.4.13",
+    version: "0.4.13",
+    artifact: "hq-fleet-local-0.4.13.zip",
+    artifactSha256: "81b129ac129578240af9091b06ae190f47f6be38ff933b35ae5459d5b78c72df",
     runtimeArtifact: "hq-fleet-runtime-abccac13bd9e.tar",
     runtimeArtifactSha256: "29bcfe718ad7fbd3636afd00623772f2a25bc84c4f6f10d8d57f38e549d528d5",
-    manifestSha256: "5cc06b30a724419c22f4ab116db1ae745158d33c4aa46c7be04d29639172af1d",
-    signatureSha256: "b7a6c771dc674423b56db36f58b5a2a2a49eb2e27b33a41206fcc228a11d1def",
+    manifestSha256: "42654f91264099ce173ce3a9f42e207f566e1412ea4b550dc21775d764327bbb",
+    signatureSha256: "93cf9b0a94d75c532454243e3391e421e2743f59f8e65989a5a56ec9152e2fa4",
     runtimeCommit: "abccac13bd9ea593b24c8cd9c0ba28d5c6050cc9",
 };
 export const HQ_FLEET_LOCAL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEAOOL7NRKQgjMYI5cWxLY+HGppXf2AtwpQbCg5v+nBksM=
+MCowBQYDK2VwAyEAbYvc1pwOmiCUPJv8yIa3E9RXfniFA84nH2+ROmLMGZU=
 -----END PUBLIC KEY-----
 `;
 function digest(value) {
@@ -417,7 +443,9 @@ function replaceProfileProvider(profilePath, agentUid, provider) {
     const credentialProviders = Array.isArray(profile.credentialProviders)
         ? profile.credentialProviders.filter((value) => typeof value === "string")
         : [];
-    profile.credentialProviders = [...new Set([...credentialProviders, provider.credentialProvider])];
+    profile.credentialProviders = [
+        ...new Set([...credentialProviders, ...(provider.credentialProvider ? [provider.credentialProvider] : [])]),
+    ];
     const temporary = `${profilePath}.${process.pid}.${crypto.randomUUID()}`;
     fs.writeFileSync(temporary, `${JSON.stringify(profile, null, 2)}\n`, { mode: 0o600 });
     fs.renameSync(temporary, profilePath);
@@ -498,6 +526,16 @@ export function authenticateFleetLocalBot(input, deps = {}) {
     if (!/^[a-z0-9][a-z0-9._:-]*$/.test(requested)) {
         throw expectedError("HQ Fleet provider identifier is invalid.");
     }
+    if ((requested === "claude" || requested === "anthropic") && !input.apiKey) {
+        const files = fleetLocalExecutables(input.agentUid, deps);
+        const run = deps.run ?? execFileSync;
+        const native = fleetProviderForRuntime("claude", input.model);
+        replaceProfileProvider(files.profile, input.agentUid, native);
+        runJson(run, files.helper, ["render-profile", "--spec", files.profile, "--mode", "update"], { stdio: ["ignore", "pipe", "pipe"] }, "profile update");
+        runJson(run, files.helper, ["doctor-profile", "--profile", files.profileDir, "--runtime", files.runtime], { stdio: ["ignore", "pipe", "pipe"] }, "profile validation");
+        const restarted = controlFleetLocalBot(input.agentUid, input.installService ? "install" : "restart", deps).ok === true;
+        return { provider: requested, runtimeProvider: "anthropic", model: native.model, authenticated: true, restarted };
+    }
     const known = providerProfiles[requested];
     const provider = known ?? {
         provider: `custom:personal-${requested}`,
@@ -558,7 +596,7 @@ export function authenticateFleetLocalBot(input, deps = {}) {
     });
     runJson(run, files.helper, ["render-profile", "--spec", files.profile, "--mode", "update"], { stdio: ["ignore", "pipe", "pipe"] }, "profile update");
     runJson(run, files.helper, ["doctor-profile", "--profile", files.profileDir, "--runtime", files.runtime], { stdio: ["ignore", "pipe", "pipe"] }, "profile validation");
-    const restarted = controlFleetLocalBot(input.agentUid, "restart", deps).ok === true;
+    const restarted = controlFleetLocalBot(input.agentUid, input.installService ? "install" : "restart", deps).ok === true;
     return {
         provider: requested,
         runtimeProvider: provider.runtimeProvider,
@@ -583,7 +621,8 @@ export function writeFleetLocalProfile(input, deps = {}) {
         schemaVersion: 1,
         botId: input.agentUid,
         ownerUid: input.ownerUid,
-        provider: { id: "custom:personal-chatgpt", model: "gpt-5.6-sol" },
+        ...(input.ownerCompanies?.length ? { ownerCompanies: [...new Set(input.ownerCompanies)].sort() } : {}),
+        provider: input.provider ?? { id: "custom:personal-chatgpt", model: "gpt-5.6-sol" },
         hqRoot: path.resolve(input.hqRoot),
         profileDir: path.resolve(dir),
         runtime: { commit: input.installation.release.runtimeCommit, path: path.resolve(runtimeDir) },
@@ -599,6 +638,24 @@ export function writeFleetLocalProfile(input, deps = {}) {
     fs.renameSync(temporary, destination);
     if (input.systemPrompt !== undefined)
         writeFleetLocalSoul(input.agentUid, input.systemPrompt, { fleetHome: root });
+    if (input.firstStart && (input.firstStart.intro || input.firstStart.kickoff)) {
+        writeFleetLocalFirstStart(dir, input.firstStart);
+    }
+    return destination;
+}
+/** The runtime's inbox plugin sends the intro and runs the kickoff once, then stamps this file. */
+export function writeFleetLocalFirstStart(profileDir, firstStart) {
+    const destination = path.join(profileDir, "first-start.json");
+    if (fs.existsSync(destination))
+        return destination;
+    const temporary = path.join(profileDir, `.first-start-${process.pid}-${crypto.randomUUID()}`);
+    const record = {
+        schemaVersion: 1,
+        ...(firstStart.intro ? { intro: firstStart.intro } : {}),
+        ...(firstStart.kickoff ? { kickoff: firstStart.kickoff } : {}),
+    };
+    fs.writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, destination);
     return destination;
 }
 export function writeFleetLocalSoul(agentUid, systemPrompt, deps = {}) {
@@ -669,6 +726,24 @@ function checkedRun(run, executable, args, options, label) {
         throw expectedError(`HQ Fleet Local ${label} failed.`);
     }
 }
+/** Moves a fresh machine credential into the bot's secure store and deletes the file. */
+export function importFleetLocalMachineCredential(agentUid, machineCredentials, deps = {}) {
+    const run = deps.run ?? execFileSync;
+    const files = fleetLocalExecutables(agentUid, deps);
+    const machineValue = fs.readFileSync(machineCredentials, "utf8").trim();
+    if (!machineValue) {
+        throw expectedError(`HQ Fleet Local machine credential file is empty: ${machineCredentials}`);
+    }
+    checkedRun(run, files.helper, [
+        "machine-credential",
+        "import",
+        "--profile",
+        files.profileDir,
+        "--bot-id",
+        agentUid,
+    ], { input: machineValue, stdio: ["pipe", "ignore", "pipe"] }, "machine credential import");
+    fs.rmSync(machineCredentials, { force: true });
+}
 export async function bootstrapFleetLocalBot(input, deps = {}) {
     const run = deps.run ?? execFileSync;
     const platform = deps.platform ?? process.platform;
@@ -716,7 +791,7 @@ export async function bootstrapFleetLocalBot(input, deps = {}) {
             "--python",
             runtimePython,
             "--editable",
-            `${runtimeSource}[all,messaging,slack,anthropic]`,
+            `${runtimeSource}[mcp,anthropic]`,
             distributionSource,
         ], { stdio: ["ignore", 2, 2], env: uvEnv }, "package installation");
         fs.writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, engine: input.installation.engine }, null, 2)}\n`, { mode: 0o600 });

package/dist/lib/bot/index.d.ts

@@ -26,5 +26,6 @@ export * from "./lock.js";
 export * from "./display-name.js";
 export * from "./decisions.js";
 export * from "./fleet-local.js";
+export * from "./fleet-default-flag.js";
 export * from "./fleet-python.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/bot/index.js

@@ -26,5 +26,6 @@ export * from "./lock.js";
 export * from "./display-name.js";
 export * from "./decisions.js";
 export * from "./fleet-local.js";
+export * from "./fleet-default-flag.js";
 export * from "./fleet-python.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/bot/jobs/hot-signal-sync.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The bot's built-in hot-signal-sync job.
+ *
+ * A local bot that is bound to a company registers one recurring job in its
+ * own `jobs.json` the first time it starts (`ensureHotSignalSyncJob`). The job
+ * fires from the bot's inbox loop like every other local job
+ * (lib/bot/local-jobs.ts): no crontab, launchd or systemd entry is written.
+ * The default schedule is 06:30 daily in the machine's time zone, ahead of a
+ * morning brief; the owner changes it with
+ * `hq bot jobs <bot> --reschedule <jobId> --every "<when>"`, or removes it with
+ * `--rm`, and a removed job is not added back on the next start.
+ *
+ * When the job fires the bot runs the sync in-process, with no model turn
+ * (`runHotSignalSyncJob`): the same hot-channel sync `hq sources sync` runs,
+ * with `trigger: "scheduled"` and `catchUp` set when the run fired late after
+ * a missed window. Catch-up is bounded by each adapter's `catchUpWindow`, and
+ * per-connection cursors keep a redelivered run from landing anything twice.
+ * The claude signals pass (US-011) runs after each adapter when the bot wires
+ * one in; with none the signals count is 0.
+ */
+import type { HotChannelRunResult, WriteGuard } from "../../hot-channels/loop.js";
+import type { RunTrigger } from "../../hot-channels/ledger.js";
+import type { OnDemandSyncReport } from "../../hot-channels/run.js";
+import { type BotConfig } from "../config.js";
+import { type LocalJob } from "../local-jobs.js";
+export declare const HOT_SIGNAL_SYNC_JOB_KIND = "hot-signal-sync";
+/**
+ * 06:30 every day, in the job's time zone (the stored EventBridge form of
+ * "30 6 * * *"). Only the first registration uses it; after that the job's
+ * own schedule in `jobs.json` is the one that runs.
+ */
+export declare const HOT_SIGNAL_SYNC_DEFAULT_CRON = "cron(30 6 * * ? *)";
+/** The private context that marks a job as this built-in, for one company. */
+export declare function hotSignalSyncJobContext(company: string): Record<string, unknown>;
+/** The company a job item syncs, when its context marks it as this built-in; else null. */
+export declare function hotSignalSyncJobCompany(context: unknown): string | null;
+/**
+ * The company a bot's hot-signal-sync job syncs: the bot's own company, else
+ * the first company it serves. Null = none, and no job is registered. There is
+ * no fallback to the HQ's active company: a personal bot syncs a company only
+ * when it was given one explicitly (`--company`), so the job never writes into
+ * a vault the bot does not belong to. Checked again each time the job fires.
+ */
+export declare function currentHotSignalSyncCompany(config: Pick<BotConfig, "companySlug" | "kind" | "companies" | "workerId">): string | null;
+/**
+ * Remove every hot-signal-sync job whose company is not `current` (all of them
+ * when `current` is null), and forget their registration so the company can be
+ * registered again if the bot is given it back. Returns the removed jobs.
+ */
+export declare function removeStaleHotSignalSyncJobs(dir: string, current: string | null): LocalJob[];
+export interface EnsureHotSignalSyncJobResult {
+    /** The job, or null when the owner removed it after it was first registered. */
+    job: LocalJob | null;
+    created: boolean;
+}
+/**
+ * Register the hot-signal-sync job for `company` once. Safe to call on every
+ * bot start: an existing job is left as it is (including a changed schedule),
+ * and a job the owner removed is not added again.
+ */
+export declare function ensureHotSignalSyncJob(dir: string, input: {
+    company: string;
+    timezone: string;
+}, now?: Date): EnsureHotSignalSyncJobResult;
+/**
+ * The signals pass over one adapter's landed sources: how many signals it
+ * generated. The bot wires the local `claude -p` pass
+ * (`createClaudeSignalsPass`); `noLocalSignalsPass` is the default when no
+ * pass is given.
+ */
+export type LocalSignalsPass = (result: HotChannelRunResult, guard?: WriteGuard) => Promise<number>;
+export declare const noLocalSignalsPass: LocalSignalsPass;
+/** One company's hot-channel sync, as `runCompanyHotChannelSync` runs it (minus the HQ root). */
+export type HotSignalSyncFn = (input: {
+    company: string;
+    trigger: RunTrigger;
+    catchUp: boolean;
+    signalsGenerated: LocalSignalsPass;
+    now: () => Date;
+    /** The owner DM for the signals-failure alert (US-012); unset = no alert check. */
+    signalsAlert?: {
+        sendOwnerDm: (text: string) => Promise<void>;
+        log?: (message: string) => void;
+    };
+}) => Promise<OnDemandSyncReport>;
+export interface HotSignalSyncRunInput {
+    company: string;
+    /** The run fired late, after a missed window (job-run.ts `isCatchUpRun`). */
+    catchUp: boolean;
+    now: () => Date;
+    sync: HotSignalSyncFn;
+    signalsPass?: LocalSignalsPass;
+    /**
+     * Sends the signals-failure alert to the owner as its own message, even when
+     * the job is quiet. Throws when the message was not delivered.
+     */
+    sendAlert?: (text: string) => Promise<void>;
+    log?: (message: string) => void;
+}
+export interface HotSignalSyncRunOutcome {
+    ok: boolean;
+    /** Plain report for the owner's DM and the job's run output. */
+    text: string;
+    report: OnDemandSyncReport | null;
+}
+/** Run the scheduled sync once and describe it in plain words. Never throws. */
+export declare function runHotSignalSyncJob(input: HotSignalSyncRunInput): Promise<HotSignalSyncRunOutcome>;
+export declare function describeSyncReport(company: string, report: OnDemandSyncReport): string;
+//# sourceMappingURL=hot-signal-sync.d.ts.map

package/dist/lib/bot/jobs/hot-signal-sync.js

@@ -0,0 +1,177 @@
+/**
+ * The bot's built-in hot-signal-sync job.
+ *
+ * A local bot that is bound to a company registers one recurring job in its
+ * own `jobs.json` the first time it starts (`ensureHotSignalSyncJob`). The job
+ * fires from the bot's inbox loop like every other local job
+ * (lib/bot/local-jobs.ts): no crontab, launchd or systemd entry is written.
+ * The default schedule is 06:30 daily in the machine's time zone, ahead of a
+ * morning brief; the owner changes it with
+ * `hq bot jobs <bot> --reschedule <jobId> --every "<when>"`, or removes it with
+ * `--rm`, and a removed job is not added back on the next start.
+ *
+ * When the job fires the bot runs the sync in-process, with no model turn
+ * (`runHotSignalSyncJob`): the same hot-channel sync `hq sources sync` runs,
+ * with `trigger: "scheduled"` and `catchUp` set when the run fired late after
+ * a missed window. Catch-up is bounded by each adapter's `catchUpWindow`, and
+ * per-connection cursors keep a redelivered run from landing anything twice.
+ * The claude signals pass (US-011) runs after each adapter when the bot wires
+ * one in; with none the signals count is 0.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { JOB_RUN_OPTIONS_CONTEXT_KEY } from "../job-run.js";
+import { effectiveBotCompanies } from "../config.js";
+import { ensureLocalJob, readLocalJobs, removeLocalJobsWhere, withJobsLock } from "../local-jobs.js";
+export const HOT_SIGNAL_SYNC_JOB_KIND = "hot-signal-sync";
+/**
+ * 06:30 every day, in the job's time zone (the stored EventBridge form of
+ * "30 6 * * *"). Only the first registration uses it; after that the job's
+ * own schedule in `jobs.json` is the one that runs.
+ */
+export const HOT_SIGNAL_SYNC_DEFAULT_CRON = "cron(30 6 * * ? *)";
+/** Which built-in jobs this bot has registered once, so a removed one stays removed. */
+const BUILTIN_JOBS_FILE = "builtin-jobs.json";
+function markerKey(company) {
+    return `${HOT_SIGNAL_SYNC_JOB_KIND}:${company}`;
+}
+function readMarker(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, BUILTIN_JOBS_FILE), "utf-8"));
+        if (parsed && parsed.v === 1 && parsed.registered && typeof parsed.registered === "object") {
+            return { v: 1, registered: { ...parsed.registered } };
+        }
+    }
+    catch {
+        // Missing or unreadable: nothing registered yet.
+    }
+    return { v: 1, registered: {} };
+}
+function writeMarker(dir, marker) {
+    const file = path.join(dir, BUILTIN_JOBS_FILE);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(marker, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+/** The private context that marks a job as this built-in, for one company. */
+export function hotSignalSyncJobContext(company) {
+    return { [JOB_RUN_OPTIONS_CONTEXT_KEY]: { builtin: HOT_SIGNAL_SYNC_JOB_KIND, company } };
+}
+/** The company a job item syncs, when its context marks it as this built-in; else null. */
+export function hotSignalSyncJobCompany(context) {
+    if (!context || typeof context !== "object" || Array.isArray(context))
+        return null;
+    const options = context[JOB_RUN_OPTIONS_CONTEXT_KEY];
+    if (!options || typeof options !== "object" || Array.isArray(options))
+        return null;
+    const { builtin, company } = options;
+    if (builtin !== HOT_SIGNAL_SYNC_JOB_KIND)
+        return null;
+    return typeof company === "string" && company.trim() ? company.trim() : null;
+}
+/**
+ * The company a bot's hot-signal-sync job syncs: the bot's own company, else
+ * the first company it serves. Null = none, and no job is registered. There is
+ * no fallback to the HQ's active company: a personal bot syncs a company only
+ * when it was given one explicitly (`--company`), so the job never writes into
+ * a vault the bot does not belong to. Checked again each time the job fires.
+ */
+export function currentHotSignalSyncCompany(config) {
+    return config.companySlug ?? effectiveBotCompanies(config)[0] ?? null;
+}
+/**
+ * Remove every hot-signal-sync job whose company is not `current` (all of them
+ * when `current` is null), and forget their registration so the company can be
+ * registered again if the bot is given it back. Returns the removed jobs.
+ */
+export function removeStaleHotSignalSyncJobs(dir, current) {
+    const removed = removeLocalJobsWhere(dir, (job) => {
+        const company = hotSignalSyncJobCompany(job.context);
+        return company !== null && company !== current;
+    });
+    const keep = current ? markerKey(current) : null;
+    withJobsLock(dir, () => {
+        const marker = readMarker(dir);
+        let changed = false;
+        for (const key of Object.keys(marker.registered)) {
+            if (key.startsWith(HOT_SIGNAL_SYNC_JOB_KIND + ":") && key !== keep) {
+                delete marker.registered[key];
+                changed = true;
+            }
+        }
+        if (changed)
+            writeMarker(dir, marker);
+    });
+    return removed;
+}
+/**
+ * Register the hot-signal-sync job for `company` once. Safe to call on every
+ * bot start: an existing job is left as it is (including a changed schedule),
+ * and a job the owner removed is not added again.
+ */
+export function ensureHotSignalSyncJob(dir, input, now = new Date()) {
+    const key = markerKey(input.company);
+    const matches = (job) => hotSignalSyncJobCompany(job.context) === input.company;
+    if (readMarker(dir).registered[key]) {
+        return { job: readLocalJobs(dir).find(matches) ?? null, created: false };
+    }
+    const { job, created } = ensureLocalJob(dir, matches, {
+        prompt: `Sync hot channels for ${input.company} and run the signals pass (runs in the bot, no model turn).`,
+        cron: HOT_SIGNAL_SYNC_DEFAULT_CRON,
+        timezone: input.timezone,
+        context: hotSignalSyncJobContext(input.company),
+    }, now);
+    withJobsLock(dir, () => {
+        const marker = readMarker(dir);
+        if (!marker.registered[key]) {
+            marker.registered[key] = now.toISOString();
+            writeMarker(dir, marker);
+        }
+    });
+    return { job, created };
+}
+export const noLocalSignalsPass = async () => 0;
+/** Run the scheduled sync once and describe it in plain words. Never throws. */
+export async function runHotSignalSyncJob(input) {
+    const signalsPass = input.signalsPass ?? noLocalSignalsPass;
+    let report;
+    try {
+        report = await input.sync({
+            company: input.company,
+            trigger: "scheduled",
+            catchUp: input.catchUp,
+            signalsGenerated: signalsPass,
+            now: input.now,
+            ...(input.sendAlert
+                ? { signalsAlert: { sendOwnerDm: input.sendAlert, ...(input.log ? { log: input.log } : {}) } }
+                : {}),
+        });
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return { ok: false, text: `The hot-channel sync for ${input.company} failed: ${reason}`, report: null };
+    }
+    return { ok: report.exitCode === 0 && !report.signInRequired, text: describeSyncReport(input.company, report), report };
+}
+export function describeSyncReport(company, report) {
+    if (report.signInRequired) {
+        return `The hot-channel sync for ${company} did not run: ${report.notices.join(" ")}`;
+    }
+    if (report.skipped)
+        return report.notices.join(" ");
+    const landed = report.outcomes.reduce((sum, o) => sum + o.landed, 0);
+    const signals = report.entries.reduce((sum, e) => sum + e.signalsGenerated, 0);
+    const lines = [
+        `Hot-channel sync for ${company}: ${landed} new source${landed === 1 ? "" : "s"}, ${signals} signal${signals === 1 ? "" : "s"}.`,
+    ];
+    for (const outcome of report.outcomes) {
+        if (outcome.status === "ok")
+            continue;
+        const label = outcome.appName ?? outcome.adapter;
+        lines.push(`- ${label}: ${outcome.reconnect?.prompt ?? outcome.message ?? outcome.status}`);
+    }
+    for (const notice of report.notices)
+        lines.push(notice);
+    return lines.join("\n");
+}
+//# sourceMappingURL=hot-signal-sync.js.map

package/dist/lib/bot/local-config.js

@@ -41,7 +41,7 @@ export function buildBotLocalConfig(config) {
     const companies = effectiveBotCompanies(config);
     const local = {
         v: 1,
-        ...(config.engine ? {} : { runtime: config.runtime }),
+        runtime: config.runtime,
         ...(config.engine ? { engine: config.engine } : {}),
         workerSource: config.workerSource ?? "scaffold",
         ...(config.workerId ? { workerId: config.workerId } : {}),

package/dist/lib/bot/local-jobs.d.ts

@@ -18,7 +18,7 @@
  * - A fire is recorded before it is handed over, so a crash never runs the
  *   same due time twice.
  */
-import { type BotApi, type InboxItem } from "./api.js";
+import { type BotApi, type BotJobRecord, type InboxItem } from "./api.js";
 export interface LocalJob {
     jobId: string;
     prompt: string;
@@ -27,6 +27,12 @@ export interface LocalJob {
     timezone: string;
     context?: Record<string, unknown>;
     createdAt: string;
+    /**
+     * When the schedule was last changed (`hq bot jobs --reschedule`). Fire
+     * times before it are never treated as missed, so a new schedule does not
+     * fire a catch-up for a time that only matches the new expression.
+     */
+    scheduledFrom?: string;
     /** The newest due time already handed to the bot. */
     lastFiredAt?: string;
     /** The run in progress, if any. */
@@ -72,6 +78,29 @@ export declare function addLocalJob(dir: string, input: {
     timezone: string;
     context?: Record<string, unknown>;
 }, now?: Date): LocalJob;
+/**
+ * Add a job unless one already matches, as one locked read-and-write, so two
+ * bot starts racing each other still leave a single job.
+ */
+export declare function ensureLocalJob(dir: string, matches: (job: LocalJob) => boolean, input: {
+    prompt: string;
+    cron: string;
+    timezone: string;
+    context?: Record<string, unknown>;
+}, now?: Date): {
+    job: LocalJob;
+    created: boolean;
+};
+/**
+ * Change a job's schedule in place, keeping its id, instruction, context and
+ * run history. Returns null when the bot has no job with that id.
+ */
+export declare function rescheduleLocalJob(dir: string, jobId: string, schedule: {
+    cron: string;
+    timezone: string;
+}, now?: Date): LocalJob | null;
+/** Remove every job `matches` picks, as one locked read-and-write. Returns the removed jobs. */
+export declare function removeLocalJobsWhere(dir: string, matches: (job: LocalJob) => boolean): LocalJob[];
 /** Forget the once-per-minute check (tests, and a bot restarted in-process). */
 export declare function resetLocalJobChecks(): void;
 export declare function takeDueLocalJobRuns(dir: string, now?: Date): InboxItem[];
@@ -81,9 +110,16 @@ export declare function takeDueLocalJobRuns(dir: string, now?: Date): InboxItem[
  * locally instead of being sent to the cloud.
  */
 export declare function withLocalJobs(api: BotApi, dir: string, clock?: () => Date): BotApi;
+/** What `hq bot jobs` uses: list, add, remove, and (local bots) reschedule. */
+export type LocalJobsApi = Pick<BotApi, "listJobs" | "createJob" | "cancelJob"> & {
+    rescheduleJob?(agentUid: string, jobId: string, schedule: {
+        cron: string;
+        timezone: string;
+    }): Promise<BotJobRecord>;
+};
 /**
- * `hq bot jobs` against the bot's own folder: the same three calls the cloud
- * client offers, answered from `jobs.json`.
+ * `hq bot jobs` against the bot's own folder: the same calls the cloud client
+ * offers, plus reschedule, answered from `jobs.json`.
  */
-export declare function localJobsClient(dir: string, clock?: () => Date): Pick<BotApi, "listJobs" | "createJob" | "cancelJob">;
+export declare function localJobsClient(dir: string, clock?: () => Date): Required<LocalJobsApi>;
 //# sourceMappingURL=local-jobs.d.ts.map

package/dist/lib/bot/local-jobs.js

@@ -237,10 +237,14 @@ function rateIntervalMs(expr) {
 function isRunnableSchedule(expr) {
     return rateIntervalMs(expr) !== null || parseCron(expr) !== null;
 }
+/** Where the current schedule starts counting: its last change, else creation. */
+function scheduleOrigin(job) {
+    return Date.parse(job.scheduledFrom ?? job.createdAt);
+}
 export function latestDueFire(job, now) {
     const interval = rateIntervalMs(job.cron);
     if (interval) {
-        const origin = Date.parse(job.createdAt);
+        const origin = scheduleOrigin(job);
         const steps = Math.floor((now.getTime() - origin) / interval);
         if (steps < 1)
             return null;
@@ -252,7 +256,7 @@ export function latestDueFire(job, now) {
         return null;
     const start = new Date(now);
     start.setUTCSeconds(0, 0);
-    const floor = Math.max(job.lastFiredAt ? Date.parse(job.lastFiredAt) : Date.parse(job.createdAt), start.getTime() - LOOKBACK_MINUTES * 60_000);
+    const floor = Math.max(job.lastFiredAt ? Date.parse(job.lastFiredAt) : Date.parse(job.createdAt), job.scheduledFrom ? Date.parse(job.scheduledFrom) : 0, start.getTime() - LOOKBACK_MINUTES * 60_000);
     for (let t = start.getTime(); t > floor; t -= 60_000) {
         const at = new Date(t);
         if (cronMatches(cron, at, job.timezone))
@@ -264,7 +268,7 @@ export function latestDueFire(job, now) {
 export function nextDueFire(job, now) {
     const interval = rateIntervalMs(job.cron);
     if (interval) {
-        const origin = Date.parse(job.createdAt);
+        const origin = scheduleOrigin(job);
         const steps = Math.max(0, Math.floor((now.getTime() - origin) / interval)) + 1;
         return new Date(origin + steps * interval);
     }
@@ -310,6 +314,53 @@ export function addLocalJob(dir, input, now = new Date()) {
     withJobsLock(dir, () => writeLocalJobs(dir, [...readLocalJobs(dir), job]));
     return job;
 }
+/**
+ * Add a job unless one already matches, as one locked read-and-write, so two
+ * bot starts racing each other still leave a single job.
+ */
+export function ensureLocalJob(dir, matches, input, now = new Date()) {
+    if (!isRunnableSchedule(input.cron))
+        throw new Error(`"${input.cron}" is not a schedule this bot can run.`);
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        const existing = jobs.find(matches);
+        if (existing)
+            return { job: existing, created: false };
+        const job = {
+            jobId: `job_${randomUUID().replace(/-/g, "").slice(0, 20)}`,
+            prompt: input.prompt,
+            cron: input.cron,
+            timezone: input.timezone,
+            ...(input.context ? { context: input.context } : {}),
+            createdAt: now.toISOString(),
+        };
+        writeLocalJobs(dir, [...jobs, job]);
+        return { job, created: true };
+    });
+}
+/**
+ * Change a job's schedule in place, keeping its id, instruction, context and
+ * run history. Returns null when the bot has no job with that id.
+ */
+export function rescheduleLocalJob(dir, jobId, schedule, now = new Date()) {
+    if (!isRunnableSchedule(schedule.cron))
+        throw new Error(`"${schedule.cron}" is not a schedule this bot can run.`);
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        const index = jobs.findIndex((job) => job.jobId === jobId);
+        if (index < 0)
+            return null;
+        const updated = {
+            ...jobs[index],
+            cron: schedule.cron,
+            timezone: schedule.timezone,
+            scheduledFrom: now.toISOString(),
+        };
+        jobs[index] = updated;
+        writeLocalJobs(dir, jobs);
+        return updated;
+    });
+}
 /** Remove a job. Returns false when the bot has no job with that id. */
 function removeLocalJob(dir, jobId) {
     return withJobsLock(dir, () => {
@@ -321,6 +372,16 @@ function removeLocalJob(dir, jobId) {
         return true;
     });
 }
+/** Remove every job `matches` picks, as one locked read-and-write. Returns the removed jobs. */
+export function removeLocalJobsWhere(dir, matches) {
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        const removed = jobs.filter(matches);
+        if (removed.length > 0)
+            writeLocalJobs(dir, jobs.filter((job) => !matches(job)));
+        return removed;
+    });
+}
 // ─── Firing ──────────────────────────────────────────────────────────────────
 /**
  * Hand over every job that is due now. Each fire is recorded (lastFiredAt and
@@ -430,8 +491,8 @@ export function withLocalJobs(api, dir, clock = () => new Date()) {
 /** The most jobs one bot may hold (the same cap the cloud uses). */
 const MAX_LOCAL_JOBS = 25;
 /**
- * `hq bot jobs` against the bot's own folder: the same three calls the cloud
- * client offers, answered from `jobs.json`.
+ * `hq bot jobs` against the bot's own folder: the same calls the cloud client
+ * offers, plus reschedule, answered from `jobs.json`.
  */
 export function localJobsClient(dir, clock = () => new Date()) {
     return {
@@ -454,6 +515,12 @@ export function localJobsClient(dir, clock = () => new Date()) {
                 throw new BotApiError(404, "local jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
             }
         },
+        async rescheduleJob(_agentUid, jobId, schedule) {
+            const job = rescheduleLocalJob(dir, jobId, schedule, clock());
+            if (!job)
+                throw new BotApiError(404, "local jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
+            return toJobRecord(job, clock());
+        },
     };
 }
 //# sourceMappingURL=local-jobs.js.map