@alphacoder-v0/pi-loops 0.18.0 → 0.19.2

package/src/pi-loops.ts

@@ -37,6 +37,7 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { computeDue, computeNext, formatLocal, formatSchedule, localOffset, parseSchedule, stamp } from "./schedule.ts";
 import { applyJobEdit } from "./job-edit.ts";
+import { asleepNote, runsIn } from "./job-owner.ts";
 import { AUTONOMY_LEVELS, type AutonomyLevel, INSTALL_ROOT, type Recipe, type UpdateResult, addLineFor, ensureExcluded, installDirFor, installFiles, installedRecipes, isRecipeName, listRecipes, MAX_SETUP_SHOWN, TRACKER_FILE, loadRecipe, packagedRecipesDir, parseAddWords, planInstall, playbookFiles, purgeInstall, readRecord, requireRecipeName, resolveRecipeRef, updateFiles } from "./recipe.ts";
 import { LoopScheduler, type SessionSnapshot } from "./scheduler.ts";
 import { MAX_PROMPT_BYTES, type LoopJob, type RunRecord, defaultLoopsDir, newId, resolveJobRef, sessionExists } from "./store.ts";
@@ -663,7 +664,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		if (n > 0) parts.push(`Inbox: ${n} new`);
 		// Machine-wide like the inbox count and the running list above it: the clock is one per host,
 		// and a loop failing in another checkout is still this machine's automation going quiet.
-		const failing = failingSummary(scheduler.store.load(), os.hostname());
+		const failing = failingSummary(scheduler.store.load());
 		if (failing) parts.push(failing);
 		const running = [...scheduler.runningLabels(), ...triggers.runningList().map((r) => (r.sourceLabel === "local:dynamic" ? "trigger-check" : r.sourceLabel))];
 		if (running.length) parts.push(`running: ${running.join(", ")}`);
@@ -730,13 +731,9 @@ export default function piLoops(pi: ExtensionAPI) {
 
 	function jobLines(jobs: LoopJob[]): string[] {
 		const now = Date.now();
-		const here = os.hostname();
 		return jobs.map((job, i) => {
-			// A job stamped with another machine's hostname is filtered out by the scheduler
-			// (`job.host !== os.hostname()`), so promising a next run would be a lie. This also
-			// catches a renamed machine or a rebuilt container, which needs no second machine at all.
-			const elsewhere = job.host && job.host !== here ? `[other host: ${job.host} — /cron set ${i + 1} --host here]` : undefined;
-			const next = job.enabled && !elsewhere
+			// A next run is shown where it will happen: a plain job of a session not open here has none.
+			const next = job.enabled && runsIn(job, session.sessionId)
 				? computeNext(
 						{
 							schedule: job.schedule,
@@ -746,9 +743,10 @@ export default function piLoops(pi: ExtensionAPI) {
 						now,
 					)
 				: undefined;
-			const dormant = !job.stateful && job.sessionId !== session.sessionId ? `[dormant: session ${(job.sessionId ?? "?").slice(0, 8)} not open here]` : undefined;
+			const asleepMark = asleepNote(job, session.sessionId);
+			const dormant = asleepMark ? `[${asleepMark}]` : undefined;
 			const orphan = job.stateful && !fs.existsSync(job.cwd) ? "[orphan: cwd missing]" : undefined;
-			const marks = [job.stateful ? "[stateful]" : undefined, job.verify ? "[verify]" : undefined, elsewhere, dormant, orphan, job.running ? `running ${job.running.runId}` : undefined, job.catchUp ? undefined : "[no-catchup]"]
+			const marks = [job.stateful ? "[stateful]" : undefined, job.verify ? "[verify]" : undefined, dormant, orphan, job.running ? `running ${job.running.runId}` : undefined, job.catchUp ? undefined : "[no-catchup]"]
 				.filter(Boolean)
 				.join("  ");
 			const head = `${String(i + 1).padStart(2)}. ${job.id}${job.name ? ` "${job.name}"` : ""}  ${job.enabled ? "enabled" : "disabled"}  ${formatSchedule(job.schedule)}${marks ? `  ${marks}` : ""}`;
@@ -798,7 +796,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		"    --verify: maker/checker — a second adversarial sub-agent reviews findings before they enter /inbox (--checker-model <provider/id> to use another model)",
 		"    more flags: --name <n> --cwd <dir> --model <provider/id> --thinking <lvl> --tools a,b --timeout 20m --catchup|--no-catchup (default: loops catch up a missed tick, plain jobs do not)",
 		"/cron enable|disable|remove <n|id|name>      /cron run <n|id|name>   fire now",
-		"/cron set <n|id|name> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-] [--name <n>|-] [--host here|-]   change what a job runs with (- = use the session's current)",
+		"/cron set <n|id|name> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-] [--name <n>|-]   change what a job runs with (- = use the session's current)",
 		'    also [--prompt "<text>"] [--schedule "<expr>"]: reword a loop or move it to another hour in place — the job keeps its id, and a stateful loop keeps its notes',
 		"/cron state <n|id|name>        the loop's notes (state spine)",
 		"/cron runs [n|id|name]         recent runs          /cron trace [n|id|name] [k] [checker]   k-th latest run's transcript (maker, or its checker)",
@@ -1067,7 +1065,6 @@ export default function piLoops(pi: ExtensionAPI) {
 						// it can be tested. Anything it refuses throws before the store is touched.
 						const applied = applyJobEdit(job, change, {
 							now: Date.now(),
-							hostName: os.hostname(),
 							maxPromptBytes: MAX_PROMPT_BYTES,
 							checkName: checkJobName,
 							others: scheduler.store.load().filter((j) => j.id !== job.id),
@@ -1094,7 +1091,6 @@ export default function piLoops(pi: ExtensionAPI) {
 							`  model: ${updated.model ?? "(the running session's current model)"}`,
 							`  thinking: ${updated.thinking ?? "(the running session's current level)"}`,
 							`  timeout: ${updated.timeoutMs ? `${Math.round(updated.timeoutMs / 1000)}s` : "default"}`,
-							`  host: ${updated.host ?? "(any machine)"}`,
 						]);
 						return;
 					}
@@ -1512,8 +1508,8 @@ export default function piLoops(pi: ExtensionAPI) {
 	/* ---------------------------------------------------------- /triggers */
 
 	// The menu names every subcommand; the arguments live in TRIGGERS_HELP below, which `/triggers
-	// help` prints. This line used to *be* that help, so what it left out (`hooks`, `panel`,
-	// `set --host`) was left out of the product.
+	// help` prints. This line used to *be* that help, so what it left out (`hooks`, `panel`)
+	// was left out of the product.
 	const TRIGGERS_USAGE = "[status|rules|sources|hooks|enable|disable|remove|set|run|running|audit|abort|panel|help] — /triggers help for the arguments";
 
 	const TRIGGERS_HELP = [
@@ -1522,7 +1518,7 @@ export default function piLoops(pi: ExtensionAPI) {
 		"/triggers sources              MCP push sources, the local crontab, the dynamic checker — and what each has seen (/triggers hooks is the same view)",
 		"/triggers enable <n|id>        /triggers disable <n|id>            also --all (this project) | --all-projects (the machine)",
 		"/triggers remove <n|id>        also remove --all | remove --all-projects; /new-trigger creates one",
-		"/triggers set <n|id> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-] [--host here|-]   what the action runs with (- = the session's current; --host - = any machine)",
+		"/triggers set <n|id> [--model <p/id>|-] [--thinking <lvl>|-] [--timeout <dur>|-]   what the action runs with (- = the session's current)",
 		"/triggers run <n|id>           check one rule now — dedup, audit, sub-agent and promotion as on a poll",
 		"/triggers running              actions in flight (dynamic checks and cron runs), and the sub-agent slots in use",
 		"/triggers audit [N] [--all]    recent decisions, with each run's transcript path (default 10)",
@@ -1540,9 +1536,7 @@ export default function piLoops(pi: ExtensionAPI) {
 			const fired = r.firedAt ? `, fired_at=${r.firedAt}` : "";
 			const head = numbered ? `${String(i + 1).padStart(2)}. ` : "  - ";
 			const other = r.createdBy?.sessionId && r.createdBy.sessionId !== session.sessionId ? `  (session ${r.createdBy.sessionId.slice(0, 8)})` : "";
-			// Same as jobLines: the runtime skips a rule stamped with another machine's hostname.
-			const elsewhere = r.host && r.host !== os.hostname() ? ` [other host: ${r.host}]` : "";
-			return `${head}${r.id} [${state}, ${fire}, ${out}${fired}]${elsewhere} when ${previewRedacted(r.condition, 80)} -> ${previewRedacted(r.action, 80)}${!sameProject(r.cwd, session.cwd) ? `  (${homeRel(r.cwd)})` : ""}${other}`;
+				return `${head}${r.id} [${state}, ${fire}, ${out}${fired}] when ${previewRedacted(r.condition, 80)} -> ${previewRedacted(r.action, 80)}${!sameProject(r.cwd, session.cwd) ? `  (${homeRel(r.cwd)})` : ""}${other}`;
 		});
 	}
 
@@ -1671,7 +1665,7 @@ export default function piLoops(pi: ExtensionAPI) {
 					case "set": {
 						const change = parseSetArgs(rest);
 						if (change.name !== undefined) {
-							ctx.ui.notify("rules have no name; /triggers set takes --model, --thinking, --timeout and --host", "warning");
+							ctx.ui.notify("rules have no name; /triggers set takes --model, --thinking and --timeout", "warning");
 							return;
 						}
 						const rule = pickRule(change.ref);
@@ -1680,14 +1674,12 @@ export default function piLoops(pi: ExtensionAPI) {
 							if (change.model !== undefined) r.model = change.model ?? undefined;
 							if (change.thinking !== undefined) r.thinking = change.thinking ?? undefined;
 							if (change.timeoutMs !== undefined) r.timeoutMs = change.timeoutMs ?? undefined;
-							if (change.host !== undefined) r.host = change.host === "here" ? os.hostname() : undefined;
 						});
 						if (!updated) return;
 						show(ctx, `updated trigger ${updated.id}`, [
 							`  model: ${updated.model ?? "(the running session's current model)"}`,
 							`  thinking: ${updated.thinking ?? "(the running session's current level)"}`,
 							`  timeout: ${updated.timeoutMs ? `${Math.round(updated.timeoutMs / 1000)}s` : `default (${Math.round(triggers.runTimeoutMs / 1000)}s)`}`,
-							`  host: ${updated.host ?? "(any machine)"}`,
 						]);
 						return;
 					}
@@ -2471,11 +2463,12 @@ export default function piLoops(pi: ExtensionAPI) {
 		pruneLogs(dir);
 		// What was loaded is printed on every start; without a line here a session
 		// can begin with loops and rules the user has entirely forgotten about.
-		const myJobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd) && j.enabled);
+		// "Active here" means it: a plain job of another session is asleep, not active.
+		const myJobs = scheduler.store.load().filter((j) => sameProject(j.cwd, session.cwd) && j.enabled && runsIn(j, session.sessionId));
 		const myRules = triggers.store.load().filter((r) => sameProject(r.cwd, session.cwd) && r.enabled);
 		// What is scheduled says nothing about what is working: a loop that has failed every night
 		// since Tuesday is still counted as active, and this line is the only one a user reads.
-		const failing = failingSummary(myJobs, os.hostname());
+		const failing = failingSummary(myJobs);
 		log.info(`session start: ${myJobs.length} enabled loop(s), ${myRules.length} enabled rule(s)${failing ? `, ${failing}` : ""} in ${session.cwd}`);
 		if (ctx.hasUI && (myJobs.length || myRules.length)) {
 			const next = myJobs
@@ -2542,14 +2535,14 @@ export default function piLoops(pi: ExtensionAPI) {
 	/** Whether this quitting pi should hand the clock to a background host. May throw on a damaged store. */
 	function handOffDecision(here: string, wasStarted: boolean): ReturnType<typeof shouldHandOff> | undefined {
 		if (!wasStarted) return undefined;
-		const enabledRules = triggers.store.load().filter((r) => r.enabled && (!r.host || r.host === here)).length;
+		const enabledRules = triggers.store.load().filter((r) => r.enabled).length;
 		return shouldHandOff({
 			auto: handsOffOnQuit(),
 			presence: scheduler.presenceList(),
 			selfPid: process.pid,
 			selfInstance: scheduler.self.instance,
 			hostName: here,
-			enabledLoops: scheduler.store.load().filter((j) => j.enabled && j.stateful && (!j.host || j.host === here)).length,
+			enabledLoops: scheduler.store.load().filter((j) => j.enabled && j.stateful).length,
 			enabledRules,
 			pushServers: hostPushWork(loadMcpConfigFiles({ dir, projectTrusted: false }).servers, enabledRules),
 			hostAlive: !!liveHost(dir),

package/src/protocol.ts

@@ -35,9 +35,8 @@ export function composeLoopPrompt(action: string, previousState: string | undefi
 	 * The run time, and how to write one.
 	 *
 	 * The notes this prompt asks for hold watermarks — "everything up to here has been seen" — and
-	 * a watermark is a time the model writes in whatever shape it likes. That was survivable while
-	 * a loop belonged to one machine. It does not: a job with no `host` runs on any machine sharing
-	 * the `$HOME` (scheduler.ts, and `/cron set <ref> --host -` asks for exactly that), so run N can
+	 * a watermark is a time the model writes in whatever shape it likes. A machine's clock is not a
+	 * constant either: `TZ` gets set, a laptop travels, a container is rebuilt in UTC — so run N can
 	 * write "checked up to 20:00" in Shanghai and run N+1 read it in New York.
 	 *
 	 * The stamp carries its offset; this asks for the same of anything the model writes back. It

package/src/scheduler.ts

@@ -1,6 +1,6 @@
 /**
  * The heartbeat. One pi process on the machine owns the timer at a time
- * (leadership lives in scheduler.<host>.json with a heartbeat); every other process
+ * (leadership lives in scheduler.json with a heartbeat); every other process
  * with this extension stands by and takes over when the owner exits or dies.
  * Loop jobs are therefore host-agnostic: close the pi that created a loop and
  * any other open pi keeps it ticking; restart pi and missed ticks are caught up
@@ -20,7 +20,8 @@ import { type RunnerResult, type SubagentRunner, failedRun } from "./runner.ts";
 import { previewRedacted, redact } from "./redact.ts";
 import { type SubagentSlot, SubagentSlots } from "./slots.ts";
 import { backoffWaitMs, computeDue, computeNext, formatLocal, formatLocalZoned, formatSchedule, isValidSchedule, stamp } from "./schedule.ts";
-import { type CheckerRecord, JobStore, type LoopJob, type RunRecord, hostFileTag, newId } from "./store.ts";
+import { type CheckerRecord, JobStore, type LoopJob, type RunRecord, newId } from "./store.ts";
+import { ownerSession, runsIn } from "./job-owner.ts";
 
 export const DEFAULT_TICK_MS = 30_000;
 export const LEADER_STALE_MS = 90_000;
@@ -172,12 +173,12 @@ export class LoopScheduler {
 		this.store = new JobStore(opts.dir);
 		this.inbox = new Inbox(opts.dir);
 		// One leader per host: machines sharing a $HOME must not elect each other.
-		this.leaderFile = path.join(opts.dir, `scheduler.${hostFileTag()}.json`);
+		this.leaderFile = path.join(opts.dir, "scheduler.json");
 		// Per host, like the leader record beside it, and for the same reason. Leadership is per
 		// host; two machines sharing a `$HOME` are both leaders, and a cron expression is matched
 		// against local time — so one file would be two machines writing different answers over each
 		// other, and a panel showing whichever wrote last.
-		this.nextRunsFile = path.join(opts.dir, `next-runs.${hostFileTag()}.json`);
+		this.nextRunsFile = path.join(opts.dir, "next-runs.json");
 		this.leaderLock = path.join(opts.dir, "scheduler.lock");
 		this.getSession = opts.getSession;
 		this.hooks = opts.hooks ?? {};
@@ -276,7 +277,9 @@ export class LoopScheduler {
 		if (this.kind === "interactive" && rec.kind === "host") return true;
 		const age = now - Date.parse(rec.heartbeatAt);
 		if (Number.isNaN(age) || age > LEADER_STALE_MS) return true;
-		if (rec.host === os.hostname() && !pidAlive(rec.pid)) return true;
+		// One machine: a pid that is not alive here is not alive. (A record from a renamed or rebuilt
+		// box used to be untouchable until its heartbeat aged out; now it is taken over like any other.)
+		if (!pidAlive(rec.pid)) return true;
 		return false;
 	}
 
@@ -415,11 +418,9 @@ export class LoopScheduler {
 					this.log(`dead-session check failed: ${err?.message ?? err}`);
 				}
 			}
-			const host = os.hostname();
 			for (const job of jobs) {
 				if (!job.enabled) continue;
-				if (job.host && job.host !== host) continue; // another machine's job (shared $HOME)
-				const owned = job.stateful ? leader : !!session.sessionId && job.sessionId === session.sessionId;
+				const owned = job.stateful ? leader : runsIn(job, session.sessionId);
 				if (!owned) continue;
 				// One unusable job must never stop the clock for the others: a schedule that cannot be
 				// evaluated disables that job and says why, instead of throwing out of the tick (pi
@@ -461,7 +462,7 @@ export class LoopScheduler {
 		if (!exists) return;
 		// Open somewhere (--no-session, --session-dir, another sessions root)? Then it is alive whatever the disk says.
 		const live = new Set(this.presence.list(this.now()).map((e) => e.sessionId).filter(Boolean));
-		const dead = jobs.filter((j) => j.enabled && !j.stateful && j.sessionId && (!j.host || j.host === os.hostname()) && !live.has(j.sessionId) && !exists(j.sessionId));
+		const dead = jobs.filter((j) => j.enabled && !j.stateful && j.sessionId && !live.has(j.sessionId) && !exists(j.sessionId));
 		for (const job of dead) {
 			await this.store.update(job.id, (j) => {
 				j.enabled = false;
@@ -481,12 +482,8 @@ export class LoopScheduler {
 	 */
 	private writeNextRuns(jobs: LoopJob[], now: number): void {
 		const next: Record<string, string> = {};
-		const host = os.hostname();
 		for (const job of jobs) {
 			if (!job.enabled || !isValidSchedule(job.schedule)) continue;
-			// The same filter `dispatch` applies: this file is per host, and a next run for a job this
-			// machine never dispatches (shared $HOME) is a promise nothing here keeps.
-			if (job.host && job.host !== host) continue;
 			const at = computeNext({ schedule: job.schedule, createdAt: Date.parse(job.createdAt), lastFiredAt: job.lastFiredAt ? Date.parse(job.lastFiredAt) : undefined }, now);
 			if (at !== undefined) next[job.id] = stamp(at);
 		}
@@ -717,6 +714,9 @@ export class LoopScheduler {
 			// job the dead-session sweep parked is the marker `gc()` matches on, so running it once left
 			// a job nothing could fire and nothing could collect.
 			if (!job.enabled) return "is disabled (/cron enable it first)";
+			// The same reasoning for a job that is enabled but belongs to another session: its prompt is
+			// written for that conversation, and running it here would land it in this one.
+			if (!runsIn(job, this.getSession().sessionId)) return `belongs to session ${ownerSession(job)}, which is not open here — resume it, or /cron add the job again in this chat`;
 			// No `dueIso`: this run was asked for, so whatever slot the schedule owes is still owed.
 			if (!(await this.injectPlainJob(job, undefined, now))) return "has no chat to run in (the background host has no session)";
 			return true;

package/src/session-head.ts

@@ -0,0 +1,98 @@
+/**
+ * What a session listing needs from a session file without reading the whole file: the header,
+ * the name someone gave it, the first thing the person said, and how many messages there are.
+ *
+ * `src/web.mjs` carries its own copy of this (it is one file with no imports, on purpose); a
+ * change here is a change there.
+ */
+import * as fs from "node:fs";
+import type { DynamicTriggerRule } from "./triggers.ts";
+import type { LoopJob } from "./store.ts";
+
+export interface SessionHead {
+	id: string;
+	cwd: string;
+	/** The header's timestamp, as written. */
+	startedAt?: string;
+	/** `/name`, when someone set one. */
+	name?: string;
+	/** The first user message, as typed, bounded. */
+	first?: string;
+	messages: number;
+	/** The file was longer than the window read; `messages` is a floor. */
+	truncated: boolean;
+}
+
+const HEAD_BYTES = 64 * 1024;
+
+export function readSessionHead(file: string, bytes: number = HEAD_BYTES): SessionHead | undefined {
+	let text: string;
+	try {
+		const fd = fs.openSync(file, "r");
+		try {
+			const buf = Buffer.alloc(bytes);
+			text = buf.toString("utf8", 0, fs.readSync(fd, buf, 0, bytes, 0));
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		return undefined;
+	}
+	const lines = text.split("\n");
+	let header: { type?: unknown; id?: unknown; cwd?: unknown; timestamp?: unknown };
+	try {
+		header = JSON.parse(lines[0] ?? "");
+	} catch {
+		return undefined;
+	}
+	if (header?.type !== "session" || typeof header.id !== "string") return undefined;
+	const truncated = text.length >= bytes;
+	let name: string | undefined;
+	let first: string | undefined;
+	let messages = 0;
+	// The last line of a partial read is half a line; a file that fitted has no such line.
+	for (const line of lines.slice(1, truncated ? -1 : undefined)) {
+		if (!line.trim()) continue;
+		let entry: any;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry?.type === "session_info" && typeof entry.name === "string") name = entry.name.slice(0, 200);
+		if (entry?.type !== "message") continue;
+		messages++;
+		if (first || entry.message?.role !== "user") continue;
+		const content = entry.message.content;
+		const said = typeof content === "string" ? content : (content ?? []).map((c: any) => (typeof c?.text === "string" ? c.text : "")).join(" ");
+		if (said.trim()) first = said.trim().slice(0, 200);
+	}
+	return { id: header.id, cwd: typeof header.cwd === "string" ? header.cwd : "", startedAt: typeof header.timestamp === "string" ? header.timestamp : undefined, name, first, messages, truncated };
+}
+
+/**
+ * One line of preview: newlines become spaces, and it is cut at `max` *characters* — not bytes,
+ * so a CJK character or an emoji at the edge is kept whole — with an ellipsis when something was cut.
+ */
+export function previewText(text: string, max = 80): string {
+	const flat = text.replace(/\s*\n\s*/g, " ").trim();
+	const chars = [...flat];
+	return chars.length > max ? `${chars.slice(0, max).join("")}…` : flat;
+}
+
+/**
+ * The automation badge of a session listing: the plain jobs bound to this session (`sessionId`)
+ * and the jobs and rules it created. `2 cron, 1 trigger`; `automation off` when everything
+ * it has is disabled; nothing when it has nothing.
+ */
+export function automationBadge(sessionId: string, jobs: LoopJob[], rules: DynamicTriggerRule[]): string | undefined {
+	const mine = jobs.filter((j) => j.sessionId === sessionId || j.createdBy?.sessionId === sessionId);
+	const rulesMine = rules.filter((r) => r.createdBy?.sessionId === sessionId);
+	if (!mine.length && !rulesMine.length) return undefined;
+	const parts: string[] = [];
+	const cron = mine.filter((j) => j.enabled).length;
+	const trig = rulesMine.filter((r) => r.enabled).length;
+	if (cron) parts.push(`${cron} cron`);
+	if (trig) parts.push(`${trig} trigger`);
+	return parts.length ? parts.join(", ") : "automation off";
+}

package/src/store.ts

@@ -7,7 +7,7 @@
  *   state/<job-id>.md    loop state — the "state spine", human-readable
  *   inbox.jsonl          the triage inbox (see inbox.ts)
  *   runs.jsonl           run log, bounded
- *   scheduler.<host>.json  which process on this machine currently owns the timer
+ *   scheduler.json         which process on this machine currently owns the timer
  *   *.lock               mkdir locks
  */
 import * as fs from "node:fs";
@@ -53,8 +53,6 @@ export interface LoopJob {
 	recipe?: string;
 	createdAt: string;
 	createdBy?: { sessionId?: string; cwd: string };
-	/** Host the job belongs to (shared $HOME across machines): other hosts ignore it. Missing = any host (pre-0.1.3). */
-	host?: string;
 	/** non-stateful jobs only: the session that receives the message. */
 	sessionId?: string;
 	lastDueAt?: string;
@@ -219,22 +217,11 @@ export function newId(prefix: string): string {
 	return `${prefix}-${randomBytes(16).toString("hex")}`;
 }
 
-/**
- * A hostname as one filename component: `scheduler.<tag>.json`, `next-runs.<tag>.json`, one
- * presence file per pi. Two machines sharing a `$HOME` must not write over each other, and a
- * hostname may contain characters a path segment may not.
- *
- * `src/web.mjs` spells the same expression out again because it has no imports, and `src/presence.ts`
- * has its own copy; `test/store.test.ts` pins those spellings to this one.
- */
-export function hostFileTag(host: string = os.hostname()): string {
-	return host.replace(/[^A-Za-z0-9._-]/g, "_");
-}
-
 /**
  * On-disk shape of `jobs.json`, bumped whenever a field becomes load-bearing, so an older pi-loops sharing this directory refuses
- * the file instead of silently rewriting it without that field. Version 2 adds `host` (which gates
- * dispatch), `verify`/`checkerModel`, `timeoutMs` and `consecutiveFailures`.
+ * the file instead of silently rewriting it without that field. Version 2 added `verify`/`checkerModel`,
+ * `timeoutMs` and `consecutiveFailures` (and a `host` that gated dispatch until 0.19.0: pi-loops runs
+ * on one machine, so the field is ignored when read and dropped when written).
  */
 export const JOBS_FILE_VERSION = 2;
 
@@ -317,6 +304,9 @@ export class JobStore {
 			throw new Error(`${this.jobsFile}: version ${parsed.version} was written by a newer pi-loops (this build understands ${JOBS_FILE_VERSION}); upgrade pi-loops`);
 		}
 		if (!Array.isArray(parsed?.jobs)) throw new Error(`${this.jobsFile}: missing "jobs" array`);
+		// Until 0.19.0 a job carried the hostname that created it and other machines ignored it.
+		// pi-loops runs on one machine: the stamp is dropped here and gone on the next write.
+		for (const j of parsed.jobs) delete (j as { host?: unknown }).host;
 		return parsed.jobs;
 	}
 

package/src/tools.ts

@@ -12,6 +12,7 @@ import { previewRedacted } from "./redact.ts";
 import { computeNext, formatLocal, formatSchedule, parseSchedule, stamp } from "./schedule.ts";
 import type { LoopScheduler, SessionSnapshot } from "./scheduler.ts";
 import { MAX_PROMPT_BYTES, type LoopJob, newId, owningSessionId, resolveJobRef } from "./store.ts";
+import { asleepNote, ownerSession, runsIn } from "./job-owner.ts";
 import type { TriggerRuntime } from "./trigger-runtime.ts";
 import { withinProject } from "./presence.ts";
 import { type TriggerStore, looksLikeFixedScheduleRequest, parseTriggerRule, resolveRuleRef, type DynamicTriggerRule } from "./triggers.ts";
@@ -153,7 +154,6 @@ export async function createLoopJob(host: Pick<ToolHost, "scheduler" | "session"
 		createdAt: stamp(),
 		// A sub-agent schedules on behalf of the session that runs it.
 		createdBy: { sessionId: scope?.parentSessionId ?? host.session().sessionId, cwd: scope?.parentCwd ?? host.session().cwd },
-		host: os.hostname(),
 		sessionId: owningSessionId(input.stateful, host.session().sessionId, scope?.parentSessionId),
 		runCount: 0,
 		skippedOverlap: 0,
@@ -172,18 +172,12 @@ function renderTriggerRulesForTool(rules: ReturnType<TriggerStore["load"]>, host
 }
 
 /**
- * Whether this machine will ever dispatch the job. The scheduler filters on `job.host`, so a job
- * stamped with another machine's hostname (a shared $HOME, a renamed box, a rebuilt container) is
- * that host's to run — and a next run promised for it is a time nothing here will honour.
- * docs/loops.md says as much; `/cron` obeyed it and the model-facing list did not.
+ * When the job next runs *here*, or undefined: disabled, or a plain job of a session this process
+ * does not hold. The list is filtered the way dispatch filters — a next run for a job nothing here
+ * will dispatch is a time nothing intends to keep, and a model reads it as a promise.
  */
-function runsHere(job: LoopJob): boolean {
-	return !job.host || job.host === os.hostname();
-}
-
-/** When the job next runs, or undefined when nothing here will run it. */
-function nextRunForTool(job: LoopJob, now: number): number | undefined {
-	if (!job.enabled || !runsHere(job)) return undefined;
+function nextRunForTool(job: LoopJob, now: number, sessionId: string | undefined): number | undefined {
+	if (!job.enabled || !runsIn(job, sessionId)) return undefined;
 	return computeNext({ schedule: job.schedule, createdAt: Date.parse(job.createdAt), lastFiredAt: job.lastFiredAt ? Date.parse(job.lastFiredAt) : undefined }, now);
 }
 
@@ -194,8 +188,9 @@ function renderCronJobsForTool(jobs: LoopJob[], host: Pick<ToolHost, "session">)
 	const lines = [`cron jobs: ${jobs.length}`];
 	for (const job of jobs) {
 		lines.push(`- ${job.id}${job.name ? ` "${job.name}"` : ""} [${job.enabled ? "enabled" : "disabled"}${job.stateful ? ", stateful" : ""}${job.verify ? ", verify" : ""}] schedule: ${formatSchedule(job.schedule)} action: ${previewRedacted(job.prompt, 120)}${job.cwd !== host.session().cwd ? ` cwd: ${job.cwd}` : ""}`);
-		if (!runsHere(job)) lines.push(`  other_host: ${job.host} (this machine does not run it)`);
-		const next = nextRunForTool(job, now);
+		const asleep = asleepNote(job, host.session().sessionId);
+		if (asleep) lines.push(`  ${asleep} (no next run here)`);
+		const next = nextRunForTool(job, now, host.session().sessionId);
 		if (next) lines.push(`  next_run: ${stamp(next)}`);
 		if (job.running) lines.push(`  running_run_id: ${job.running.runId}`);
 		if (job.lastError) lines.push(`  last_error: ${previewRedacted(job.lastError, 120)}`);
@@ -250,7 +245,7 @@ export function automationTools(scope: ToolScope, host: ToolHost): ToolDefinitio
 			const reason = fromSpec ? "create dynamic trigger from `spec` field" : "create dynamic trigger from `condition` + `action` fields";
 			const denied = await host.confirmTool(ctx, { label: "create dynamic trigger", tool: "new_trigger", reason, preview: `when ${previewRedacted(condition, 80)} -> ${previewRedacted(action, 80)}`, args: params }, scope.hop);
 			if (denied) return deny(denied);
-			const rule = await host.triggers.store.add({ condition, action, fireOnce: params.fire_once ?? true, promoteToChat: params.promote_to_chat ?? false, cwd: host.session().cwd, sessionId: host.session().sessionId, model: host.session().model, thinking: host.session().thinking, host: os.hostname() });
+			const rule = await host.triggers.store.add({ condition, action, fireOnce: params.fire_once ?? true, promoteToChat: params.promote_to_chat ?? false, cwd: host.session().cwd, sessionId: host.session().sessionId, model: host.session().model, thinking: host.session().thinking });
 			host.refreshBadge();
 			return {
 				content: [{ type: "text", text: `created dynamic trigger ${rule.id}\ncondition: ${rule.condition}\naction: ${rule.action}\nfire_once: ${rule.fireOnce}\npromote_to_chat: ${rule.promoteToChat}\n(checked every ${host.triggers.pollIntervalSecs}s by a background sub-agent)` }],
@@ -342,7 +337,7 @@ export function automationTools(scope: ToolScope, host: ToolHost): ToolDefinitio
 			verify: Type.Optional(Type.Boolean({ description: "Maker/checker: a second adversarial sub-agent verifies each finding before it enters the inbox (stateful jobs only, default false). Use when the user asks for verified, double-checked, or high-precision findings." })),
 			name: Type.Optional(Type.String({ description: "Short unique label (letters, digits, . _ -)." })),
 			cwd: Type.Optional(Type.String({ description: "Directory a stateful job's sub-agent runs in. Default: current project." })),
-			catch_up: Type.Optional(Type.Boolean({ description: "Run once at startup if a tick was missed while no pi was open (default: true for stateful jobs, false for plain jobs)." })),
+			catch_up: Type.Optional(Type.Boolean({ description: "Run once for a tick that was missed: a loop when a pi next takes the clock, a plain job when the session that created it is next opened (default: true for stateful jobs, false for plain jobs)." })),
 		}),
 		async execute(_id, params) {
 			const schedule = parseSchedule(params.schedule);
@@ -365,7 +360,7 @@ export function automationTools(scope: ToolScope, host: ToolHost): ToolDefinitio
 			// Three lines — what was created, when it runs, what it will do — then where its output goes.
 			return {
 				content: [{ type: "text", text: `created cron job ${job.id}${job.name ? ` "${job.name}"` : ""}\nschedule: ${formatSchedule(job.schedule)}\naction: ${previewRedacted(job.prompt, 120)}\n${job.stateful ? "[stateful] " : ""}next run ${next ? stamp(next) : "—"}. ${where}` }],
-				details: { id: job.id, name: job.name, schedule: formatSchedule(job.schedule), action: job.prompt, enabled: job.enabled, stateful: job.stateful, verify: job.verify ?? false, scope: "machine", next_run: next ? stamp(next) : undefined, audit_entry_id: auditEntryId },
+				details: { id: job.id, name: job.name, schedule: formatSchedule(job.schedule), action: job.prompt, enabled: job.enabled, stateful: job.stateful, verify: job.verify ?? false, scope: job.stateful ? "machine" : "session", owner_session: ownerSession(job), next_run: next ? stamp(next) : undefined, audit_entry_id: auditEntryId },
 			};
 		},
 	});
@@ -383,8 +378,8 @@ export function automationTools(scope: ToolScope, host: ToolHost): ToolDefinitio
 			const jobs = everywhere ? host.scheduler.store.load() : host.scheduler.store.load().filter((j) => sameProject(j.cwd, listCwd));
 			const text = `${renderCronJobsForTool(jobs, host)}\ninbox: ${host.scheduler.inbox.newCount()} new finding(s)`;
 			const nowMs = Date.now();
-			const nextRun = (j: LoopJob) => nextRunForTool(j, nowMs);
-			return { content: [{ type: "text", text }], details: { count: jobs.length, scope: everywhere ? "machine" : listCwd, storage_path: host.scheduler.store.jobsFile, jobs: jobs.map((j) => ({ id: j.id, name: j.name, schedule: formatSchedule(j.schedule), action_preview: previewRedacted(j.prompt, 120), enabled: j.enabled, stateful: j.stateful, verify: j.verify ?? false, cwd: j.cwd, running_run_id: j.running?.runId, last_due_at: j.lastDueAt, last_fired_at: j.lastFiredAt, last_completed_at: j.lastCompletedAt, last_error: j.lastError ? previewRedacted(j.lastError, 120) : undefined, skipped_overlap_count: j.skippedOverlap, next_run: (() => { const n = nextRun(j); return n ? stamp(n) : undefined; })(), created_at: j.createdAt })) } };
+			const nextRun = (j: LoopJob) => nextRunForTool(j, nowMs, host.session().sessionId);
+			return { content: [{ type: "text", text }], details: { count: jobs.length, scope: everywhere ? "machine" : listCwd, storage_path: host.scheduler.store.jobsFile, jobs: jobs.map((j) => ({ id: j.id, name: j.name, schedule: formatSchedule(j.schedule), action_preview: previewRedacted(j.prompt, 120), enabled: j.enabled, stateful: j.stateful, verify: j.verify ?? false, cwd: j.cwd, running_run_id: j.running?.runId, last_due_at: j.lastDueAt, last_fired_at: j.lastFiredAt, last_completed_at: j.lastCompletedAt, last_error: j.lastError ? previewRedacted(j.lastError, 120) : undefined, skipped_overlap_count: j.skippedOverlap, next_run: (() => { const n = nextRun(j); return n ? stamp(n) : undefined; })(), owner_session: ownerSession(j), asleep: !runsIn(j, host.session().sessionId) || undefined, created_at: j.createdAt })) } };
 		},
 	});
 

package/src/trigger-runtime.ts

@@ -316,8 +316,7 @@ export class TriggerRuntime {
 	 * `ownIfUnowned` is passed straight to `ownsRule`: it only adds the rules nobody owns.
 	 */
 	private rulesFor(cwd: string | undefined, ownIfUnowned: boolean): { applicable: DynamicTriggerRule[]; owned: DynamicTriggerRule[] } {
-		const host = this.self?.host ?? os.hostname();
-		const all = this.store.load().filter((r) => r.enabled && (!r.host || r.host === host));
+		const all = this.store.load().filter((r) => r.enabled);
 		const applicable = cwd ? all.filter((r) => withinProject(r.cwd, cwd)) : all;
 		return { applicable, owned: applicable.filter((r) => this.ownsRule(r, ownIfUnowned)) };
 	}
@@ -333,7 +332,7 @@ export class TriggerRuntime {
 		// backlog, not the leader's, so leadership does not gate them.
 		this.retryPending();
 		const host = this.self?.host ?? os.hostname();
-		const rules = this.store.load().filter((r) => r.enabled && (!r.host || r.host === host) && this.ownsRule(r, leader) && !this.inBackoff(r, now));
+		const rules = this.store.load().filter((r) => r.enabled && this.ownsRule(r, leader) && !this.inBackoff(r, now));
 		if (!rules.length) return;
 		const byCwd = new Map<string, DynamicTriggerRule[]>();
 		for (const r of rules) byCwd.set(r.cwd, [...(byCwd.get(r.cwd) ?? []), r]);
@@ -386,8 +385,7 @@ export class TriggerRuntime {
 			if (trigger.source.kind === "mcp" && delivery === "sub_agent" && !trigger.cwd && !this.getSession().cwd) {
 				// No project of our own (the headless host): evaluate the push once per project that has
 				// rules, each in that project, as tick() does — never all rules at once in $HOME.
-				const host = this.self?.host ?? os.hostname();
-				const cwds = [...new Set(this.store.load().filter((r) => r.enabled && (!r.host || r.host === host)).map((r) => r.cwd))];
+				const cwds = [...new Set(this.store.load().filter((r) => r.enabled).map((r) => r.cwd))];
 				if (!cwds.length) return await this.admit(trigger, delivery); // audited as no_rules
 				const outcomes = await Promise.all(cwds.map((cwd, i) => this.admit({ ...trigger, cwd, traceId: i ? newTraceId() : trigger.traceId }, delivery)));
 				return outcomes.find(Boolean);

package/src/triggers.ts

@@ -35,8 +35,6 @@ export interface DynamicTriggerRule {
 	thinking?: string;
 	/** Per-rule cap on the check/action sub-agent; default `[triggers] run_timeout_secs`. */
 	timeoutMs?: number;
-	/** Host the rule belongs to (shared $HOME): other hosts ignore it. Missing = any host (pre-0.1.3). */
-	host?: string;
 	createdBy?: { sessionId?: string };
 	/** Checks that failed in a row (a check covers every rule it evaluated). Cleared by one that completes; drives the poll backoff in the trigger runtime, as `JobStore`'s field of the same name drives the scheduler's. */
 	consecutiveFailures?: number;
@@ -262,6 +260,8 @@ export class TriggerStore {
 		if (!text.trim()) return [];
 		const parsed = JSON.parse(text) as RulesFile;
 		if (!Array.isArray(parsed?.rules)) throw new Error(`${this.rulesFile}: missing "rules" array`);
+		// The pre-0.19.0 host stamp, dropped the way jobs.json drops it.
+		for (const r of parsed.rules) delete (r as { host?: unknown }).host;
 		return parsed.rules;
 	}
 
@@ -274,7 +274,7 @@ export class TriggerStore {
 		});
 	}
 
-	async add(input: { condition: string; action: string; fireOnce?: boolean; promoteToChat?: boolean; cwd: string; sessionId?: string; model?: string; thinking?: string; host?: string }): Promise<DynamicTriggerRule> {
+	async add(input: { condition: string; action: string; fireOnce?: boolean; promoteToChat?: boolean; cwd: string; sessionId?: string; model?: string; thinking?: string }): Promise<DynamicTriggerRule> {
 		const condition = input.condition.trim();
 		const action = input.action.trim();
 		if (!condition || !action) throw new Error("trigger rule needs both a condition and an action");
@@ -289,7 +289,6 @@ export class TriggerStore {
 			cwd: input.cwd,
 			model: input.model,
 			thinking: input.thinking,
-			host: input.host,
 			createdBy: { sessionId: input.sessionId },
 		};
 		await this.mutate((rules) => rules.push(rule));