@kingcrab/pi-imessage 0.0.42 → 1.0.0

package/dist/agent/prompt.js

@@ -0,0 +1,79 @@
+import { DefaultPackageManager, formatSkillsForPrompt, loadProjectContextFiles, loadSkills, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { defineExtension, section } from "@earendil-works/pi-durable";
+function preamble(workingDir) {
+    return `You are the user's best friend communicating via iMessage. Be concise. No emojis.
+
+## Context
+- Plain text only. Do not use Markdown formatting, double asterisks (**like this**), or [markdown](links).
+- Reply in the same language the user is writing in.
+- Name sources without URLs by default to avoid iMessage link previews. Include original URLs only when the user asks for links.
+- Output ONLY the final message to the user. Never include planning, reasoning, analysis or meta-commentary in the reply.
+
+## Environment
+You are running directly on the host machine.
+- Bash working directory: ${workingDir}
+- Be careful with system modifications.
+
+## Workspace Layout
+${workingDir}/
+├── settings.json                # Bot configuration
+├── extensions/<name>/           # Trusted business tools/tasks: index.ts and config.json
+├── skills/                      # Your reusable CLI tools; skills/file-memory is the memory store
+├── attachments/<chat>/          # Files users shared, referenced by path in messages
+└── durable/                     # All conversations (JSONL); grep here to search old messages
+
+## Messaging
+Your final answer is sent to the chat automatically. Use the send_message tool for files or extra messages.
+Six-hour compaction and workspace extension schedules run as native Durable background tasks. Their deadlines and recent execution records are visible on the read-only Scheduled web page.
+You can create or update a trusted workspace extension in extensions/<name>/index.ts with its config.json, using the host-pinned Durable primitives. An extension can define multiple tasks and optional daily/interval schedules. Use reload_extensions (or the user command /reload) to apply code and configuration changes without interrupting current calls or resetting saved deadlines.
+
+## Long-running work
+- On a resumed or interrupted task, check its transcript and actual results first. An interrupted tool may already have acted: verify it instead of blindly repeating it.
+
+## Skills (custom CLI tools)
+Create reusable tools for on-demand tasks in ${workingDir}/skills/<name>/, each with a SKILL.md:
+---
+name: skill-name
+description: What this skill does
+---
+Usage instructions and details here.`;
+}
+/**
+ * The system prompt: product instructions, AGENTS files and skills, read once per load.
+ * `/reload` builds it again; the same extension name replaces the old one in place.
+ */
+export async function loadPrompt(workingDir, agentDir) {
+    const settings = SettingsManager.create(workingDir, agentDir, { projectTrusted: false });
+    const packages = new DefaultPackageManager({ cwd: workingDir, agentDir, settingsManager: settings });
+    // Discover installed user resources only; never install packages or execute SDK extensions headlessly.
+    const resources = await packages.resolve(async (source) => {
+        console.warn("Prompt resource unavailable; skipping missing package", source);
+        return "skip";
+    });
+    const agents = loadProjectContextFiles({ cwd: workingDir, agentDir });
+    const loadedSkills = loadSkills({
+        cwd: workingDir,
+        agentDir,
+        includeDefaults: false,
+        skillPaths: resources.skills
+            .filter((resource) => resource.enabled && resource.metadata.scope === "user")
+            .map((resource) => resource.path),
+    });
+    for (const diagnostic of loadedSkills.diagnostics)
+        console.warn("Skill resource diagnostic", diagnostic);
+    const skills = formatSkillsForPrompt(loadedSkills.skills, "read").trim();
+    const text = preamble(workingDir);
+    return defineExtension({
+        name: "prompt",
+        sections: [
+            section("preamble", () => text, { tag: false }),
+            section("project_context", () => agents.length === 0
+                ? undefined
+                : [
+                    "Project-specific instructions and guidelines:",
+                    ...agents.map(({ path, content }) => `<project_instructions path="${path}">\n${content}\n</project_instructions>`),
+                ].join("\n\n")),
+            section("skills", (input) => input.agent.tools.some((tool) => tool.name === "read") ? skills || undefined : undefined),
+        ],
+    });
+}

package/dist/agent/replies.js

@@ -0,0 +1,9 @@
+import { defineDoc } from "@earendil-works/pi-durable";
+export const Deliveries = defineDoc({
+    kind: "imessage.deliveries",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: () => ({ answers: {} }),
+});

package/dist/agent/run.js

@@ -0,0 +1,159 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { Type } from "@earendil-works/pi-ai";
+import { AssistantEntry, configure, defineDoc, defineExtension, defineTask, defineTool, GenerationTask, hook, InboxDoc, LiveDoc, section, } from "@earendil-works/pi-durable";
+import { finalReplyText } from "../extensions/final-text.js";
+import { Deliveries } from "./replies.js";
+/** Every `/run`; ended runs stay listed so their last answers can still be delivered. */
+export const Runs = defineDoc({
+    kind: "imessage.runs",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+});
+/** Model-visible notes in the chat conversation about what happened in a run. */
+export const RUN_RECORD = "imessage.run-record";
+export function activeRun(runs, chat) {
+    return runs?.find((run) => run.chat === chat && run.status === "active");
+}
+export function runRecord(text, now) {
+    return { kind: RUN_RECORD, model: [{ role: "user", content: text, timestamp: now }] };
+}
+const instructions = [
+    "This conversation is a /run: the user asked you to keep working on the task without waiting for confirmation.",
+    "Every final answer is sent to the chat as it is written.",
+    "Call end_run when the task is done, when you need the user, or when there is no unfinished task; do not invent a new task.",
+].join("\n");
+async function finish(tx, taskId, stopped, now) {
+    const run = (await tx.doc(Runs)).items.find((item) => item.taskId === taskId);
+    if (!run || run.status === "ended")
+        return;
+    if (stopped) {
+        // Withdraw answers that were not claimed for sending; a claimed send cannot be retracted.
+        const deliveries = await tx.doc(Deliveries, run.conversationId);
+        const entries = await tx.scanEntries({
+            conversationId: run.conversationId,
+            ...(deliveries.scanned === undefined ? {} : { minEntryId: deliveries.scanned }),
+        }, 1000);
+        for (const entry of entries.items) {
+            const key = String(entry.id);
+            if (!AssistantEntry.is(entry) || !finalReplyText(entry.model?.[0]) || deliveries.answers[key])
+                continue;
+            if (deliveries.drafts?.[key] && deliveries.drafts[key].status !== "held")
+                continue;
+            deliveries.drafts ??= {};
+            deliveries.drafts[key] = { status: "cancelled" };
+        }
+        const drafts = deliveries.drafts ?? {};
+        for (const [key, draft] of Object.entries(drafts))
+            if (draft.status === "held")
+                drafts[key] = { status: "cancelled" };
+        run.endReason = "stopped";
+    }
+    run.endReason ??= now >= run.deadline ? "deadline" : "finished";
+    run.status = "ended";
+    // The chat conversation is idle while its run is active: ordinary messages go to the run.
+    await tx.appendEntry(run.chat, runRecord(`[/run ended: ${run.endReason}]`, now));
+}
+/** Owns the run conversation, so aborting it stops the run's work and withdraws its queued messages. */
+export const RunTask = defineTask({
+    name: "imessage.run",
+    version: 1,
+    initial: () => ({ phase: "start" }),
+    phases: {
+        async start(task, runtime, context) {
+            const run = (await runtime.snapshot(Runs, context))?.items.find((item) => item.taskId === task.id);
+            const conversation = run && (await runtime.conversation(run.conversationId, context));
+            if (!conversation)
+                throw new Error("Run conversation is missing");
+            await conversation.submit({ type: "input", content: task.input.task, requestId: `run:${task.id}`, whenBusy: "steer" }, context);
+            await runtime.commit(() => ({ status: "running", checkpoint: { phase: "watch" } }), context);
+        },
+        async watch(task, runtime, context) {
+            const run = (await runtime.snapshot(Runs, context))?.items.find((item) => item.taskId === task.id);
+            const conversation = run && (await runtime.conversation(run.conversationId, context));
+            // onYield keeps the run conversation busy until end_run or the deadline; idle means the run is over.
+            await conversation?.waitForIdle(context);
+            await runtime.commit(async (tx) => {
+                await finish(tx, task.id, false, runtime.now());
+                return { status: "terminal", outcome: { status: "completed", result: null } };
+            }, context);
+        },
+    },
+    async abort(task, runtime, context) {
+        await runtime.commit(async (tx) => {
+            await finish(tx, task.id, true, runtime.now());
+            return { status: "terminal", outcome: { status: "aborted" } };
+        }, context);
+    },
+});
+/** Selected only by run conversations; its task definition resolves everywhere. */
+export const RunExtension = defineExtension({
+    name: "run",
+    tasks: [RunTask],
+    sections: [section("run", () => instructions)],
+    tools: [
+        defineTool({
+            name: "end_run",
+            description: "End this /run when the task is done, you need the user, or nothing is left to do.",
+            parameters: Type.Object({ reason: Type.String() }),
+            replay: "safe",
+            async execute(args, api, context) {
+                await api.commit(async (tx) => {
+                    const run = (await tx.doc(Runs)).items.find((item) => item.conversationId === api.conversationId && item.status === "active");
+                    if (run)
+                        run.endReason = args.reason;
+                }, context);
+                return { content: [{ type: "text", text: "The run ends after this answer." }] };
+            },
+        }),
+    ],
+    hooks: [
+        hook(GenerationTask, {
+            async onYield(_answer, api, context) {
+                const run = (await api.snapshot(Runs, context))?.items.find((item) => item.conversationId === api.conversationId);
+                if (run?.status !== "active" || run.endReason !== undefined)
+                    return;
+                // The deadline only stops continuation; a turn in progress finishes.
+                const minutes = Math.floor((run.deadline - Date.now()) / 60000);
+                if (minutes < 1)
+                    return;
+                return {
+                    continue: `Continue the /run task. ${minutes} minutes left. Call end_run when it is done or you need the user.`,
+                };
+            },
+        }),
+    ],
+});
+/** Starts a run in a fork of the idle chat conversation, or moves the deadline of the active one. */
+export function startRun(chat, chatGuid, deadline, task) {
+    return chat.commit(async (tx) => {
+        const newest = (await tx.scanEntries({ conversationId: chat.id }, 1)).items[0];
+        const runs = await tx.doc(Runs);
+        const active = activeRun(runs.items, chat.id);
+        if (active) {
+            active.deadline = deadline;
+            return { status: "updated", run: { ...active } };
+        }
+        const inbox = await tx.doc(InboxDoc, chat.id);
+        if ((await tx.doc(LiveDoc, chat.id)).run || inbox.items.length > 0)
+            return { status: "busy" };
+        const taskId = await tx.createTask(RunTask, { task }, { ownership: { kind: "conversation" } });
+        const ownership = { ownership: { kind: "task", taskId } };
+        // A fork inherits the chat's context without copying or summarizing it.
+        const conversation = newest
+            ? await tx.forkConversation(chat.id, newest.id, ownership)
+            : await tx.createConversation(ownership);
+        await configure(tx, conversation.id, { extensions: { add: [RunExtension] } });
+        const run = {
+            chatGuid,
+            chat: chat.id,
+            conversationId: conversation.id,
+            taskId,
+            deadline,
+            status: "active",
+        };
+        runs.items.push(run);
+        await tx.appendEntry(chat.id, runRecord(`[/run started: ${task}]`, Date.now()));
+        return { status: "started", run: { ...run } };
+    }, BACKGROUND_CONTEXT);
+}

package/dist/agent/scheduling.js

@@ -0,0 +1,290 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { configure, defineDoc, defineExtension, defineTask, } from "@earendil-works/pi-durable";
+import { ScheduledOutbox, validateSchedules } from "../extensions/schedules.js";
+import { compactChats } from "./compaction.js";
+import { dailyTime, localDate, nextDaily } from "./time.js";
+export { ScheduledOutbox };
+const SIX_HOURS = 6 * 3600000;
+export const EXECUTION_KIND = "imessage.scheduled-execution";
+export const Schedules = defineDoc({
+    kind: "imessage.schedules",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+});
+export const RunRequests = defineDoc({
+    kind: "imessage.schedule-requests",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+});
+function nextAt(schedule, previous, now) {
+    if (schedule.time !== undefined)
+        return nextDaily(schedule.time, now);
+    const interval = schedule.intervalMs ?? SIX_HOURS;
+    return previous + (Math.max(0, Math.floor((now - previous) / interval)) + 1) * interval;
+}
+/** Durable owns cadence and execution receipts; extensions own business tasks and documents. */
+export function schedulingExtension(harness, defaults) {
+    let admissionReady = true;
+    const Execution = defineTask({
+        name: EXECUTION_KIND,
+        version: 2,
+        initial: () => ({ phase: "start" }),
+        phases: {
+            async start(task, runtime, context) {
+                const schedule = (await runtime.snapshot(Schedules, context))?.items.find((item) => item.id === task.input.jobId);
+                if (!schedule)
+                    throw new Error("Scheduled job is missing");
+                if (schedule.id === "compact-chats") {
+                    let admissionFailures = 0;
+                    const tasks = await compactChats(harness, () => admissionFailures++);
+                    await runtime.commit(() => ({ status: "running", checkpoint: { phase: "compact", tasks, admissionFailures } }), context);
+                    return;
+                }
+                const definition = schedule.execution && runtime.registry.task(schedule.execution);
+                if (!definition)
+                    throw new Error(`Missing scheduled task definition: ${schedule.execution}`);
+                await runtime.commit(async (tx) => {
+                    const execution = await tx.createTask(definition, { ...task.input, config: schedule.input ?? null, chatGuid: schedule.chatGuid ?? null }, { ownership: { kind: "task", taskId: task.id } });
+                    return {
+                        status: "waiting",
+                        checkpoint: { phase: "execute", execution },
+                        on: [execution],
+                        policy: "allSettled",
+                    };
+                }, context);
+            },
+            async execute(task, runtime, context) {
+                const receipt = await runtime.waitForTask(task.state.checkpoint.execution, context);
+                await runtime.commit(() => ({ status: "terminal", outcome: receipt.state.outcome }), context);
+            },
+            async compact(task, runtime, context) {
+                const receipts = await Promise.all(task.state.checkpoint.tasks.map((id) => runtime.waitForTask(id, context)));
+                const failed = task.state.checkpoint.admissionFailures +
+                    receipts.filter((receipt) => receipt.state.outcome.status !== "completed").length;
+                await runtime.commit(() => ({
+                    status: "terminal",
+                    outcome: failed
+                        ? { status: "failed", error: { message: `${failed} scheduled compaction(s) failed` } }
+                        : {
+                            status: "completed",
+                            result: {
+                                summary: `${receipts.length} native compaction(s) completed; includes no-ops`,
+                                finishedAt: runtime.now(),
+                            },
+                        },
+                }), context);
+            },
+        },
+        async abort(_task, runtime, context) {
+            await runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), context);
+        },
+    });
+    const Scheduler = defineTask({
+        name: "imessage.schedule",
+        version: 2,
+        migrate(input, checkpoint) {
+            return { input: input, checkpoint: checkpoint };
+        },
+        initial: (input) => ({ phase: "sleep", at: input.firstAt }),
+        phases: {
+            async sleep(task, runtime, context) {
+                const { at } = task.state.checkpoint;
+                await runtime.sleep(at, context);
+                // Due-now work must not start between the configuration commit and registry publication.
+                if (!admissionReady) {
+                    await runtime.sleep(runtime.now() + 100, context);
+                    await runtime.commit(() => ({ status: "running", checkpoint: task.state.checkpoint }), context);
+                    return;
+                }
+                await runtime.commit(async (tx) => {
+                    const schedule = (await tx.doc(Schedules)).items.find((item) => item.id === task.input.jobId);
+                    if (!schedule)
+                        throw new Error("Scheduled job is missing");
+                    if (task.input.requestId &&
+                        !(await tx.doc(RunRequests)).items.find((item) => item.id === task.input.requestId)?.enabled)
+                        return { status: "terminal", outcome: { status: "completed", result: null } };
+                    const now = runtime.now();
+                    const beforeToday = schedule.time !== undefined && now < dailyTime(schedule.time, now);
+                    if (!schedule.enabled)
+                        return task.input.requestId
+                            ? { status: "terminal", outcome: { status: "completed", result: null } }
+                            : { status: "running", checkpoint: { phase: "sleep", at: nextAt(schedule, at, now) } };
+                    if (!task.input.requestId && beforeToday)
+                        return { status: "running", checkpoint: { phase: "sleep", at: nextAt(schedule, at, now) } };
+                    // All triggers of a job share its non-overlap boundary.
+                    for (const status of ["pending", "running", "waiting", "completing"]) {
+                        const existing = (await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND, status }, 1)).items[0];
+                        if (existing)
+                            return {
+                                status: "waiting",
+                                checkpoint: {
+                                    phase: task.input.requestId ? "retry" : "advance",
+                                    at,
+                                    execution: existing.id,
+                                },
+                                on: [existing.id],
+                                policy: "allSettled",
+                            };
+                    }
+                    const execution = await tx.createTask(Execution, {
+                        jobId: schedule.id,
+                        dueAt: at,
+                        startedAt: now,
+                        date: localDate(now),
+                        ...(task.input.requestId ? { requestId: task.input.requestId } : {}),
+                    }, { ownership: { kind: "task", taskId: task.id } });
+                    return {
+                        status: "waiting",
+                        checkpoint: { phase: "advance", at, execution },
+                        on: [execution],
+                        policy: "allSettled",
+                    };
+                }, context);
+            },
+            async retry(task, runtime, context) {
+                await runtime.commit(() => ({ status: "running", checkpoint: { phase: "sleep", at: task.state.checkpoint.at } }), context);
+            },
+            async advance(task, runtime, context) {
+                if (task.input.requestId) {
+                    await runtime.commit(() => ({ status: "terminal", outcome: { status: "completed", result: null } }), context);
+                    return;
+                }
+                await runtime.commit(async (tx) => {
+                    const schedule = (await tx.doc(Schedules)).items.find((item) => item.id === task.input.jobId);
+                    if (!schedule)
+                        throw new Error("Scheduled job is missing");
+                    const execution = await tx.task(task.state.checkpoint.execution);
+                    const outcome = execution?.state.outcome;
+                    const result = outcome?.status === "completed" ? outcome.result : undefined;
+                    const finishedAt = result &&
+                        typeof result === "object" &&
+                        !Array.isArray(result) &&
+                        typeof result.finishedAt === "number"
+                        ? result.finishedAt
+                        : runtime.now();
+                    return {
+                        status: "running",
+                        checkpoint: { phase: "sleep", at: nextAt(schedule, task.state.checkpoint.at, finishedAt) },
+                    };
+                }, context);
+            },
+        },
+        async abort(_task, runtime, context) {
+            await runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), context);
+        },
+    });
+    return {
+        extension: defineExtension({ name: "scheduling", tasks: [Scheduler, Execution] }),
+        /** May join a host reload commit. Existing task IDs and absolute deadlines are never reset. */
+        async initialize(extensions, transaction, publish) {
+            validateSchedules(extensions);
+            const timezone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+            const initialize = async (tx) => {
+                const state = await tx.doc(Schedules);
+                const definitions = [
+                    {
+                        id: "compact-chats",
+                        name: "Chat compaction",
+                        kind: "compaction",
+                        enabled: true,
+                        intervalMs: SIX_HOURS,
+                        timezone,
+                        extension: "scheduling",
+                    },
+                    ...extensions.flatMap((extension) => (extension.schedules ?? []).map(({ task, initialize, ...schedule }) => ({
+                        ...schedule,
+                        kind: schedule.kind ?? "custom",
+                        extension: extension.name,
+                        execution: task,
+                        timezone,
+                        initialize,
+                    }))),
+                ];
+                for (const { initialize: initializeBusiness, ...definition } of definitions) {
+                    const found = state.items.find((item) => item.id === definition.id);
+                    if (found) {
+                        // Clear old cadence when an extension switches between daily and interval scheduling.
+                        delete found.time;
+                        delete found.intervalMs;
+                        delete found.input;
+                        delete found.chatGuid;
+                        Object.assign(found, definition);
+                        await initializeBusiness?.(tx, found.conversationId);
+                        continue;
+                    }
+                    const conversation = await tx.createConversation({ ownership: { kind: "ownerless" } });
+                    await configure(tx, conversation.id, { ...defaults, extensions: [], tools: [] });
+                    await initializeBusiness?.(tx, conversation.id);
+                    const firstAt = definition.time !== undefined
+                        ? nextDaily(definition.time, Date.now())
+                        : Date.now() + (definition.intervalMs ?? SIX_HOURS);
+                    const taskId = await tx.createTask(Scheduler, { jobId: definition.id, firstAt }, { conversationId: conversation.id, ownership: { kind: "conversation" }, background: true });
+                    state.items.push({ ...definition, conversationId: conversation.id, taskId });
+                }
+                const ids = new Set(definitions.map((definition) => definition.id));
+                for (const item of state.items)
+                    if (!ids.has(item.id))
+                        item.enabled = false;
+                const requests = await tx.doc(RunRequests);
+                for (const extension of extensions)
+                    for (const request of extension.runRequests ?? []) {
+                        const existing = requests.items.find((item) => item.id === request.id);
+                        if (existing) {
+                            if (existing.jobId !== request.scheduleId || existing.requestedAt !== request.at)
+                                throw new Error(`Run request ID already used with different configuration: ${request.id}`);
+                            existing.enabled = true;
+                            continue;
+                        }
+                        const schedule = state.items.find((item) => item.id === request.scheduleId);
+                        if (!schedule?.enabled)
+                            throw new Error("Run request target is unavailable");
+                        if (schedule.manualRuns?.[request.id])
+                            throw new Error("Run request ID belongs to a historical operator run");
+                        const at = request.at === "now" ? Date.now() : request.at;
+                        const taskId = await tx.createTask(Scheduler, { jobId: schedule.id, firstAt: at, requestId: request.id }, {
+                            conversationId: schedule.conversationId,
+                            ownership: { kind: "conversation" },
+                            background: true,
+                        });
+                        requests.items.push({
+                            id: request.id,
+                            jobId: schedule.id,
+                            requestedAt: request.at,
+                            at,
+                            taskId,
+                            enabled: true,
+                        });
+                    }
+                const declaredRequests = new Set(extensions.flatMap((extension) => (extension.runRequests ?? []).map((request) => request.id)));
+                for (const request of requests.items)
+                    if (!declaredRequests.has(request.id))
+                        request.enabled = false;
+            };
+            admissionReady = false;
+            try {
+                if (transaction)
+                    await initialize(transaction);
+                else
+                    await harness.commit(initialize, BACKGROUND_CONTEXT);
+                publish?.();
+            }
+            finally {
+                admissionReady = true;
+            }
+        },
+    };
+}
+/** Reuse at-most-once direct-send receipts; never retry unknown external effects. */
+export async function deliverScheduled(harness, send, enabled) {
+    for (const item of (await harness.snapshot(ScheduledOutbox, BACKGROUND_CONTEXT))?.items ?? []) {
+        if (!enabled(item.chatGuid))
+            continue;
+        await send(item);
+        await harness.commit(async (tx) => {
+            const outbox = await tx.doc(ScheduledOutbox);
+            outbox.items = outbox.items.filter((queued) => queued.requestId !== item.requestId);
+        }, BACKGROUND_CONTEXT);
+    }
+}

package/dist/agent/time.js

@@ -0,0 +1,18 @@
+/** Calendar dates follow the service process timezone, including an explicit TZ override. */
+export function localDate(timestamp) {
+    const date = new Date(timestamp);
+    return [date.getFullYear(), date.getMonth() + 1, date.getDate()]
+        .map((value, index) => String(value).padStart(index === 0 ? 4 : 2, "0"))
+        .join("-");
+}
+/** Date applies local daylight-saving rules: shift gaps forward and choose the first repeated time. */
+export function dailyTime(time, timestamp, dayOffset = 0) {
+    const date = new Date(timestamp);
+    const [hours, minutes] = time.split(":").map(Number);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + dayOffset, hours, minutes).getTime();
+}
+/** Advance by a calendar day, which need not be 24 elapsed hours. */
+export function nextDaily(time, after) {
+    const today = dailyTime(time, after);
+    return today > after ? today : dailyTime(time, after, 1);
+}