@indigoai-us/hq-cli 5.345.198 → 5.345.199

package/dist/lib/bot/claude-login.js

@@ -0,0 +1,160 @@
+/**
+ * Can a Claude bot on the HQ Fleet Runtime read a Claude Code login here?
+ *
+ * The runtime never runs the `claude` binary; it calls Anthropic with the
+ * owner's Claude Code OAuth token, read in this order (its
+ * `resolve_anthropic_token`): ANTHROPIC_TOKEN, CLAUDE_CODE_OAUTH_TOKEN and
+ * ANTHROPIC_API_KEY from the environment, the HQ Fleet login file,
+ * ~/.claude/.credentials.json, then the macOS Keychain item
+ * "Claude Code-credentials". This mirrors that order so `hq doctor` and
+ * `hq bot create` can say which sources were checked and why each failed,
+ * without printing a token.
+ */
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fleetHome } from "./fleet-local.js";
+export const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+export const CLAUDE_LOGIN_ENV_VARS = ["ANTHROPIC_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"];
+function readKeychainWithSecurity() {
+    try {
+        const stdout = execFileSync("security", ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 5000,
+        });
+        return { code: 0, stdout, stderr: "" };
+    }
+    catch (error) {
+        const failure = error;
+        const stderr = failure.stderr ? String(failure.stderr) : (failure.message ?? "");
+        return { code: typeof failure.status === "number" ? failure.status : -1, stdout: "", stderr };
+    }
+}
+function oauthRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    const accessToken = typeof record.accessToken === "string" ? record.accessToken.trim() : "";
+    if (!accessToken)
+        return null;
+    return {
+        accessToken,
+        refreshToken: typeof record.refreshToken === "string" ? record.refreshToken : "",
+        expiresAt: typeof record.expiresAt === "number" ? record.expiresAt : 0,
+    };
+}
+function describeRecord(record, now) {
+    if (!record.expiresAt || now < record.expiresAt - 60_000) {
+        return { status: "ok", reason: "access token present and not expired", usable: true };
+    }
+    if (record.refreshToken) {
+        return { status: "expired", reason: "access token expired; the bot refreshes it with the refresh token", usable: true };
+    }
+    return { status: "expired", reason: "access token expired and no refresh token", usable: false };
+}
+function readJsonFile(file) {
+    if (!fs.existsSync(file))
+        return { parsed: null, problem: `${file} does not exist` };
+    try {
+        return { parsed: JSON.parse(fs.readFileSync(file, "utf8")), problem: null };
+    }
+    catch (error) {
+        return { parsed: null, problem: `${file} could not be read (${error.message})` };
+    }
+}
+export function checkClaudeCodeLogin(deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? os.homedir();
+    const platform = deps.platform ?? process.platform;
+    const now = (deps.now ?? Date.now)();
+    const sources = [];
+    let via = null;
+    const found = (source) => {
+        if (via === null)
+            via = source;
+    };
+    for (const name of CLAUDE_LOGIN_ENV_VARS) {
+        const set = !!env[name]?.trim();
+        sources.push({ source: `env:${name}`, status: set ? "ok" : "missing", reason: set ? "set" : "not set in this environment" });
+        if (set)
+            found(`env:${name}`);
+    }
+    const fleetLogin = path.join(fleetHome(home, env), ".anthropic_oauth.json");
+    const fleetFile = readJsonFile(fleetLogin);
+    const fleetRecord = fleetFile.parsed ? oauthRecord(fleetFile.parsed) : null;
+    if (fleetRecord) {
+        const described = describeRecord(fleetRecord, now);
+        sources.push({ source: "hq_fleet_oauth_file", status: described.status, reason: described.reason });
+        if (described.usable)
+            found("hq_fleet_oauth_file");
+    }
+    else {
+        sources.push({ source: "hq_fleet_oauth_file", status: "missing", reason: fleetFile.problem ?? `${fleetLogin} holds no access token` });
+    }
+    const credentialsFile = path.join(home, ".claude", ".credentials.json");
+    const claudeFile = readJsonFile(credentialsFile);
+    const claudeRecord = claudeFile.parsed ? oauthRecord(claudeFile.parsed.claudeAiOauth) : null;
+    if (claudeRecord) {
+        const described = describeRecord(claudeRecord, now);
+        sources.push({ source: "claude_code_credentials_file", status: described.status, reason: described.reason });
+        if (described.usable)
+            found("claude_code_credentials_file");
+    }
+    else {
+        sources.push({
+            source: "claude_code_credentials_file",
+            status: "missing",
+            reason: claudeFile.problem ?? `${credentialsFile} holds no claudeAiOauth access token`,
+        });
+    }
+    if (platform !== "darwin") {
+        sources.push({ source: "macos_keychain", status: "skipped", reason: "not macOS" });
+    }
+    else {
+        const read = (deps.readKeychain ?? readKeychainWithSecurity)();
+        if (read.code !== 0) {
+            const detail = read.stderr.replace(/\s+/g, " ").trim().slice(0, 200) || `exit ${read.code}`;
+            sources.push({ source: "macos_keychain", status: "missing", reason: `no readable '${CLAUDE_KEYCHAIN_SERVICE}' item (${detail})` });
+        }
+        else {
+            let payload;
+            try {
+                payload = JSON.parse(read.stdout.trim());
+            }
+            catch {
+                payload = null;
+            }
+            const record = payload && typeof payload === "object" ? oauthRecord(payload.claudeAiOauth) : null;
+            if (record) {
+                const described = describeRecord(record, now);
+                sources.push({ source: "macos_keychain", status: described.status, reason: described.reason });
+                if (described.usable)
+                    found("macos_keychain");
+            }
+            else {
+                sources.push({ source: "macos_keychain", status: "missing", reason: "keychain item has no claudeAiOauth access token" });
+            }
+        }
+    }
+    return { signedIn: via !== null, via, sources };
+}
+const SOURCE_LABELS = {
+    hq_fleet_oauth_file: "the HQ Fleet login file",
+    claude_code_credentials_file: "~/.claude/.credentials.json",
+    macos_keychain: "the macOS Keychain",
+};
+/** One sentence listing every source that did not yield a login. */
+export function describeClaudeLoginSources(check) {
+    const parts = check.sources
+        .filter((entry) => entry.status !== "ok" && entry.status !== "skipped")
+        .map((entry) => `${SOURCE_LABELS[entry.source] ?? entry.source.replace("env:", "")}: ${entry.reason}`);
+    return parts.length ? `Checked ${parts.join("; ")}.` : "";
+}
+export function claudeLoginFix(botName) {
+    return botName
+        ? `Run \`claude /login\` in a terminal on this computer, then \`hq bot restart ${botName}\`.`
+        : "Run `claude /login` in a terminal on this computer, then retry.";
+}
+//# sourceMappingURL=claude-login.js.map

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

@@ -0,0 +1,18 @@
+import type { InboxItem } from "./api.js";
+import { type LocalJob } from "./local-jobs.js";
+/** Rotate journals at five MiB without discarding unread records. */
+export declare const EVENT_ROTATE_BYTES: number;
+export declare const EVENT_PAYLOAD_BYTES: number;
+export interface BotEvent {
+    event: string;
+    at: string;
+    payload: Record<string, unknown>;
+}
+export declare function validateEventPayload(payload: unknown): asserts payload is Record<string, unknown>;
+export declare function emitBotEvent(dir: string, event: string, payload: unknown, now?: Date, alreadyEmitted?: (record: BotEvent) => boolean): BotEvent;
+export declare function eventMatches(job: LocalJob, record: BotEvent): boolean;
+/** Pending items survive a crash between queueing and the next poll. */
+export declare function drainBotEvents(dir: string): InboxItem[];
+export declare function ackBotEvent(dir: string, messageId: string): void;
+export declare function tailBotEvents(dir: string, predicate?: (event: BotEvent) => boolean): BotEvent[];
+//# sourceMappingURL=events.d.ts.map

package/dist/lib/bot/events.js

@@ -0,0 +1,160 @@
+/** Local event journal and durable inbox. Cursor and queued deliveries commit together. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { readLocalJobsStrict, withJobsLock } from "./local-jobs.js";
+/** Rotate journals at five MiB without discarding unread records. */
+export const EVENT_ROTATE_BYTES = 5 * 1024 * 1024;
+export const EVENT_PAYLOAD_BYTES = 16 * 1024;
+const journal = "events.jsonl";
+const stateFile = "events-state.json";
+export function validateEventPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        throw new Error("Event payload must be a JSON object.");
+    if (Buffer.byteLength(JSON.stringify(payload), "utf8") >= EVENT_PAYLOAD_BYTES)
+        throw new Error("Event payload must be under 16 KB.");
+}
+function readState(dir) {
+    try {
+        const state = JSON.parse(fs.readFileSync(path.join(dir, stateFile), "utf8"));
+        if (state.v !== 1 || !state.cursors || !Array.isArray(state.pending))
+            throw new Error("Invalid event state");
+        return state;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { v: 1, cursors: {}, pending: [] };
+        throw err; // Never reset a corrupt cursor and replay the journal.
+    }
+}
+function writeState(dir, state) {
+    const file = path.join(dir, stateFile);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function files(dir) {
+    return fs.readdirSync(dir).filter((f) => /^events\.\d+-[a-f0-9-]+\.jsonl$/.test(f)).sort().concat(journal);
+}
+/** A persisted intent makes both sides of the journal rename recoverable. */
+function recoverRotation(dir, state) {
+    if (!state.rotating)
+        return;
+    const archived = state.rotating;
+    if (!fs.existsSync(path.join(dir, archived))) {
+        fs.renameSync(path.join(dir, journal), path.join(dir, archived));
+    }
+    state.cursors[archived] = state.cursors[journal] ?? 0;
+    delete state.cursors[journal];
+    delete state.rotating;
+    writeState(dir, state);
+}
+export function emitBotEvent(dir, event, payload, now = new Date(), alreadyEmitted) {
+    if (!event.trim() || event.length > 256 || /[\r\n]/.test(event))
+        throw new Error("Event name must be 1–256 characters without newlines.");
+    validateEventPayload(payload);
+    const record = { event, at: now.toISOString(), payload };
+    return withJobsLock(dir, () => {
+        const state = readState(dir);
+        recoverRotation(dir, state);
+        // Optional producer idempotency: scan and append under the same lock as
+        // rotation, including archived journals and only fully written lines.
+        if (alreadyEmitted) {
+            for (const name of files(dir)) {
+                const candidate = path.join(dir, name);
+                if (!fs.existsSync(candidate))
+                    continue;
+                const lines = fs.readFileSync(candidate, "utf8").split("\n").slice(0, -1);
+                for (const line of lines.filter(Boolean)) {
+                    const prior = JSON.parse(line);
+                    if (alreadyEmitted(prior))
+                        return prior;
+                }
+            }
+        }
+        const file = path.join(dir, journal);
+        const bytes = fs.existsSync(file) ? fs.readFileSync(file) : Buffer.alloc(0);
+        // A process killed during append may leave an incomplete final line.
+        // It was never accepted as an event: discard it before the next append,
+        // otherwise that next valid record would join it and poison the drain.
+        const size = bytes.length && bytes.at(-1) !== 10 ? bytes.lastIndexOf(10) + 1 : bytes.length;
+        if (size !== bytes.length)
+            fs.truncateSync(file, size);
+        if (size >= EVENT_ROTATE_BYTES) {
+            state.rotating = `events.${Date.now()}-${randomUUID()}.jsonl`;
+            writeState(dir, state);
+            recoverRotation(dir, state);
+        }
+        fs.appendFileSync(file, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+        return record;
+    });
+}
+export function eventMatches(job, record) {
+    return job.trigger?.kind === "event" && job.trigger.event === record.event &&
+        Object.entries(job.trigger.filter ?? {}).every(([key, value]) => {
+            if (!Object.hasOwn(record.payload, key))
+                return false;
+            // JSON objects can shadow toString/valueOf with non-callable fields.
+            // Such a value cannot match a string filter and must not poison the drain.
+            try {
+                return String(record.payload[key]) === value;
+            }
+            catch {
+                return false;
+            }
+        });
+}
+/** Pending items survive a crash between queueing and the next poll. */
+export function drainBotEvents(dir) {
+    return withJobsLock(dir, () => {
+        const state = readState(dir);
+        recoverRotation(dir, state);
+        const jobs = readLocalJobsStrict(dir);
+        for (const name of files(dir)) {
+            const file = path.join(dir, name);
+            if (!fs.existsSync(file))
+                continue;
+            let offset = state.cursors[name] ?? 0;
+            // Consumed archives need only a stat, not a full read on every poll.
+            if (offset === fs.statSync(file).size)
+                continue;
+            const bytes = fs.readFileSync(file);
+            if (offset > bytes.length)
+                throw new Error(`Event journal was truncated: ${name}`);
+            while (offset < bytes.length) {
+                const end = bytes.indexOf(10, offset);
+                if (end < 0)
+                    break; // An interrupted append is never treated as a full event.
+                const record = JSON.parse(bytes.subarray(offset, end).toString("utf8"));
+                validateEventPayload(record.payload);
+                for (const job of jobs.filter((j) => eventMatches(j, record))) {
+                    state.pending.push({
+                        messageId: `localjob-event-${randomUUID()}`, channel: "job", jobId: job.jobId,
+                        prompt: job.prompt, firedAt: record.at, receivedAt: record.at,
+                        context: { ...job.context, payload: record.payload, event: record },
+                    });
+                }
+                offset = end + 1;
+            }
+            state.cursors[name] = offset;
+        }
+        writeState(dir, state);
+        return state.pending;
+    });
+}
+export function ackBotEvent(dir, messageId) {
+    withJobsLock(dir, () => {
+        const state = readState(dir);
+        state.pending = state.pending.filter((item) => item.messageId !== messageId);
+        writeState(dir, state);
+    });
+}
+export function tailBotEvents(dir, predicate = () => true) {
+    return withJobsLock(dir, () => files(dir).flatMap((name) => {
+        const file = path.join(dir, name);
+        if (!fs.existsSync(file))
+            return [];
+        return fs.readFileSync(file, "utf8").split("\n").slice(0, -1).filter(Boolean).map((line) => JSON.parse(line));
+    }).filter(predicate).slice(-50));
+}
+//# sourceMappingURL=events.js.map

package/dist/lib/bot/executive-settings.d.ts

@@ -0,0 +1,10 @@
+import { type BotConfig } from "./config.js";
+export declare function executiveRiderEnabled(home?: string): boolean;
+export declare function isExecutiveBot(config: Pick<BotConfig, "name" | "kind" | "workerId">, home?: string): boolean;
+export declare function executiveStatus(config: Pick<BotConfig, "name" | "kind" | "workerId">, dir: string, home?: string): {
+    is_executive: boolean;
+    rider_enabled: boolean;
+    detect_source_last: string | null;
+    last_detected_at: string | null;
+};
+//# sourceMappingURL=executive-settings.d.ts.map

package/dist/lib/bot/executive-settings.js

@@ -0,0 +1,43 @@
+/** Shared Executive identity and the desktop's default-on rider preference. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { effectiveBotKind } from "./config.js";
+import { tailBotEvents } from "./events.js";
+export function executiveRiderEnabled(home = os.homedir()) {
+    try {
+        const settings = JSON.parse(fs.readFileSync(path.join(home, ".hq/menubar.json"), "utf8"));
+        return settings?.executiveMeetingRider?.enabled !== false;
+    }
+    catch (err) {
+        return err.code === "ENOENT";
+    }
+}
+export function isExecutiveBot(config, home = os.homedir()) {
+    if (effectiveBotKind(config) !== "personal")
+        return false;
+    let name = "setup";
+    try {
+        const value = JSON.parse(fs.readFileSync(path.join(home, ".hq/executive.json"), "utf8"));
+        if (value?.bot != null) {
+            if (typeof value.bot !== "string" || !value.bot.trim())
+                return false;
+            name = value.bot;
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            return false;
+    }
+    return config.name === name;
+}
+export function executiveStatus(config, dir, home = os.homedir()) {
+    const last = tailBotEvents(dir, (event) => event.event === "meeting.detected").at(-1);
+    return {
+        is_executive: isExecutiveBot(config, home), rider_enabled: executiveRiderEnabled(home),
+        // The first desktop producer did not set source.
+        detect_source_last: last ? (last.payload.source === "poll" ? "poll" : "desktop") : null,
+        last_detected_at: last?.at ?? null,
+    };
+}
+//# sourceMappingURL=executive-settings.js.map

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

@@ -169,6 +169,10 @@ export function migrateLegacyJobsToFleet(dir, config, ops, now = new Date()) {
         const skipped = [];
         const moved = new Set();
         for (const job of legacy) {
+            if (job.trigger || !job.cron) {
+                skipped.push(job.jobId);
+                continue;
+            }
             let schedule;
             try {
                 schedule = /^(cron|rate)\(/i.test(job.cron.trim()) ? fleetScheduleFromLegacy(job.cron) : job.cron.trim();

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

@@ -79,15 +79,15 @@ export function sharedRuntimeLayout(root, id, platform) {
 }
 export const HQ_FLEET_LOCAL_RELEASE = {
     repository: "indigoai-us/hq-fleet-local",
-    tag: "v0.4.22",
-    version: "0.4.22",
-    artifact: "hq-fleet-local-0.4.22.zip",
-    artifactSha256: "b12c01d48c8add7609de557f02987eaa7570223751446915835f52dc9b69d1db",
-    runtimeArtifact: "hq-fleet-runtime-f17ab10aa598.tar",
-    runtimeArtifactSha256: "a2296305a82af7f834804f4240705d791f0c08fa52257955dae3dce091d39ee8",
-    manifestSha256: "f3c62e4e64f91e0aeab32d0999a106c89122144c83757874c81781fb417c0392",
-    signatureSha256: "f07502b61b35431292c9d656f9e602f5230f8fb8ca093993ec92d4353077b4ba",
-    runtimeCommit: "f17ab10aa598d5915f47bf0b83d332a5cc243f98",
+    tag: "v0.4.24",
+    version: "0.4.24",
+    artifact: "hq-fleet-local-0.4.24.zip",
+    artifactSha256: "daa74b7aaf7f26d8c069f33aa94a453369fb2d7ae8c122e7fbe48a5b38e73f31",
+    runtimeArtifact: "hq-fleet-runtime-d257fdd1171f.tar",
+    runtimeArtifactSha256: "8262c5f28773d35c04f7f9ce6f61ed19a88e601847f9d12d5ab11fb5d8e87fb0",
+    manifestSha256: "302d2206957b815a846db583a49e7862948fd8a8a36aaff8e0e8a6e0aa7a1b9c",
+    signatureSha256: "efee90b00c6eb1d0f53a76e93a756435975c9da6c70c9c0b505aafcce79a586a",
+    runtimeCommit: "d257fdd1171f1edd5e381b3bad7baacab0cb00d3",
 };
 /** hq-fleet-local trust/release-public.pem (rotated 2026-10-30; signed v0.4.17). */
 export const HQ_FLEET_LOCAL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
@@ -1717,7 +1717,7 @@ async function installSharedFleetRuntime(installation, root, python, platform, r
 function writeNativeProfileMarker(profileDir, shared, engine) {
     const marker = path.join(profileDir, "bootstrap.json");
     const temporary = `${marker}.${process.pid}.${crypto.randomUUID()}`;
-    fs.writeFileSync(temporary, `${JSON.stringify({ schemaVersion: 2, runtimeId: shared.id, engine }, null, 2)}\n`, { mode: 0o600 });
+    fs.writeFileSync(temporary, `${JSON.stringify({ schemaVersion: 2, runtimeId: shared.id, engine, cliVersion: CLI_VERSION }, null, 2)}\n`, { mode: 0o600 });
     fs.renameSync(temporary, marker);
 }
 function removeEmbeddedRuntime(profileDir, platform = process.platform) {

package/dist/lib/bot/job-run.js

@@ -215,7 +215,7 @@ export function planJobRuns(items, handled) {
     const byJob = new Map();
     for (const item of items) {
         const job = readJobRun(item);
-        if (!job)
+        if (!job || item.messageId.startsWith("localjob-event-"))
             continue;
         const list = byJob.get(job.jobId);
         if (list)

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

@@ -48,6 +48,12 @@ export declare const HOT_SIGNAL_SYNC_JOB_KIND = "hot-signal-sync";
  * own schedule in `jobs.json` is the one that runs.
  */
 export declare const HOT_SIGNAL_SYNC_DEFAULT_CRON = "cron(30 6 * * ? *)";
+interface BuiltinJobsMarker {
+    v: 1;
+    registered: Record<string, string>;
+}
+declare function readMarker(dir: string): BuiltinJobsMarker;
+declare function writeMarker(dir: string, marker: BuiltinJobsMarker): void;
 export declare function hotSignalSyncRegistered(dir: string, company: string): boolean;
 export declare function fleetHotSignalSyncRegistered(dir: string, company: string): boolean;
 export declare function markFleetHotSignalSyncRegistered(dir: string, company: string, now?: Date): void;
@@ -210,4 +216,6 @@ export interface HotSignalSyncRunOutcome {
 /** 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;
+/** Shared registration marker for additive built-in event jobs. */
+export { readMarker as readBuiltinJobsMarker, writeMarker as writeBuiltinJobsMarker };
 //# sourceMappingURL=hot-signal-sync.d.ts.map

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

@@ -430,4 +430,6 @@ export function describeSyncReport(company, report) {
         lines.push(notice);
     return lines.join("\n");
 }
+/** Shared registration marker for additive built-in event jobs. */
+export { readMarker as readBuiltinJobsMarker, writeMarker as writeBuiltinJobsMarker };
 //# sourceMappingURL=hot-signal-sync.js.map

package/dist/lib/bot/jobs/meeting-detect.d.ts

@@ -0,0 +1,28 @@
+import { type LiveMeetingBot } from "../../live-meetings.js";
+import type { BotConfig } from "../config.js";
+export declare function detectIntervalSeconds(hqRoot: string): number;
+/** Desktop events carry company UIDs; local rider files use manifest slugs. */
+export declare function normalizeDetectedCompany(hqRoot: string, payload: unknown): unknown;
+export interface MeetingDetectDeps {
+    hqRoot: string;
+    dir: string;
+    enabled: () => boolean;
+    companies: () => string[];
+    list: (company: string, signal: AbortSignal) => Promise<{
+        companyId: string;
+        bots: LiveMeetingBot[];
+    }>;
+    intervalSeconds?: () => number;
+    now?: () => Date;
+    log: (message: string) => void;
+}
+/** Live reads are keyed by Recall ID; the desktop may emit a saved meeting ID or SDK window ID. */
+export declare function resolveDetectedMeeting(hqRoot: string, payload: unknown, list: MeetingDetectDeps["list"]): Promise<unknown>;
+export declare function createMeetingDetect(deps: MeetingDetectDeps): {
+    /** Called by the inbox loop; network work never holds up inbox delivery. */
+    tick(): void;
+    settled(): Promise<void>;
+    stop(): Promise<void>;
+};
+export declare function defaultMeetingDetectDeps(config: BotConfig, dir: string, log: (message: string) => void): MeetingDetectDeps;
+//# sourceMappingURL=meeting-detect.d.ts.map