@indigoai-us/hq-cli 5.185.1 → 5.187.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [5.187.0] — 2026-09-25
+
+### Fixed
+
+- `hq mesh context prd-sync` sends only stories whose Board status changed (a first snapshot of already-done stories is not re-emitted). Quiet `session_end` summaries read Claude Code `result` lines and Codex/Grok `item.completed` agent messages, not only `type=assistant` turns.
+
+## [5.186.0] — 2026-09-25
+
+### Changed
+
+- A local bot's scheduled jobs now live with the bot. `hq bot jobs` stores them in the bot's folder (`jobs.json`) and the running bot fires them itself, through the same path as a cloud-fired job. No cloud setting is involved. A run missed while the computer slept or the bot was stopped runs once as a catch-up; a job never overlaps itself. The 25-job cap per bot is unchanged.
+
 ## [5.185.1] — 2026-09-25
 
 ### Fixed

package/dist/commands/bot-jobs.js

@@ -18,9 +18,9 @@ import chalk from "chalk";
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { BotApi, BotApiError } from "../lib/bot/api.js";
+import { localJobsClient } from "../lib/bot/local-jobs.js";
+import { BotApiError } from "../lib/bot/api.js";
 import { effectiveBotKind } from "../lib/bot/config.js";
-import { identityMismatchMessage, tokenAgentUid } from "../lib/heartbeat-identity.js";
 // ─── Schedule translation ────────────────────────────────────────────────────
 /** Mirrors hq-pro-agents `MIN_RECURRING_INTERVAL_SECONDS`. */
 export const MIN_RECURRING_INTERVAL_SECONDS = 5 * 60;
@@ -365,16 +365,13 @@ export async function runBotJobs(nameArg, opts, deps) {
     const kind = effectiveBotKind(config);
     const out = deps.out ?? ((line) => console.log(line));
     const ctx = { botName: name, kind };
+    // The schedule lives with the bot: this bot runs on this computer, so its
+    // jobs live in its folder and it fires them itself.
     let client;
     const jobsApi = async () => {
         if (client)
             return client;
-        const token = await deps.botTokenSupplier(dir)();
-        const tokenUid = tokenAgentUid(token);
-        if (tokenUid && tokenUid !== config.agentUid) {
-            refuse(identityMismatchMessage("bot jobs", config.agentUid, tokenUid));
-        }
-        client = deps.apiFor ? deps.apiFor(dir) : new BotApi({ token: async () => token });
+        client = deps.apiFor ? deps.apiFor(dir) : localJobsClient(dir);
         return client;
     };
     if (opts.add !== undefined && opts.rm !== undefined) {
@@ -420,9 +417,8 @@ export async function runBotJobs(nameArg, opts, deps) {
         }
         const words = ("human" in schedule && schedule.human) || describeSchedule(created);
         out(chalk.green(`Scheduled ${created.jobId}: ${name} will ${body.prompt.replace(/\s+/g, " ").slice(0, 120)} — ${words}.`));
-        out(chalk.gray("If this computer is asleep or off when a run is due, it is picked up as a catch-up when the computer " +
-            "wakes, as long as it wakes within about an hour. After a longer outage that run is skipped and the " +
-            "job carries on at its next scheduled time."));
+        out(chalk.gray(`It runs on this computer while ${name} is running. If a run is due while the computer is asleep or ` +
+            `${name} is stopped, it runs once, as a catch-up, the next time ${name} is running.`));
         return;
     }
     let jobs;

package/dist/commands/bot.js

@@ -1,3 +1,4 @@
+import { withLocalJobs } from "../lib/bot/local-jobs.js";
 import { OwnerContextCache, lookupOwnerContext } from "../lib/bot/owner-context.js";
 import { hasActivePromotion } from "../lib/bot/promotion-receipt.js";
 import { readInflightTurns } from "../lib/bot/inflight.js";
@@ -866,7 +867,8 @@ async function runBotResident(nameArg) {
     if (healNodePathFromJob(name, dir, config))
         return;
     const token = botTokenSupplier(dir);
-    const api = new BotApi({ token });
+    // The bot's own schedule lives in its folder and fires from this loop.
+    const api = withLocalJobs(new BotApi({ token }), dir);
     const owner = new OwnerContextCache(() => lookupOwnerContext(config.ownerUid), Date.now, undefined, config.ownerUid);
     const handle = await runBot({
         dir,

package/dist/commands/mesh.js

@@ -14,7 +14,7 @@ import chalk from "chalk";
 import { loadCachedTokens, isMachineIdentity } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
 import { STORY_STATUSES, appendThreadEvent, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
-import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, formatStoryStatusChanges, mergeProjectStories, } from "../lib/mesh/project-board.js";
+import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, formatStoryStatusChanges, mergeProjectStories, prdSyncEventsThatChangeBoard, } from "../lib/mesh/project-board.js";
 import { buildPreflightFixtures } from "../lib/work-context/preflight-contract.js";
 import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, } from "../lib/work-context/config.js";
@@ -603,7 +603,25 @@ async function runPrdSync(opts) {
         ...(bound?.projectId ? { project: bound.projectId } : {}),
         touchedPaths: [resolvePath(file)],
     };
+    let toEmit = plan.events;
     if (bound?.companyUid && bound.projectId) {
+        try {
+            const live = await getProjectView(token, bound.companyUid, bound.projectId);
+            toEmit = prdSyncEventsThatChangeBoard(plan.events, live.stories);
+        }
+        catch {
+            // Board unread — emit the snapshot diff; the server drops same-status.
+        }
+        if (toEmit.length === 0) {
+            plan.commit();
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: 0 }));
+            }
+            else {
+                console.log("Work mesh: prd-sync unchanged");
+            }
+            return;
+        }
         try {
             const source = parseProjectPlan(readFileSync(file, "utf8"), file);
             await ensureMissingBoardStories({
@@ -617,7 +635,7 @@ async function runPrdSync(opts) {
                 description: source.description ?? "",
                 stories: source.stories,
                 repos: source.repos ?? [],
-                requiredIds: plan.events.map((event) => event.taskId),
+                requiredIds: toEmit.map((event) => event.taskId),
             });
         }
         catch (err) {
@@ -625,9 +643,12 @@ async function runPrdSync(opts) {
             console.error(`work-mesh: prd-sync ensure failed; emitting anyway (${reason.slice(0, 160)})`);
         }
     }
+    const alreadyOnBoard = plan.events
+        .filter((event) => !toEmit.some((row) => row.taskId === event.taskId))
+        .map((event) => event.taskId);
     const meshRoot = workMeshHomeRoot();
-    const seqFirst = reserveSessionSeq(sessionId, plan.events.length);
-    const events = plan.events.map((event, index) => buildMeshEmitEvent({
+    const seqFirst = reserveSessionSeq(sessionId, toEmit.length);
+    const events = toEmit.map((event, index) => buildMeshEmitEvent({
         eventId: generateUlid(Date.now() + index),
         kind: "task_status",
         sessionId,
@@ -659,7 +680,7 @@ async function runPrdSync(opts) {
             blocked.add(id);
     }
     const advanced = events.flatMap((event) => (event.eventId && event.taskId && !blocked.has(event.eventId) ? [event.taskId] : []));
-    plan.commit(advanced);
+    plan.commit([...alreadyOnBoard, ...advanced]);
     if (plan.taskId && advanced.includes(plan.taskId)) {
         updateSessionState(sessionId, root, (current) => {
             if (!current)
@@ -673,10 +694,10 @@ async function runPrdSync(opts) {
         });
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: plan.events.length, taskId: plan.taskId }));
+        console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: toEmit.length, taskId: plan.taskId }));
         return;
     }
-    console.log(`Work mesh: prd-sync emitted ${plan.events.length} task_status`);
+    console.log(`Work mesh: prd-sync emitted ${toEmit.length} task_status`);
 }
 function noteCallingSessionBound(projectId, company) {
     try {

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

@@ -0,0 +1,109 @@
+/**
+ * Scheduled jobs for a bot that runs on this computer.
+ *
+ * The schedule lives with the bot. A local bot keeps its jobs in `jobs.json`
+ * in its own folder and fires them itself, from the same loop that checks its
+ * inbox. A due job becomes an ordinary `channel: "job"` inbox item, so it runs
+ * through exactly the path a cloud-fired job does (own session, "scheduled
+ * job" header in the owner's DM, catch-up label when late). Only the three
+ * calls that talk to the cloud about a run are answered here instead:
+ * pulling due runs, acking them, and recording how they finished.
+ *
+ * Rules:
+ * - Jobs fire only while the bot is running. After a sleep or an outage, a job
+ *   runs ONCE for its newest missed time, labelled a catch-up; older missed
+ *   times are not replayed.
+ * - A job never overlaps itself. A new fire waits until the previous run of
+ *   the same job has finished (or has been silent for an hour).
+ * - A fire is recorded before it is handed over, so a crash never runs the
+ *   same due time twice.
+ */
+import { type BotApi, type BotJobRecord, type InboxItem, type JobRunCompletion } from "./api.js";
+export declare const LOCAL_JOBS_FILE = "jobs.json";
+export declare const LOCAL_JOB_MESSAGE_PREFIX = "localjob-";
+export interface LocalJob {
+    jobId: string;
+    prompt: string;
+    /** Standard 5-field cron, evaluated in `timezone`. */
+    cron: string;
+    timezone: string;
+    context?: Record<string, unknown>;
+    createdAt: string;
+    /** The newest due time already handed to the bot. */
+    lastFiredAt?: string;
+    /** The run in progress, if any. */
+    inFlight?: {
+        messageId: string;
+        since: string;
+    };
+    lastRunAt?: string;
+    lastStatus?: string;
+    runCount?: number;
+}
+export declare function localJobsPath(dir: string): string;
+export declare function readLocalJobs(dir: string): LocalJob[];
+export declare function writeLocalJobs(dir: string, jobs: LocalJob[]): void;
+/**
+ * Run a read-change-write of `jobs.json` under an exclusive lock. The running
+ * bot (firing, finishing) and `hq bot jobs` (add, remove) are separate
+ * processes; without the lock one can write back a stale copy and silently
+ * undo the other's change.
+ */
+export declare function withJobsLock<T>(dir: string, fn: () => T): T;
+export interface CronMatcher {
+    minutes: Set<number>;
+    hours: Set<number>;
+    days: Set<number>;
+    months: Set<number>;
+    weekdays: Set<number>;
+    dayRestricted: boolean;
+    weekdayRestricted: boolean;
+}
+/**
+ * The job's schedule as a standard 5-field cron. Jobs are stored in the same
+ * form the cloud uses (`cron(m h dom mon dow year)`, Sunday = 1, `?` for the
+ * unused day field), so the same `hq bot jobs` input works for either home.
+ */
+export declare function toStandardCron(expr: string): string | null;
+/** Parse a standard 5-field cron, or null when it is not one. */
+export declare function parseCron(expr: string): CronMatcher | null;
+export declare function cronMatches(cron: CronMatcher, date: Date, timeZone: string): boolean;
+/**
+ * The newest time this job was due, at or before `now` and after the last one
+ * already fired. Null when nothing new is due.
+ */
+/** `rate(5 minutes)` / `rate(1 hour)` / `rate(2 days)` as milliseconds. */
+export declare function rateIntervalMs(expr: string): number | null;
+export declare function isRunnableSchedule(expr: string): boolean;
+export declare function latestDueFire(job: LocalJob, now: Date): Date | null;
+/** The next time this job is due after `now`, within a week; null otherwise. */
+export declare function nextDueFire(job: LocalJob, now: Date): Date | null;
+export declare function toJobRecord(job: LocalJob, now?: Date): BotJobRecord;
+export declare function addLocalJob(dir: string, input: {
+    prompt: string;
+    cron: string;
+    timezone: string;
+    context?: Record<string, unknown>;
+}, now?: Date): LocalJob;
+/** Remove a job. Returns false when the bot has no job with that id. */
+export declare function removeLocalJob(dir: string, jobId: string): boolean;
+/** 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[];
+export declare function isLocalJobMessage(messageId: string): boolean;
+/** Record how a local run finished and release the job for its next fire. */
+export declare function finishLocalJobRun(dir: string, jobId: string, messageId: string, completion: Pick<JobRunCompletion, "status">, now?: Date): void;
+/**
+ * The bot's cloud client, with its scheduled runs answered on this computer:
+ * due local jobs join the inbox, and their ack and completion are recorded
+ * locally instead of being sent to the cloud.
+ */
+export declare function withLocalJobs(api: BotApi, dir: string, clock?: () => Date): BotApi;
+/** The most jobs one bot may hold (the same cap the cloud uses). */
+export declare 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`.
+ */
+export declare function localJobsClient(dir: string, clock?: () => Date): Pick<BotApi, "listJobs" | "createJob" | "cancelJob">;
+//# sourceMappingURL=local-jobs.d.ts.map

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

@@ -0,0 +1,459 @@
+/**
+ * Scheduled jobs for a bot that runs on this computer.
+ *
+ * The schedule lives with the bot. A local bot keeps its jobs in `jobs.json`
+ * in its own folder and fires them itself, from the same loop that checks its
+ * inbox. A due job becomes an ordinary `channel: "job"` inbox item, so it runs
+ * through exactly the path a cloud-fired job does (own session, "scheduled
+ * job" header in the owner's DM, catch-up label when late). Only the three
+ * calls that talk to the cloud about a run are answered here instead:
+ * pulling due runs, acking them, and recording how they finished.
+ *
+ * Rules:
+ * - Jobs fire only while the bot is running. After a sleep or an outage, a job
+ *   runs ONCE for its newest missed time, labelled a catch-up; older missed
+ *   times are not replayed.
+ * - A job never overlaps itself. A new fire waits until the previous run of
+ *   the same job has finished (or has been silent for an hour).
+ * - A fire is recorded before it is handed over, so a crash never runs the
+ *   same due time twice.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { BotApiError } from "./api.js";
+export const LOCAL_JOBS_FILE = "jobs.json";
+export const LOCAL_JOB_MESSAGE_PREFIX = "localjob-";
+/** How far back a missed fire is still looked for (one week). */
+const LOOKBACK_MINUTES = 7 * 24 * 60;
+/** A run that never reported back releases its job after this long. */
+const IN_FLIGHT_RELEASE_MS = 60 * 60 * 1000;
+/** A fire is "late" (a catch-up) once this long past its due time. */
+const STALE_AFTER_MS = 10 * 60 * 1000;
+export function localJobsPath(dir) {
+    return path.join(dir, LOCAL_JOBS_FILE);
+}
+export function readLocalJobs(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(localJobsPath(dir), "utf8"));
+        return Array.isArray(parsed.jobs) ? parsed.jobs.filter((job) => !!job && typeof job.jobId === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeLocalJobs(dir, jobs) {
+    const file = localJobsPath(dir);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ v: 1, jobs }, null, 2));
+    fs.renameSync(tmp, file);
+}
+// ─── Lock ────────────────────────────────────────────────────────────────────
+/** A lock older than this belongs to a process that died holding it. */
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 5_000;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * Run a read-change-write of `jobs.json` under an exclusive lock. The running
+ * bot (firing, finishing) and `hq bot jobs` (add, remove) are separate
+ * processes; without the lock one can write back a stale copy and silently
+ * undo the other's change.
+ */
+export function withJobsLock(dir, fn) {
+    const lock = `${localJobsPath(dir)}.lock`;
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    for (;;) {
+        try {
+            fs.writeFileSync(lock, String(process.pid), { flag: "wx" });
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            try {
+                if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                    fs.rmSync(lock, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`The bot's job list is busy (${lock}). Try again in a moment.`);
+            sleepSync(25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        fs.rmSync(lock, { force: true });
+    }
+}
+// ─── Cron ────────────────────────────────────────────────────────────────────
+const FIELD_RANGES = [
+    [0, 59], // minute
+    [0, 23], // hour
+    [1, 31], // day of month
+    [1, 12], // month
+    [0, 7], // day of week (0 and 7 are Sunday)
+];
+function parseField(field, [min, max]) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (!Number.isInteger(step) || step < 1)
+            return null;
+        let lo;
+        let hi;
+        if (rangePart === "*") {
+            lo = min;
+            hi = max;
+        }
+        else if (/^\d+-\d+$/.test(rangePart ?? "")) {
+            [lo, hi] = rangePart.split("-").map(Number);
+        }
+        else if (/^\d+$/.test(rangePart ?? "")) {
+            lo = Number(rangePart);
+            hi = stepPart === undefined ? lo : max;
+        }
+        else {
+            return null;
+        }
+        if (lo < min || hi > max || lo > hi)
+            return null;
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+const DAY_NAMES = { SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6 };
+const MONTH_NAMES = {
+    JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6, JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12,
+};
+function replaceNames(field, names) {
+    return field.replace(/[A-Za-z]{3}/g, (name) => {
+        const value = names[name.toUpperCase()];
+        return value === undefined ? name : String(value);
+    });
+}
+/**
+ * The job's schedule as a standard 5-field cron. Jobs are stored in the same
+ * form the cloud uses (`cron(m h dom mon dow year)`, Sunday = 1, `?` for the
+ * unused day field), so the same `hq bot jobs` input works for either home.
+ */
+export function toStandardCron(expr) {
+    const trimmed = expr.trim();
+    const wrapped = /^cron\((.*)\)$/.exec(trimmed);
+    if (!wrapped)
+        return trimmed.split(/\s+/).length === 5 ? trimmed : null;
+    const fields = wrapped[1].trim().split(/\s+/);
+    if (fields.length !== 6)
+        return null;
+    const [minute, hour, dom, month, dow] = fields;
+    const standardDow = dow === "?" || dow === "*"
+        ? "*"
+        : replaceNames(dow, { SUN: 1, MON: 2, TUE: 3, WED: 4, THU: 5, FRI: 6, SAT: 7 }).replace(/\d+/g, (n) => String(Number(n) - 1));
+    return [minute, hour, dom === "?" ? "*" : dom, month, standardDow].join(" ");
+}
+/** Parse a standard 5-field cron, or null when it is not one. */
+export function parseCron(expr) {
+    const standard = toStandardCron(expr);
+    if (!standard)
+        return null;
+    const fields = standard.split(/\s+/).map((field, i) => i === 3 ? replaceNames(field, MONTH_NAMES) : i === 4 ? replaceNames(field, DAY_NAMES) : field);
+    if (fields.length !== 5)
+        return null;
+    const sets = fields.map((field, i) => parseField(field, FIELD_RANGES[i]));
+    if (sets.some((set) => set === null))
+        return null;
+    const [minutes, hours, days, months, weekdays] = sets;
+    if (weekdays.has(7))
+        weekdays.add(0);
+    return {
+        minutes: minutes,
+        hours: hours,
+        days: days,
+        months: months,
+        weekdays: weekdays,
+        dayRestricted: fields[2] !== "*",
+        weekdayRestricted: fields[4] !== "*",
+    };
+}
+const WEEKDAY = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+const formatters = new Map();
+function zonedParts(date, timeZone) {
+    let format = formatters.get(timeZone);
+    if (!format) {
+        format = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hour12: false,
+            minute: "numeric",
+            hour: "numeric",
+            day: "numeric",
+            month: "numeric",
+            weekday: "short",
+        });
+        formatters.set(timeZone, format);
+    }
+    const parts = format.formatToParts(date);
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    return {
+        minute: Number(get("minute")),
+        hour: Number(get("hour")) % 24,
+        day: Number(get("day")),
+        month: Number(get("month")),
+        weekday: WEEKDAY[get("weekday")] ?? -1,
+    };
+}
+export function cronMatches(cron, date, timeZone) {
+    const t = zonedParts(date, timeZone);
+    if (!cron.minutes.has(t.minute) || !cron.hours.has(t.hour) || !cron.months.has(t.month))
+        return false;
+    const dayOk = cron.days.has(t.day);
+    const weekdayOk = cron.weekdays.has(t.weekday);
+    // Standard cron: when both day fields are restricted, either may match.
+    if (cron.dayRestricted && cron.weekdayRestricted)
+        return dayOk || weekdayOk;
+    return dayOk && weekdayOk;
+}
+/**
+ * The newest time this job was due, at or before `now` and after the last one
+ * already fired. Null when nothing new is due.
+ */
+/** `rate(5 minutes)` / `rate(1 hour)` / `rate(2 days)` as milliseconds. */
+export function rateIntervalMs(expr) {
+    const match = /^rate\((\d+)\s+(minute|minutes|hour|hours|day|days)\)$/.exec(expr.trim());
+    if (!match)
+        return null;
+    const n = Number(match[1]);
+    const unit = match[2].startsWith("minute") ? 60_000 : match[2].startsWith("hour") ? 3_600_000 : 86_400_000;
+    return n > 0 ? n * unit : null;
+}
+export function isRunnableSchedule(expr) {
+    return rateIntervalMs(expr) !== null || parseCron(expr) !== null;
+}
+export function latestDueFire(job, now) {
+    const interval = rateIntervalMs(job.cron);
+    if (interval) {
+        const origin = Date.parse(job.createdAt);
+        const steps = Math.floor((now.getTime() - origin) / interval);
+        if (steps < 1)
+            return null;
+        const due = origin + steps * interval;
+        return job.lastFiredAt && Date.parse(job.lastFiredAt) >= due ? null : new Date(due);
+    }
+    const cron = parseCron(job.cron);
+    if (!cron)
+        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);
+    for (let t = start.getTime(); t > floor; t -= 60_000) {
+        const at = new Date(t);
+        if (cronMatches(cron, at, job.timezone))
+            return at;
+    }
+    return null;
+}
+/** The next time this job is due after `now`, within a week; null otherwise. */
+export function nextDueFire(job, now) {
+    const interval = rateIntervalMs(job.cron);
+    if (interval) {
+        const origin = Date.parse(job.createdAt);
+        const steps = Math.max(0, Math.floor((now.getTime() - origin) / interval)) + 1;
+        return new Date(origin + steps * interval);
+    }
+    const cron = parseCron(job.cron);
+    if (!cron)
+        return null;
+    const start = new Date(now);
+    start.setUTCSeconds(0, 0);
+    for (let i = 1; i <= LOOKBACK_MINUTES; i += 1) {
+        const at = new Date(start.getTime() + i * 60_000);
+        if (cronMatches(cron, at, job.timezone))
+            return at;
+    }
+    return null;
+}
+// ─── The job list (what `hq bot jobs` reads and writes) ──────────────────────
+export function toJobRecord(job, now = new Date()) {
+    const next = nextDueFire(job, now);
+    return {
+        jobId: job.jobId,
+        prompt: job.prompt,
+        status: "active",
+        schedule: { kind: "recurring", cron: job.cron, timezone: job.timezone },
+        ...(job.context ? { context: job.context } : {}),
+        createdAt: job.createdAt,
+        ...(next ? { nextRunAt: next.toISOString() } : {}),
+        ...(job.lastRunAt ? { lastRunAt: job.lastRunAt } : {}),
+        ...(job.lastStatus ? { lastStatus: job.lastStatus } : {}),
+        ...(job.runCount ? { runCount: job.runCount } : {}),
+    };
+}
+export function addLocalJob(dir, input, now = new Date()) {
+    if (!isRunnableSchedule(input.cron))
+        throw new Error(`"${input.cron}" is not a schedule this bot can run.`);
+    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(),
+    };
+    withJobsLock(dir, () => writeLocalJobs(dir, [...readLocalJobs(dir), job]));
+    return job;
+}
+/** Remove a job. Returns false when the bot has no job with that id. */
+export function removeLocalJob(dir, jobId) {
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        const next = jobs.filter((job) => job.jobId !== jobId);
+        if (next.length === jobs.length)
+            return false;
+        writeLocalJobs(dir, next);
+        return true;
+    });
+}
+// ─── Firing ──────────────────────────────────────────────────────────────────
+/**
+ * Hand over every job that is due now. Each fire is recorded (lastFiredAt and
+ * inFlight) before its inbox item is returned.
+ */
+const lastCheckedMinute = new Map();
+/** Forget the once-per-minute check (tests, and a bot restarted in-process). */
+export function resetLocalJobChecks() {
+    lastCheckedMinute.clear();
+}
+export function takeDueLocalJobRuns(dir, now = new Date()) {
+    // Schedules have minute resolution and the inbox is polled every few
+    // seconds: look at the jobs once per minute.
+    const minute = Math.floor(now.getTime() / 60_000);
+    if (lastCheckedMinute.get(dir) === minute)
+        return [];
+    lastCheckedMinute.set(dir, minute);
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        if (jobs.length === 0)
+            return [];
+        const items = [];
+        let changed = false;
+        const next = jobs.map((job) => {
+            if (job.inFlight && now.getTime() - Date.parse(job.inFlight.since) < IN_FLIGHT_RELEASE_MS)
+                return job;
+            const due = latestDueFire(job, now);
+            if (!due) {
+                if (job.inFlight) {
+                    changed = true;
+                    return { ...job, inFlight: undefined };
+                }
+                return job;
+            }
+            const firedAt = due.toISOString();
+            const messageId = `${LOCAL_JOB_MESSAGE_PREFIX}${job.jobId}-${due.getTime()}`;
+            items.push({
+                messageId,
+                channel: "job",
+                jobId: job.jobId,
+                prompt: job.prompt,
+                ...(job.context ? { context: job.context } : {}),
+                firedAt,
+                staleAfter: new Date(due.getTime() + STALE_AFTER_MS).toISOString(),
+                receivedAt: now.toISOString(),
+            });
+            changed = true;
+            return { ...job, lastFiredAt: firedAt, inFlight: { messageId, since: now.toISOString() } };
+        });
+        if (changed)
+            writeLocalJobs(dir, next);
+        return items;
+    });
+}
+export function isLocalJobMessage(messageId) {
+    return messageId.startsWith(LOCAL_JOB_MESSAGE_PREFIX);
+}
+/** Record how a local run finished and release the job for its next fire. */
+export function finishLocalJobRun(dir, jobId, messageId, completion, now = new Date()) {
+    withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        let changed = false;
+        const next = jobs.map((job) => {
+            if (job.jobId !== jobId)
+                return job;
+            changed = true;
+            const releases = !job.inFlight || job.inFlight.messageId === messageId;
+            return {
+                ...job,
+                ...(releases ? { inFlight: undefined } : {}),
+                lastRunAt: now.toISOString(),
+                lastStatus: completion.status,
+                runCount: (job.runCount ?? 0) + (completion.status === "succeeded" || completion.status === "failed" ? 1 : 0),
+            };
+        });
+        if (changed)
+            writeLocalJobs(dir, next);
+    });
+}
+/**
+ * The bot's cloud client, with its scheduled runs answered on this computer:
+ * due local jobs join the inbox, and their ack and completion are recorded
+ * locally instead of being sent to the cloud.
+ */
+export function withLocalJobs(api, dir, clock = () => new Date()) {
+    const local = Object.create(api);
+    local.pullInbox = async (agentUid) => {
+        // Cloud first: if that call fails, nothing local has been taken yet, so
+        // no due run is recorded as fired and then dropped.
+        const cloud = await api.pullInbox(agentUid);
+        return [...cloud, ...takeDueLocalJobRuns(dir, clock())];
+    };
+    local.ackInbox = async (agentUid, messageId) => {
+        if (isLocalJobMessage(messageId))
+            return;
+        await api.ackInbox(agentUid, messageId);
+    };
+    local.completeJobRun = async (agentUid, jobId, messageId, completion) => {
+        if (isLocalJobMessage(messageId)) {
+            finishLocalJobRun(dir, jobId, messageId, completion, clock());
+            return;
+        }
+        await api.completeJobRun(agentUid, jobId, messageId, completion);
+    };
+    return local;
+}
+/** The most jobs one bot may hold (the same cap the cloud uses). */
+export 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`.
+ */
+export function localJobsClient(dir, clock = () => new Date()) {
+    return {
+        async listJobs() {
+            const now = clock();
+            return readLocalJobs(dir).map((job) => toJobRecord(job, now));
+        },
+        async createJob(_agentUid, input) {
+            if (input.schedule.kind !== "recurring") {
+                throw new BotApiError(400, "local jobs", "JOB_VALIDATION", "A local bot runs recurring jobs only.");
+            }
+            if (readLocalJobs(dir).length >= MAX_LOCAL_JOBS) {
+                throw new BotApiError(409, "local jobs", "JOB_QUOTA_EXCEEDED", `at most ${MAX_LOCAL_JOBS} jobs`);
+            }
+            const job = addLocalJob(dir, { prompt: input.prompt, cron: input.schedule.cron, timezone: input.schedule.timezone, ...(input.context ? { context: input.context } : {}) }, clock());
+            return toJobRecord(job, clock());
+        },
+        async cancelJob(_agentUid, jobId) {
+            if (!removeLocalJob(dir, jobId)) {
+                throw new BotApiError(404, "local jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
+            }
+        },
+    };
+}
+//# sourceMappingURL=local-jobs.js.map

package/dist/lib/mesh/live/report-summary.js

@@ -75,14 +75,27 @@ export function extractLastAssistantText(jsonl) {
         const type = typeof obj.type === "string" ? obj.type : "";
         const role = typeof obj.role === "string" ? obj.role : "";
         const payload = obj.payload;
+        const item = obj.item;
+        const message = obj.message;
         let text = "";
         if (type === "assistant" || role === "assistant") {
             text = textFromUnknown(obj.message ?? obj.content);
         }
+        else if (message && (message.role === "assistant" || message.type === "assistant")) {
+            text = textFromUnknown(message.content ?? message.text ?? message);
+        }
         else if (payload &&
             (payload.type === "agent_message" || payload.type === "assistant")) {
             text = textFromUnknown(payload.message ?? payload.content ?? payload.text);
         }
+        else if (type === "item.completed" &&
+            item &&
+            item.type === "agent_message") {
+            text = textFromUnknown(item.text ?? item.content ?? item.message);
+        }
+        else if (type === "result" && typeof obj.result === "string") {
+            text = obj.result;
+        }
         const trimmed = text.trim();
         if (trimmed)
             last = trimmed;

package/dist/lib/mesh/project-board.d.ts

@@ -4,6 +4,15 @@ export declare function mergeProjectStories(current: MeshProjectStoryInput[], pl
     resetStatus?: boolean;
 }): MeshProjectStoryInput[];
 export declare function boardStoryStatus(story: MeshProjectStoryInput): string;
+/**
+ * Keep only prd-sync task_status events whose Board status actually differs.
+ * Missing Board rows stay (ensure will add them). Same-status replays of
+ * already-done stories must not be sent again (US-051b).
+ */
+export declare function prdSyncEventsThatChangeBoard<T extends {
+    taskId: string;
+    status: string;
+}>(events: readonly T[], boardStories: readonly MeshProjectStoryInput[]): T[];
 /** One-line summary of live→next status diffs for existing story ids. */
 export declare function formatStoryStatusChanges(current: MeshProjectStoryInput[], next: MeshProjectStoryInput[]): string | undefined;
 /**

package/dist/lib/mesh/project-board.js

@@ -34,6 +34,15 @@ export function boardStoryStatus(story) {
         return story.status;
     return story.passes === true ? "done" : "queued";
 }
+/**
+ * Keep only prd-sync task_status events whose Board status actually differs.
+ * Missing Board rows stay (ensure will add them). Same-status replays of
+ * already-done stories must not be sent again (US-051b).
+ */
+export function prdSyncEventsThatChangeBoard(events, boardStories) {
+    const byId = new Map(boardStories.map((story) => [story.id, boardStoryStatus(story)]));
+    return events.filter((event) => byId.get(event.taskId) !== event.status);
+}
 /** One-line summary of live→next status diffs for existing story ids. */
 export function formatStoryStatusChanges(current, next) {
     const currentById = new Map(current.map((story) => [story.id, story]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.185.1",
+  "version": "5.187.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {