@indigoai-us/hq-cli 5.345.198 → 5.345.200

package/dist/lib/bot/jobs/meeting-detect.js

@@ -0,0 +1,176 @@
+/** No-model producer of the same event the desktop emits. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import yaml from "js-yaml";
+import { fetchAttendedLiveBots } from "../../live-meetings.js";
+import { ensureCognitoToken } from "../../../utils/cognito-session.js";
+import { getCompanyUid } from "../../../utils/vault-api.js";
+import { assertSafeSegment } from "../../hot-channels/landing.js";
+import { readManifestCompanies } from "../company-bind.js";
+import { emitBotEvent } from "../events.js";
+import { executiveRiderEnabled, isExecutiveBot } from "../executive-settings.js";
+const RETENTION_MS = 24 * 60 * 60 * 1000;
+const ACTIVE = new Set(["joining", "recording", "in_call"]);
+export function detectIntervalSeconds(hqRoot) {
+    try {
+        const settings = yaml.load(fs.readFileSync(path.join(hqRoot, "core/settings/signals.yaml"), "utf8"));
+        const value = settings?.rider?.detect_interval_seconds;
+        return typeof value === "number" && Number.isFinite(value) ? Math.max(5, value) : 60;
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        return 60;
+    }
+}
+/** Desktop events carry company UIDs; local rider files use manifest slugs. */
+export function normalizeDetectedCompany(hqRoot, payload) {
+    if (!payload || typeof payload !== "object" || !("company" in payload) || typeof payload.company !== "string")
+        return payload;
+    const company = payload.company;
+    if (!company.startsWith("cmp_"))
+        return payload;
+    const manifest = yaml.load(fs.readFileSync(path.join(hqRoot, "companies/manifest.yaml"), "utf8"));
+    const slug = Object.entries(manifest?.companies ?? {}).find(([, value]) => value?.cloud_uid === company)?.[0];
+    return slug ? { ...payload, company: slug } : payload;
+}
+/** Live reads are keyed by Recall ID; the desktop may emit a saved meeting ID or SDK window ID. */
+export async function resolveDetectedMeeting(hqRoot, payload, list) {
+    const normalized = normalizeDetectedCompany(hqRoot, payload);
+    if (!normalized || typeof normalized !== "object")
+        return normalized;
+    const event = normalized;
+    if (event.source === "poll" || typeof event.company !== "string" || typeof event.meeting_url !== "string")
+        return normalized;
+    assertSafeSegment(event.company, "company");
+    const { companyId, bots } = await list(event.company, AbortSignal.timeout(15_000));
+    const row = bots.find((bot) => bot && (bot.companyId === undefined || bot.companyId === companyId) &&
+        typeof bot.status === "string" && ACTIVE.has(bot.status.toLowerCase().replaceAll("-", "_")) &&
+        ([bot.recallBotId, bot.botId, bot.meetingId].includes(String(event.meeting_id)) || bot.meetingUrl === event.meeting_url));
+    const id = row?.recallBotId || row?.botId || row?.meetingId;
+    return id ? { ...event, meeting_id: id } : normalized;
+}
+export function createMeetingDetect(deps) {
+    const now = deps.now ?? (() => new Date());
+    const controller = new AbortController();
+    let next = 0;
+    let disabledLogged = false;
+    let pending;
+    const poll = async () => {
+        // One slow or denied company must not delay detection in another company.
+        await Promise.all([...new Set(deps.companies())].map(async (company) => {
+            if (controller.signal.aborted || !deps.enabled())
+                return;
+            try {
+                assertSafeSegment(company, "company");
+                const root = path.join(deps.hqRoot, "workspace/executive/meetings", company);
+                const file = path.join(root, ".detected.json");
+                let stored = {};
+                try {
+                    stored = JSON.parse(fs.readFileSync(file, "utf8"));
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        throw err;
+                }
+                if (!stored || typeof stored !== "object" || Array.isArray(stored))
+                    throw new Error("Invalid detected ledger");
+                const time = now();
+                const seen = Object.fromEntries(Object.entries(stored).filter((entry) => typeof entry[1] === "string" && Date.parse(entry[1]) > time.getTime() - RETENTION_MS));
+                const { companyId, bots } = await deps.list(company, controller.signal);
+                if (controller.signal.aborted || !deps.enabled())
+                    return;
+                fs.mkdirSync(root, { recursive: true });
+                for (const bot of bots) {
+                    if (!bot || (bot.companyId !== undefined && bot.companyId !== companyId) || typeof bot.status !== "string" || !ACTIVE.has(bot.status.toLowerCase().replaceAll("-", "_")))
+                        continue;
+                    const id = bot.recallBotId || bot.botId || bot.meetingId;
+                    if (typeof id !== "string" || !id)
+                        continue;
+                    assertSafeSegment(id, "meeting id");
+                    if (Object.hasOwn(seen, id))
+                        continue;
+                    // Check aliases too: an older rider may have started with a Recall ID.
+                    const ids = [id, bot.recallBotId, bot.botId, bot.meetingId].filter((value) => typeof value === "string" && value.length > 0);
+                    for (const alias of ids)
+                        assertSafeSegment(alias, "meeting id");
+                    if (ids.some((alias) => [company, companyId].some((co) => {
+                        assertSafeSegment(co, "company");
+                        const base = path.join(deps.hqRoot, "workspace/executive/meetings", co, alias);
+                        return fs.existsSync(`${base}.rider.lock`) || fs.existsSync(`${base}.rider.json`);
+                    }))) {
+                        seen[id] = time.toISOString();
+                        continue;
+                    }
+                    const event = emitBotEvent(deps.dir, "meeting.detected", { meeting_id: id, company, source: "poll" }, time, (prior) => prior.event === "meeting.detected" && [company, companyId].includes(String(prior.payload.company)) && ids.includes(String(prior.payload.meeting_id)));
+                    seen[id] = event.at;
+                }
+                const tmp = `${file}.${randomUUID()}.tmp`;
+                try {
+                    fs.writeFileSync(tmp, JSON.stringify(seen), { mode: 0o600 });
+                    fs.renameSync(tmp, file);
+                }
+                finally {
+                    fs.rmSync(tmp, { force: true });
+                }
+            }
+            catch {
+                if (!controller.signal.aborted)
+                    deps.log(`meeting detection failed for ${company}`);
+            }
+        }));
+    };
+    return {
+        /** Called by the inbox loop; network work never holds up inbox delivery. */
+        tick() {
+            if (controller.signal.aborted || pending)
+                return;
+            if (!deps.enabled()) {
+                if (!disabledLogged) {
+                    deps.log("rider disabled");
+                    disabledLogged = true;
+                }
+                return;
+            }
+            if (now().getTime() < next)
+                return;
+            const seconds = deps.intervalSeconds?.() ?? 60;
+            next = now().getTime() + (Number.isFinite(seconds) ? Math.max(5, seconds) : 60) * 1000;
+            pending = poll().catch(() => deps.log("meeting detection failed")).finally(() => { pending = undefined; });
+        },
+        async settled() { await pending; },
+        async stop() { controller.abort(); await pending; },
+    };
+}
+/** Bound waiting even for shared auth/scope helpers that cannot cancel every internal call. */
+async function untilAborted(signal, work) {
+    signal.throwIfAborted();
+    let abort;
+    const cancelled = new Promise((_resolve, reject) => {
+        abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+        return await Promise.race([work(), cancelled]);
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+    }
+}
+export function defaultMeetingDetectDeps(config, dir, log) {
+    return {
+        hqRoot: config.hqRoot, dir, log,
+        enabled: () => isExecutiveBot(config) && executiveRiderEnabled(),
+        companies: () => config.companySlug ? [config.companySlug] : readManifestCompanies(config.hqRoot),
+        intervalSeconds: () => detectIntervalSeconds(config.hqRoot),
+        list: async (company, signal) => {
+            const bounded = AbortSignal.any([signal, AbortSignal.timeout(15_000)]);
+            const token = await untilAborted(bounded, () => ensureCognitoToken({ interactive: false, signal: bounded }));
+            const companyId = company.startsWith("cmp_") ? company : await untilAborted(bounded, () => getCompanyUid(token, company));
+            const bots = await untilAborted(bounded, () => fetchAttendedLiveBots(token, companyId, true, bounded));
+            return { companyId, bots };
+        },
+    };
+}
+//# sourceMappingURL=meeting-detect.js.map

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

@@ -0,0 +1,53 @@
+import { type BotConfig } from "../config.js";
+export { isExecutiveBot } from "../executive-settings.js";
+import { type LocalJob } from "../local-jobs.js";
+export declare const MEETING_RIDER_JOB_KIND = "meeting-rider";
+export declare const END_POLLS = 3;
+export interface MeetingIdentity {
+    meeting_id: string;
+    company: string;
+}
+export interface RiderRecord {
+    started_at: string;
+    ended_at?: string;
+    passes: number;
+    signals_written: string[];
+    lanes: string[];
+}
+export interface RiderDeps {
+    hqRoot: string;
+    dir: string;
+    bot: string;
+    /** Must check the authenticated owner's attended list in the requested company. */
+    live: (meeting: MeetingIdentity) => Promise<{
+        attended: boolean;
+        status: string;
+    }>;
+    runIncremental: (meeting: MeetingIdentity) => Promise<{
+        signal_ids: string[];
+        lanes?: string[];
+        skipped?: boolean;
+    }>;
+    enabled: () => boolean;
+    intervalSeconds?: () => number;
+    now?: () => Date;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    isAlive?: (pid: number) => boolean;
+    log: (message: string) => void;
+    emit?: (meeting: MeetingIdentity, record: RiderRecord) => void;
+}
+export declare function ensureMeetingRiderJob(dir: string): LocalJob | null;
+export declare function meetingRiderSettings(hqRoot: string, home?: string): {
+    enabled: boolean;
+    interval: number;
+};
+export declare function createMeetingRider(deps: RiderDeps): {
+    /** Synchronously persists intent before the event handler may acknowledge delivery. */
+    start(payload: unknown): void;
+    resume(): void;
+    settled(): Promise<void>;
+    stop(): Promise<void>;
+};
+/** Production dependencies use the same attended endpoint as `meetings live`. */
+export declare function defaultMeetingRiderDeps(config: BotConfig, dir: string, log: (message: string) => void): RiderDeps;
+//# sourceMappingURL=meeting-rider.d.ts.map

package/dist/lib/bot/jobs/meeting-rider.js

@@ -0,0 +1,284 @@
+/** The meeting-specific producer; extraction and event consumers remain source-independent. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import yaml from "js-yaml";
+import { ensureCognitoToken } from "../../../utils/cognito-session.js";
+import { getCompanyUid, vaultApiFetch } from "../../../utils/vault-api.js";
+import { assertSafeSegment } from "../../hot-channels/landing.js";
+import { meetingSignalSourceRef, cursorPath } from "../../signals/incremental.js";
+import { readAllLanes } from "../../lanes/store.js";
+import { runSignals } from "../../signals/engine.js";
+import { emitBotEvent, EVENT_PAYLOAD_BYTES } from "../events.js";
+import { executiveRiderEnabled } from "../executive-settings.js";
+export { isExecutiveBot } from "../executive-settings.js";
+import { readLocalJobsStrict, withJobsLock, writeLocalJobs } from "../local-jobs.js";
+import { readBuiltinJobsMarker, writeBuiltinJobsMarker } from "./hot-signal-sync.js";
+export const MEETING_RIDER_JOB_KIND = "meeting-rider";
+export const END_POLLS = 3;
+const MAX_LOCK_AGE = 6 * 60 * 60 * 1000;
+const TERMINAL = new Set(["completed", "done", "no_transcript", "failed", "fatal", "error", "cancelled", "canceled", "ended", "call_ended", "left", "processing"]);
+const terminal = (status) => TERMINAL.has(status.toLowerCase().replaceAll("-", "_"));
+function atomic(file, value) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code !== "ESRCH";
+    }
+}
+export function ensureMeetingRiderJob(dir) {
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobsStrict(dir);
+        const existing = jobs.find((job) => job.context?.jobKind === MEETING_RIDER_JOB_KIND);
+        const marker = readBuiltinJobsMarker(dir);
+        if (marker.registered[MEETING_RIDER_JOB_KIND])
+            return existing ?? null;
+        const job = existing ?? {
+            jobId: `job_${randomUUID().replaceAll("-", "").slice(0, 20)}`,
+            prompt: "Ride an attended live meeting and extract incremental signals in-process.",
+            trigger: { kind: "event", event: "meeting.detected" }, timezone: "UTC",
+            context: { jobKind: MEETING_RIDER_JOB_KIND }, createdAt: new Date().toISOString(),
+        };
+        if (!existing)
+            writeLocalJobs(dir, [...jobs, job]);
+        marker.registered[MEETING_RIDER_JOB_KIND] = new Date().toISOString();
+        writeBuiltinJobsMarker(dir, marker);
+        return job;
+    });
+}
+export function meetingRiderSettings(hqRoot, home = os.homedir()) {
+    const enabled = executiveRiderEnabled(home);
+    let interval = 20;
+    try {
+        const settings = yaml.load(fs.readFileSync(path.join(hqRoot, "core/settings/signals.yaml"), "utf8"));
+        const value = settings?.rider?.interval_seconds;
+        if (typeof value === "number" && Number.isFinite(value))
+            interval = Math.max(5, value);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    return { enabled, interval };
+}
+/** A crash after append but before removing the lock must not append the end event twice. */
+function emitEndedOnce(dir, meeting, record) {
+    let payload = { ...meeting, source_ref: meetingSignalSourceRef(meeting.meeting_id), signal_ids: record.signals_written };
+    if (Buffer.byteLength(JSON.stringify(payload), "utf8") >= EVENT_PAYLOAD_BYTES) {
+        // The summary is durable before emit. Keep the complete IDs there rather
+        // than silently truncating them or stranding completion on the event cap.
+        payload = { ...payload, signal_ids: [], signal_count: record.signals_written.length,
+            signal_ids_ref: { path: `workspace/executive/meetings/${meeting.company}/${meeting.meeting_id}.rider.json`, field: "signals_written" } };
+    }
+    emitBotEvent(dir, "meeting.ended", payload, new Date(), (event) => event.event === "meeting.ended" && event.payload.company === meeting.company && event.payload.meeting_id === meeting.meeting_id);
+}
+export function createMeetingRider(deps) {
+    const now = deps.now ?? (() => new Date());
+    const running = new Map();
+    const controller = new AbortController();
+    const root = path.join(deps.hqRoot, "workspace/executive/meetings");
+    const emit = deps.emit ?? ((meeting, record) => emitEndedOnce(deps.dir, meeting, record));
+    const paths = (meeting) => {
+        assertSafeSegment(meeting.company, "company");
+        assertSafeSegment(meeting.meeting_id, "meeting id");
+        const base = path.join(root, meeting.company, meeting.meeting_id);
+        return { lock: `${base}.rider.lock`, result: `${base}.rider.json` };
+    };
+    const persist = (state) => atomic(paths(state).lock, state);
+    const finish = (state) => {
+        const { lock, result } = paths(state);
+        const record = { started_at: state.started_at, ended_at: state.ended_at, passes: state.passes, signals_written: state.signals_written, lanes: state.lanes };
+        atomic(result, record);
+        emit({ company: state.company, meeting_id: state.meeting_id }, record);
+        fs.unlinkSync(lock);
+    };
+    const loop = async (state, resumed) => {
+        const file = paths(state).lock;
+        if (state.ended_at) {
+            finish(state);
+            return;
+        }
+        let first = !resumed || state.passes === 0;
+        while (!controller.signal.aborted) {
+            if (!deps.enabled()) {
+                deps.log("rider disabled");
+                fs.unlinkSync(file);
+                return;
+            }
+            const started = now().getTime();
+            const status = await deps.live({ meeting_id: state.meeting_id, company: state.company });
+            if (controller.signal.aborted)
+                return;
+            if (!status.attended) {
+                deps.log(`rider skipped ${state.meeting_id}: owner did not attend`);
+                fs.unlinkSync(file);
+                return;
+            }
+            state.end_polls = terminal(status.status) ? state.end_polls + 1 : 0;
+            // A detection delivered after the meeting ended needs just one final pass.
+            const ended = (first && terminal(status.status)) || state.end_polls >= END_POLLS;
+            first = false;
+            const pass = await deps.runIncremental({ meeting_id: state.meeting_id, company: state.company });
+            if (pass.skipped) {
+                deps.log(`rider ${state.meeting_id} waiting for the signals lock`);
+                // Keep a pending final pass pending even when the first read was terminal.
+                if (ended)
+                    state.end_polls = END_POLLS;
+                persist(state);
+            }
+            else {
+                state.passes++;
+                state.signals_written = [...new Set([...state.signals_written, ...pass.signal_ids])];
+                state.lanes = [...new Set([...state.lanes, ...(pass.lanes ?? [])])];
+                deps.log(`rider ${state.meeting_id} pass ${state.passes}`);
+                // Persist progress even on a stop; the next process resumes this cursor.
+                persist(state);
+                if (controller.signal.aborted)
+                    return;
+                if (ended) {
+                    if (!deps.enabled()) {
+                        deps.log("rider disabled");
+                        fs.unlinkSync(file);
+                        return;
+                    }
+                    state.ended_at = now().toISOString();
+                    persist(state);
+                    finish(state);
+                    return;
+                }
+            }
+            const seconds = deps.intervalSeconds?.() ?? 20;
+            const cadence = Number.isFinite(seconds) ? Math.max(5, seconds) * 1000 : 20_000;
+            await (deps.sleep ?? ((ms, signal) => delay(ms, undefined, { signal })))(Math.max(0, cadence - (now().getTime() - started)), controller.signal);
+        }
+    };
+    const launch = (state, resumed) => {
+        const key = paths(state).lock;
+        const task = loop(state, resumed).catch(() => {
+            if (!controller.signal.aborted)
+                deps.log(`rider ${state.meeting_id} interrupted; retained lock for restart`);
+        }).finally(() => running.delete(key));
+        running.set(key, task);
+    };
+    return {
+        /** Synchronously persists intent before the event handler may acknowledge delivery. */
+        start(payload) {
+            if (!deps.enabled()) {
+                deps.log("rider disabled");
+                return;
+            }
+            if (!payload || typeof payload !== "object")
+                throw new Error("Invalid meeting.detected payload");
+            const { company, meeting_id } = payload;
+            if (typeof company !== "string" || typeof meeting_id !== "string")
+                throw new Error("meeting.detected needs company and meeting_id");
+            const meeting = { company, meeting_id };
+            const { lock, result } = paths(meeting);
+            if (fs.existsSync(result) && !fs.existsSync(lock))
+                return;
+            fs.mkdirSync(path.dirname(lock), { recursive: true });
+            const state = { ...meeting, bot: deps.bot, pid: process.pid, started_at: now().toISOString(), passes: 0, end_polls: 0, signals_written: [], lanes: [] };
+            // Publish a complete intent atomically without replacing an existing lock.
+            const intent = `${lock}.${randomUUID()}.tmp`;
+            fs.writeFileSync(intent, JSON.stringify(state), { mode: 0o600 });
+            try {
+                fs.linkSync(intent, lock);
+            }
+            catch (err) {
+                if (err.code !== "EEXIST")
+                    throw err;
+                deps.log(`rider already running: ${meeting_id}`);
+                return;
+            }
+            finally {
+                fs.unlinkSync(intent);
+            }
+            launch(state, false);
+        },
+        resume() {
+            if (!deps.enabled()) {
+                deps.log("rider disabled");
+                return;
+            }
+            if (!fs.existsSync(root))
+                return;
+            for (const company of fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory())) {
+                for (const name of fs.readdirSync(path.join(root, company.name)).filter((name) => name.endsWith(".rider.lock"))) {
+                    const file = path.join(root, company.name, name);
+                    try {
+                        const state = JSON.parse(fs.readFileSync(file, "utf8"));
+                        if (state.bot !== deps.bot || paths(state).lock !== file || running.has(file))
+                            continue;
+                        if ((deps.isAlive ?? alive)(state.pid))
+                            continue;
+                        if (now().getTime() - fs.statSync(file).mtimeMs >= MAX_LOCK_AGE) {
+                            fs.unlinkSync(file);
+                            continue;
+                        }
+                        state.pid = process.pid;
+                        persist(state);
+                        launch(state, true);
+                    }
+                    catch {
+                        deps.log(`rider lock could not be resumed: ${name}`);
+                    }
+                }
+            }
+        },
+        async settled() { await Promise.all(running.values()); },
+        async stop() { controller.abort(); await Promise.all(running.values()); },
+    };
+}
+/** Production dependencies use the same attended endpoint as `meetings live`. */
+export function defaultMeetingRiderDeps(config, dir, log) {
+    return {
+        hqRoot: config.hqRoot, dir, bot: config.name, log,
+        enabled: () => meetingRiderSettings(config.hqRoot).enabled,
+        intervalSeconds: () => meetingRiderSettings(config.hqRoot).interval,
+        live: async ({ company, meeting_id }) => {
+            const token = await ensureCognitoToken();
+            const companyId = await getCompanyUid(token, company);
+            const response = await vaultApiFetch({ token, path: "/v1/meetings", query: { companyId, view: "live" } });
+            if (!response.ok)
+                throw new Error("Could not check attended meetings");
+            const data = await response.json();
+            if (!Array.isArray(data.bots))
+                throw new Error("Invalid attended meetings response");
+            const row = data.bots.find((bot) => bot && typeof bot === "object" &&
+                (bot.companyId === undefined || bot.companyId === companyId) &&
+                (bot.meetingId === meeting_id || bot.recallBotId === meeting_id || bot.botId === meeting_id));
+            if (row && typeof row.status !== "string")
+                throw new Error("Invalid attended meeting status");
+            return { attended: Boolean(row), status: typeof row?.status === "string" ? row.status : "unknown" };
+        },
+        runIncremental: async ({ company, meeting_id }) => {
+            const source = meetingSignalSourceRef(meeting_id);
+            const result = await runSignals({ hqRoot: config.hqRoot, company, source, incremental: true, trigger: "manual",
+                incrementalOptions: { onSignalWritten: async ({ event, ...payload }) => { emitBotEvent(dir, event, payload); } },
+            });
+            if (result.locked?.some((record) => record.company === company))
+                return { signal_ids: [], skipped: true };
+            if (!result.records.length || result.records.some((record) => record.status !== "complete"))
+                throw new Error("Incremental pass did not complete");
+            const file = path.join(config.hqRoot, cursorPath(company, source));
+            const cursor = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : { signal_ids: [] };
+            // US-003 adds signal metadata to lane records. Reading it is additive:
+            // older lanes have none and are not included in this source's summary.
+            const lanes = readAllLanes(config.hqRoot).filter((lane) => {
+                const signal = lane.signal;
+                return lane.company?.slug === company && signal?.source_ref === source;
+            }).map((lane) => lane.lane_id);
+            return { signal_ids: cursor.signal_ids, lanes };
+        },
+    };
+}
+//# sourceMappingURL=meeting-rider.js.map

package/dist/lib/bot/jobs/signal-to-lane.d.ts

@@ -0,0 +1,32 @@
+import { type BotConfig } from "../config.js";
+import { type LocalJob } from "../local-jobs.js";
+import type { JobRunCompletion } from "../api.js";
+export declare const SIGNAL_TO_LANE_JOB_KIND = "signal-to-lane";
+export declare function signalLaneCompanies(config: BotConfig): string[];
+export declare function ensureSignalToLaneJobs(dir: string, config: BotConfig, companies?: string[], home?: string): LocalJob[];
+/** Only new locally extracted signals reach here; cloud upload/garden is separate. */
+export declare function emitExecutiveSignalWritten(hqRoot: string, company: string, payload: Record<string, string>, root?: string, home?: string): boolean;
+/** Persist intent before publishing a new signal file; ordinary redo creates none. */
+export declare function prepareSignalPublication(hqRoot: string, company: string, payload: Record<string, string>): void;
+/** A pre-append crash retries; a post-append crash uses the event journal's dedupe. */
+export declare function flushSignalPublications(hqRoot: string, company: string, emit?: typeof emitExecutiveSignalWritten): void;
+type Create = (input: {
+    hqRoot: string;
+    company: string;
+    signal_id: string;
+}) => Promise<{
+    lane_id: string;
+    existing: boolean;
+}>;
+export declare function runSignalToLane(input: {
+    dir: string;
+    config: BotConfig;
+    payload: unknown;
+    company: unknown;
+    log: (message: string) => void;
+    create?: Create;
+    companies?: string[];
+    home?: string;
+}): Promise<JobRunCompletion>;
+export {};
+//# sourceMappingURL=signal-to-lane.d.ts.map