@mulmoclaude/core 0.12.0 → 0.12.2

package/assets/helps/error-recovery.md

@@ -177,3 +177,93 @@ yourself — additions to `config/helps/error-recovery.md` are managed
 by the project maintainers so the canonical copy in
 `packages/core/assets/helps/error-recovery.md` and the installed copy
 stay in sync.
+
+## Sandbox MCP server dies at load — `Cannot find module '@…/…'`
+
+### Symptoms
+
+- Chatting fails before any tool runs, with:
+  `Error: MCP tool mcp__mulmoclaude__handlePermission (passed via --permission-prompt-tool) not found.`
+- Or, in the server log: `[agent-stderr] Error: Cannot find module '@mulmobridge/protocol'`
+  (or `@mulmoclaude/chart-plugin`, `@gui-chat-plugin/camera`, …) followed by a `Require stack:`
+  listing `/app/server/agent/mcp-server.ts`.
+- Sandbox (Docker) mode only. The broker dies **permanently** — it fails on every manual retry
+  too (contrast the transient scheduler race below, which succeeds on a manual re-run).
+
+### Cause
+
+The MCP child resolves its imports against `/app/node_modules` plus the `/app/pkg_modules`
+fallback on `NODE_PATH`. It dies at load when a package it imports is reachable from neither. Two
+layouts cause that:
+
+1. **Windows source checkout.** `yarn` links workspace packages into `node_modules/` as **NTFS
+   junctions**; their absolute Windows target (`C:\Users\…`) does not exist in the Linux container,
+   so every junction dangles. `server/agent/config.ts` bind-mounts a junction-free copy of each
+   workspace package at `/app/pkg_modules/<name>`; a package missing from that list is invisible.
+2. **npx install with nested `node_modules`.** npm sometimes places a dep in the nested
+   `<packageRoot>/node_modules` (a version conflict, or a half-deduped npx cache from repeated
+   overwrite-updates) instead of hoisting it to `<projectRoot>/node_modules`. Only the latter is
+   mounted to `/app/node_modules`, so the nested dep is invisible.
+
+Either way the child dies before the MCP handshake, so the agent loses **every** MCP tool at once —
+`handlePermission` included, which is why the CLI complains about the permission-prompt tool rather
+than about the missing module.
+
+### Fix
+
+Both layouts are handled automatically: the Windows case mounts every workspace scope, and the npx
+case mounts the nested `<packageRoot>/node_modules` onto `/app/pkg_modules`. If you see this anyway:
+
+```bash
+# Check the SHIPPED mount list, not a hand-mounted copy: does the package the
+# child failed on appear in what workspaceModuleMounts() actually produces?
+node_modules/.bin/tsx test/sandbox-repro/print-mcp-container-spec.ts \
+  | grep pkg_modules/<name>       # <name> e.g. @mulmobridge/protocol
+
+# The workspace dists must exist — production ships built output.
+yarn build:packages:dev
+```
+
+A stale `dist/` looks identical from the outside: the mount is there, but its `exports` target is
+absent. Rebuild before suspecting the mounts.
+
+For an **npx** install specifically, the quickest user-side unblock is to clear the npx cache so
+the next launch installs a clean, fully-hoisted tree:
+
+```bash
+rm -rf ~/.npm/_npx        # then re-run:
+npx mulmoclaude@latest
+```
+
+## Scheduled run fails once with `handlePermission not found`, but works on a manual retry
+
+### Symptoms
+
+- A scheduled skill / user task fails with the SAME
+  `MCP tool mcp__mulmoclaude__handlePermission ... not found` message — but running the identical
+  skill by hand immediately afterwards succeeds.
+- More frequent when several tasks are scheduled for the same minute (e.g. multiple 20:00 UTC
+  jobs). The failed run's transcript is tiny (a few hundred bytes to a few KB) and its recorded
+  duration is only milliseconds.
+
+### Cause
+
+This is a transient STARTUP RACE, not the permanent load failure above. Each scheduled chat spawns
+its own `mulmoclaude` MCP broker; when many chats launch in the same instant the broker boots under
+contention and can connect a moment after the agent's first tool call, so the permission-prompt
+tool is briefly absent. The broker connects seconds later — which is why a manual re-run works.
+
+The scheduler now staggers same-minute firings by a second each to reduce this contention (#2057),
+so it should be rare. It is NOT a module-resolution problem — the mounts / `dist` are fine.
+
+### Fix
+
+Just re-run the task. If it recurs often on a busy schedule, spread the tasks across different
+minutes rather than stacking them on the same one.
+
+### Regression coverage
+
+`.github/workflows/docker_sandbox_windows.yaml` boots the real `mcp-server.ts` inside a Linux
+container from a Windows host (WSL2 + native `dockerd`), with the same mounts / env / argv the
+shipped builders produce, and asserts `handlePermission` comes back over the MCP handshake. See
+`docs/windows-docker-ci.md`.

package/assets/helps/index.md

@@ -69,6 +69,7 @@ See [Wiki](config/helps/wiki.md) for details on how it works.
 - [Sandbox](config/helps/sandbox.md) — how the Docker sandbox isolates the agent, what it can access, and how to disable it
 - [Error recovery](config/helps/error-recovery.md) — the lookup the agent reads on tool failures (gh/git/SSH inside the sandbox, Marp PDF, registry import, build/workspace, plugin runtime) before asking the user
 - [Telegram Bridge](config/helps/telegram.md) — how to talk to MulmoClaude from the Telegram app: creating a bot, starting the bridge, allowlisting chat IDs, commands, and troubleshooting
+- [Remote host](config/helps/remote-host.md) — drive MulmoClaude from a phone at mulmoserver.web.app: Google sign-in connect, host online vs. offline (queued chats, 7-day expiry), photo attachments, and the security model
 - [Feeds](config/helps/feeds.md) — register a self-refreshing data feed (RSS/Atom/JSON) by authoring `feeds/<slug>/schema.json`: schema shape, the `ingest` block, raw-item field mapping, and `maxItems` retention
 - [GitHub repositories in the workspace](config/helps/github.md) — clone-destination rules under `github/<name>/` and how to handle existing directories with matching or different remotes
 - [Collection skills](config/helps/collection-skills.md) — build a data app (model + UI + relations + computed fields + action buttons) by authoring a `schema.json` collection skill: the DSL, field types, derived formulas, actions, records

package/assets/helps/remote-host.md

@@ -0,0 +1,122 @@
+# Remote Host — Your MulmoClaude from Your Phone
+
+The remote host feature lets you use your MulmoClaude from a phone browser at
+**https://mulmoserver.web.app** — browse your collections, open mobile custom
+views, edit records, and start chats with photos taken on the spot — while the
+server keeps running privately on your own computer.
+
+Nothing on your computer is exposed to the internet: no open ports, no public
+URL, no tunnels. Phone and server talk through a **cloud message queue**
+(Google Firestore): the phone drops a request into your private queue, your
+server picks it up, does the work, and drops the answer back. Both directions
+happen in real time.
+
+## Connecting
+
+1. On your computer, click the **phone icon** (`phonelink`) in the MulmoClaude
+   toolbar and press **Connect**. A Google sign-in popup opens — sign in with
+   your Google account. The icon turns green when the host is connected.
+2. On your phone, open **https://mulmoserver.web.app** and sign in with the
+   **same Google account**. The app shows your host as online and lists what it
+   can do.
+
+The two sides find each other purely through the shared Google account — there
+is no pairing code and no IP address to type.
+
+The connection lives only as long as the server process: restarting MulmoClaude
+drops it, and you reconnect with the same one click. **Disconnect** in the same
+popover stops it immediately.
+
+## What You Can Do from the Phone
+
+- **Browse collections** — list your collections and page through their records.
+- **Mobile custom views** — open views authored for the phone
+  (`target: "mobile"` in a collection's `views[]`; see
+  [Remote custom views](config/helps/custom-view-remote.md)). Views can show
+  image thumbnails and, where the view allows it, **update or delete records**.
+- **Start a chat** — send a message (optionally with a role and **photo
+  attachments**) that opens a visible chat session on your computer, as if you
+  had typed it there.
+- **Browse feeds, shortcuts, and skills** — read-only listings of what the
+  workspace offers.
+
+The phone app only shows actions your host actually supports — an older host
+simply advertises a shorter menu, so you never tap a button that can't work.
+
+## When the Host Is Online
+
+Everything above works live. The host announces itself once a minute, so the
+phone reliably shows it as online and results come back within moments.
+
+## When the Host Is Offline
+
+If your computer is asleep or MulmoClaude isn't connected, the phone shows the
+host as **offline**. Browsing (collections, views, feeds) needs a live host and
+is unavailable — but **starting a chat still works**:
+
+- The message (and any attached photos) is **queued** in the cloud. The moment
+  your host reconnects, it drains the queue — oldest first — and starts the
+  chats as if they had just arrived.
+- Queued messages **expire after 7 days**. An expired message is deleted
+  outright, along with its uploaded photos — it will not surprise you by
+  starting a week-old chat.
+- The phone lists your pending messages, and you can delete one before the
+  host picks it up.
+
+This makes the chat queue a fire-and-forget inbox: jot an idea or snap a
+receipt on the go, and it is waiting for your MulmoClaude the next time it
+comes online.
+
+## Photos and Attachments
+
+Photos attached to a chat are uploaded to a private staging area (Firebase
+Storage) under your account, downloaded into your workspace when the host
+handles the message, and then **deleted from the cloud**. Photos belonging to
+an expired queued message are deleted too. As a backstop, anything somehow left
+behind is automatically swept after 14 days.
+
+## How Secure Is It?
+
+**Your server stays private.** It only makes *outbound* connections to Google's
+Firestore — it never listens on a public address, so there is nothing on your
+machine for an attacker to scan or reach.
+
+**Everything is scoped to your Google account.** Both the phone and the host
+sign in as *you*, and the cloud's security rules restrict each signed-in user
+to their own private area — no other user can read your data or send commands
+to your host, and your host cannot touch anyone else's data.
+
+**Sign-in is one-shot and in-memory.** Connect passes a short-lived Google
+sign-in token from your browser to the server over `localhost` only; it is
+used once, never written to a log or to disk. The resulting session lives in
+server memory — restarting the server forgets it, and Disconnect ends it on
+the spot.
+
+**Mobile views are sandboxed.** A custom view rendered on the phone runs in a
+locked-down frame with **all network access disabled** — data reaches it only
+through a controlled message channel, so a view (which may be LLM-authored)
+cannot leak your data to the outside. Record edits made from a view are
+validated and policy-checked by *your host*, not trusted from the phone.
+
+**What passes through the cloud.** Requests, results (record pages, view HTML,
+thumbnails), and staged photo uploads transit — and are temporarily stored in —
+your private area of a Google Firebase project while in flight. Access is
+limited to your account, and the data is deleted as soon as it has been
+delivered — the cloud is a relay, not a copy of your workspace.
+
+**The one thing to protect is your Google account.** Anyone who can sign in to
+it can command your host with the full capability list above (though never
+beyond it — the host only executes its fixed, built-in set of operations).
+Use a strong password and two-factor authentication, and Disconnect the host
+when you don't need remote access.
+
+## Good to Know
+
+- **Host shows offline right after a restart** — reconnecting is manual by
+  design (the sign-in lives in memory). Click the phone icon → Connect.
+- **A queued chat used a role that no longer exists** — the message fails with
+  an error the phone can display, rather than silently starting the wrong chat.
+- **Not the same thing as the MulmoBridge messenger bridges** — Telegram / LINE
+  bridges relay *conversations* through a bot; the remote host is a *control
+  channel* for collections, views, and chat-starting from the dedicated phone
+  app.

package/dist/scheduler/adapter.d.ts

@@ -1,4 +1,4 @@
-import { TaskExecutionState, TaskLogEntry, MISSED_RUN_POLICIES } from '@receptron/task-scheduler';
+import { TaskExecutionState, TaskLogEntry, TaskTrigger, MISSED_RUN_POLICIES } from '@receptron/task-scheduler';
 import { ITaskManager, TaskDefinition, SchedulerLogger } from './task-manager.js';
 export interface SchedulerConfig {
     /** Absolute workspace root — state.json + logs hang off it. */
@@ -44,5 +44,28 @@ export declare function getSchedulerTasks(): {
     missedRunPolicy: string;
     state: TaskExecutionState;
 }[];
+/** Read the persisted execution state for any task id (system, user, or
+ *  skill). Returns an empty state when the id has never run — used by the API
+ *  route to attach last-run / next-run / history state to user + skill tasks
+ *  it lists from other sources. */
+export declare function getSchedulerTaskState(taskId: string): TaskExecutionState;
+/** Record a run of an EXTERNAL (skill / user) task — one registered directly
+ *  on the task-manager rather than through `initScheduler`. Persists a log
+ *  entry + updates state so these tasks get the same history / last-run /
+ *  next-run as system tasks. Because they are fire-and-forget (`startChat`
+ *  spawns an async chat), `errorMessage` reflects whether the *dispatch*
+ *  succeeded, not the chat's eventual outcome; `chatSessionId` links the run
+ *  to the spawned session. */
+export declare function recordExternalRun(params: {
+    id: string;
+    name: string;
+    schedule: TaskDefinition["schedule"];
+    scheduledFor: string;
+    startedAt: string;
+    durationMs: number;
+    trigger: TaskTrigger;
+    errorMessage: string | null;
+    chatSessionId?: string;
+}): Promise<void>;
 /** Test-only: clear config + in-memory state. */
 export declare function resetSchedulerForTesting(): void;

package/dist/scheduler/index.cjs

@@ -9,6 +9,14 @@ let _receptron_task_scheduler = require("@receptron/task-scheduler");
 var ONE_SECOND_MS$1 = 1e3;
 var ONE_MINUTE_MS = 60 * ONE_SECOND_MS$1;
 var ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+var DEFAULT_FIRING_STAGGER_MS = ONE_SECOND_MS$1;
+var MAX_STAGGER_FRACTION_OF_TICK = .5;
+var realSleep = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
+function staggerStepMs(staggerMs, tickMs, count) {
+	if (staggerMs <= 0 || count <= 1) return 0;
+	const maxStepMs = tickMs * MAX_STAGGER_FRACTION_OF_TICK / (count - 1);
+	return Math.min(staggerMs, maxStepMs);
+}
 var NOOP_LOG$1 = {
 	info: () => {},
 	warn: () => {},
@@ -27,65 +35,104 @@ function isDue(now, schedule, tickMs) {
 	}
 	return false;
 }
-function createTaskManager(options) {
-	const tickMs = options?.tickMs ?? ONE_MINUTE_MS;
-	const now = options?.now ?? (() => /* @__PURE__ */ new Date());
-	const log = options?.log ?? NOOP_LOG$1;
-	const registry = /* @__PURE__ */ new Map();
-	let timer = null;
-	function collectDueTasks(currentTime) {
-		const independent = [];
-		const dependent = [];
-		for (const def of registry.values()) {
-			if (def.enabled === false) continue;
-			if (!isDue(currentTime, def.schedule, tickMs)) continue;
-			if (def.dependsOn) dependent.push(def);
-			else independent.push(def);
-		}
-		return {
-			independent,
-			dependent
-		};
+/** Split the due tasks into those that may run immediately and those gated
+*  behind a `dependsOn` edge (resolved later in the same tick cycle). */
+function collectDueTasks(currentTime, registry, tickMs) {
+	const independent = [];
+	const dependent = [];
+	for (const def of registry.values()) {
+		if (def.enabled === false) continue;
+		if (!isDue(currentTime, def.schedule, tickMs)) continue;
+		if (def.dependsOn) dependent.push(def);
+		else independent.push(def);
 	}
-	async function runAndTrack(def, currentTime, succeeded) {
-		try {
-			await def.run({
-				taskId: def.id,
-				now: currentTime
-			});
-			succeeded.add(def.id);
-		} catch (err) {
-			log.error("task failed", {
-				id: def.id,
-				error: String(err)
-			});
-		}
+	return {
+		independent,
+		dependent
+	};
+}
+async function runAndTrack(def, currentTime, succeeded, log) {
+	try {
+		await def.run({
+			taskId: def.id,
+			now: currentTime
+		});
+		succeeded.add(def.id);
+	} catch (err) {
+		log.error("task failed", {
+			id: def.id,
+			error: String(err)
+		});
 	}
-	async function runDependentChain(dependent, currentTime, succeeded) {
-		let remaining = [...dependent];
-		let progress = true;
-		while (remaining.length > 0 && progress) {
-			progress = false;
-			const next = [];
-			for (const def of remaining) {
-				const dep = def.dependsOn;
-				if (!dep || !succeeded.has(dep)) {
-					next.push(def);
-					continue;
-				}
-				await runAndTrack(def, currentTime, succeeded);
-				progress = true;
+}
+async function runDependentChain(dependent, currentTime, succeeded, log) {
+	let remaining = [...dependent];
+	let progress = true;
+	while (remaining.length > 0 && progress) {
+		progress = false;
+		const next = [];
+		for (const def of remaining) {
+			const dep = def.dependsOn;
+			if (!dep || !succeeded.has(dep)) {
+				next.push(def);
+				continue;
 			}
-			remaining = next;
+			await runAndTrack(def, currentTime, succeeded, log);
+			progress = true;
 		}
+		remaining = next;
 	}
-	async function onTick() {
-		const currentTime = now();
-		const { independent, dependent } = collectDueTasks(currentTime);
-		const succeeded = /* @__PURE__ */ new Set();
-		await Promise.all(independent.map((def) => runAndTrack(def, currentTime, succeeded)));
-		await runDependentChain(dependent, currentTime, succeeded);
-	}
+}
+async function runTick(now, registry, cfg) {
+	const currentTime = now();
+	const { independent, dependent } = collectDueTasks(currentTime, registry, cfg.tickMs);
+	const succeeded = /* @__PURE__ */ new Set();
+	const stepMs = staggerStepMs(cfg.staggerMs, cfg.tickMs, independent.length);
+	await Promise.all(independent.map(async (def, index) => {
+		if (stepMs > 0 && index > 0) await cfg.sleep(index * stepMs);
+		await runAndTrack(def, currentTime, succeeded, cfg.log);
+	}));
+	await runDependentChain(dependent, currentTime, succeeded, cfg.log);
+}
+function listTaskSummaries(registry) {
+	return [...registry.values()].map((taskDef) => ({
+		id: taskDef.id,
+		description: taskDef.description,
+		schedule: taskDef.schedule,
+		dependsOn: taskDef.dependsOn
+	}));
+}
+function makeGuardedTick(now, registry, cfg) {
+	let ticking = false;
+	return async () => {
+		if (ticking) return;
+		ticking = true;
+		try {
+			await runTick(now, registry, cfg);
+		} finally {
+			ticking = false;
+		}
+	};
+}
+function resolveTickConfig(options) {
+	const tickMs = options?.tickMs ?? ONE_MINUTE_MS;
+	return {
+		tickMs,
+		now: options?.now ?? (() => /* @__PURE__ */ new Date()),
+		cfg: {
+			tickMs,
+			staggerMs: options?.firingStaggerMs ?? DEFAULT_FIRING_STAGGER_MS,
+			sleep: options?.sleep ?? realSleep,
+			log: options?.log ?? NOOP_LOG$1
+		}
+	};
+}
+function createTaskManager(options) {
+	const { tickMs, now, cfg } = resolveTickConfig(options);
+	const { log } = cfg;
+	const registry = /* @__PURE__ */ new Map();
+	let timer = null;
+	const onTick = makeGuardedTick(now, registry, cfg);
 	return {
 		async tick() {
 			await onTick();
@@ -118,12 +165,7 @@ function createTaskManager(options) {
 			}
 		},
 		listTasks() {
-			return [...registry.values()].map((taskDef) => ({
-				id: taskDef.id,
-				description: taskDef.description,
-				schedule: taskDef.schedule,
-				dependsOn: taskDef.dependsOn
-			}));
+			return listTaskSummaries(registry);
 		}
 	};
 }
@@ -228,7 +270,7 @@ async function applyScheduleOverride(taskId, schedule) {
 	if (!task || !taskManagerRef) return false;
 	if (!taskManagerRef.updateSchedule(taskId, schedule)) return false;
 	task.schedule = schedule;
-	await safeUpdateState(taskId, { nextScheduledAt: computeNextScheduled(task) });
+	await safeUpdateState(taskId, { nextScheduledAt: computeNextScheduledFor(task.schedule) });
 	return true;
 }
 /** Query execution logs — used by API routes. */
@@ -246,6 +288,35 @@ function getSchedulerTasks() {
 		state: stateMap.get(taskDef.id) ?? (0, _receptron_task_scheduler.emptyState)(taskDef.id)
 	}));
 }
+/** Read the persisted execution state for any task id (system, user, or
+*  skill). Returns an empty state when the id has never run — used by the API
+*  route to attach last-run / next-run / history state to user + skill tasks
+*  it lists from other sources. */
+function getSchedulerTaskState(taskId) {
+	return stateMap.get(taskId) ?? (0, _receptron_task_scheduler.emptyState)(taskId);
+}
+/** Record a run of an EXTERNAL (skill / user) task — one registered directly
+*  on the task-manager rather than through `initScheduler`. Persists a log
+*  entry + updates state so these tasks get the same history / last-run /
+*  next-run as system tasks. Because they are fire-and-forget (`startChat`
+*  spawns an async chat), `errorMessage` reflects whether the *dispatch*
+*  succeeded, not the chat's eventual outcome; `chatSessionId` links the run
+*  to the spawned session. */
+async function recordExternalRun(params) {
+	await persistRun({
+		meta: {
+			id: params.id,
+			name: params.name,
+			schedule: params.schedule
+		},
+		scheduledFor: params.scheduledFor,
+		startedAt: params.startedAt,
+		durationMs: params.durationMs,
+		trigger: params.trigger,
+		errMsg: params.errorMessage,
+		chatSessionId: params.chatSessionId
+	});
+}
 /** Test-only: clear config + in-memory state. */
 function resetSchedulerForTesting() {
 	config = null;
@@ -266,44 +337,66 @@ async function executeAndLog(task, scheduledFor, trigger) {
 			error: errMsg
 		});
 	}
-	await safePersist(task, scheduledFor, startedAt, Date.now() - startMs, trigger, errMsg);
+	const durationMs = Date.now() - startMs;
+	await persistRun({
+		meta: {
+			id: task.id,
+			name: task.name,
+			schedule: task.schedule
+		},
+		scheduledFor,
+		startedAt,
+		durationMs,
+		trigger,
+		errMsg
+	});
+}
+/** Best-effort persistence — state and log are independent, so one failing
+*  never blocks the other and neither propagates upward. */
+async function persistRun(run) {
+	await writeRunState(run);
+	await writeRunLog(run);
 }
-/** Best-effort persistence — state and log are independent. A failure in
-*  one does not block the other, and neither propagates upward. */
-async function safePersist(task, scheduledFor, startedAt, durationMs, trigger, errMsg) {
+async function writeRunState(run) {
+	const { meta, scheduledFor, durationMs, errMsg } = run;
 	const isSuccess = errMsg === null;
-	const currentState = stateMap.get(task.id);
+	const currentState = stateMap.get(meta.id);
 	try {
-		await (0, _receptron_task_scheduler.updateAndSave)(stateFilePath(), stateMap, task.id, {
+		await (0, _receptron_task_scheduler.updateAndSave)(stateFilePath(), stateMap, meta.id, {
 			lastRunAt: scheduledFor,
 			lastRunResult: isSuccess ? _receptron_task_scheduler.TASK_RESULTS.success : _receptron_task_scheduler.TASK_RESULTS.error,
 			lastRunDurationMs: durationMs,
 			lastErrorMessage: errMsg,
 			consecutiveFailures: isSuccess ? 0 : (currentState?.consecutiveFailures ?? 0) + 1,
 			totalRuns: (currentState?.totalRuns ?? 0) + 1,
-			nextScheduledAt: computeNextScheduled(task)
+			nextScheduledAt: computeNextScheduledFor(meta.schedule)
 		}, stateDeps());
 	} catch (err) {
 		logger().warn("state persistence failed", {
-			taskId: task.id,
+			taskId: meta.id,
 			error: String(err)
 		});
 	}
+}
+async function writeRunLog(run) {
+	const { meta, scheduledFor, startedAt, durationMs, trigger, errMsg, chatSessionId } = run;
+	const isSuccess = errMsg === null;
 	try {
 		await (0, _receptron_task_scheduler.appendLogEntry)(logsDir(), {
-			taskId: task.id,
-			taskName: task.name,
+			taskId: meta.id,
+			taskName: meta.name,
 			scheduledFor,
 			startedAt,
 			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
 			result: isSuccess ? _receptron_task_scheduler.TASK_RESULTS.success : _receptron_task_scheduler.TASK_RESULTS.error,
 			durationMs,
 			trigger,
-			...errMsg !== null && { errorMessage: errMsg }
+			...errMsg !== null && { errorMessage: errMsg },
+			...chatSessionId !== void 0 && { chatSessionId }
 		}, logDeps);
 	} catch (err) {
 		logger().warn("log persistence failed", {
-			taskId: task.id,
+			taskId: meta.id,
 			error: String(err)
 		});
 	}
@@ -329,8 +422,8 @@ function computeCurrentWindow(task) {
 	const windowMs = (0, _receptron_task_scheduler.nextWindowAfter)(coreSchedule, nowMs - (coreSchedule.type === _receptron_task_scheduler.SCHEDULE_TYPES.interval ? coreSchedule.intervalSec * ONE_SECOND_MS : 0));
 	return windowMs !== null && windowMs <= nowMs ? new Date(windowMs).toISOString() : new Date(nowMs).toISOString();
 }
-function computeNextScheduled(task) {
-	const next = (0, _receptron_task_scheduler.nextWindowAfter)(toCoreSchedule(task.schedule), Date.now() + 1);
+function computeNextScheduledFor(schedule) {
+	const next = (0, _receptron_task_scheduler.nextWindowAfter)(toCoreSchedule(schedule), Date.now() + 1);
 	return next !== null ? new Date(next).toISOString() : null;
 }
 function toCoreSchedule(schedule) {
@@ -341,12 +434,20 @@ function toCoreSchedule(schedule) {
 	return schedule;
 }
 //#endregion
+Object.defineProperty(exports, "TASK_TRIGGERS", {
+	enumerable: true,
+	get: function() {
+		return _receptron_task_scheduler.TASK_TRIGGERS;
+	}
+});
 exports.applyScheduleOverride = applyScheduleOverride;
 exports.configureScheduler = configureScheduler;
 exports.createTaskManager = createTaskManager;
 exports.getSchedulerLogs = getSchedulerLogs;
+exports.getSchedulerTaskState = getSchedulerTaskState;
 exports.getSchedulerTasks = getSchedulerTasks;
 exports.initScheduler = initScheduler;
+exports.recordExternalRun = recordExternalRun;
 exports.resetSchedulerForTesting = resetSchedulerForTesting;
 
 //# sourceMappingURL=index.cjs.map