@alphacoder-v0/pi-loops 0.17.6 → 0.19.2

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";
@@ -49,10 +49,10 @@ export interface LoopJob {
 	/** Fire once on startup if a tick was missed while no pi was running (default true). */
 	catchUp: boolean;
 	timeoutMs?: number;
+	/** The recipe that created this job (`/recipe add`), so `/recipe list|remove` can find it. */
+	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;
@@ -217,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;
 
@@ -315,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";
@@ -54,6 +55,8 @@ export interface CreateJobInput {
 	catchUp?: boolean;
 	verify?: boolean;
 	checkerModel?: string;
+	/** Set by `/recipe add`: which recipe this job belongs to. */
+	recipe?: string;
 }
 
 export interface JobScope {
@@ -147,10 +150,10 @@ export async function createLoopJob(host: Pick<ToolHost, "scheduler" | "session"
 		checkerModel: input.stateful && input.verify ? input.checkerModel : undefined,
 		catchUp: input.catchUp ?? input.stateful,
 		timeoutMs: input.timeoutMs,
+		recipe: input.recipe,
 		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,
@@ -169,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);
 }
 
@@ -191,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)}`);
@@ -247,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)` }],
@@ -339,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);
@@ -362,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 },
 			};
 		},
 	});
@@ -380,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));

package/src/web.mjs

@@ -452,8 +452,7 @@ function nextRuns() {
 	// This machine's file. Leadership is per host, and so is the clock a cron expression is matched
 	// against, so on a shared `$HOME` each machine keeps its own answers rather than overwriting the
 	// other's with times computed in a different timezone.
-	const safe = HOST.replace(/[^A-Za-z0-9._-]/g, "_");
-	const doc = readJson(path.join(LOOPS_DIR, `next-runs.${safe}.json`), { next: {} });
+	const doc = readJson(path.join(LOOPS_DIR, "next-runs.json"), { next: {} });
 	return doc?.next && typeof doc.next === "object" ? doc.next : {};
 }
 
@@ -467,16 +466,13 @@ function automation(cwd) {
 	// The directory is the evidence, not any one file in it: a project with rules and no cron jobs
 	// has no jobs.json at all, and reporting "pi-loops not found" there would be a lie.
 	if (!fs.existsSync(LOOPS_DIR)) return { installed: false, dir: LOOPS_DIR };
+	// A plain job runs only in the session that created it; the id in this session's header says
+	// whether that is this one, and the panel says "resume it" rather than promising a time.
+	const currentSession = sessionFile ? readHead(sessionFile)?.id : undefined;
 	const jobsFile = readJson(path.join(LOOPS_DIR, "jobs.json"), { jobs: [] });
 	/**
-	 * This project's, whatever machine they were made on.
-	 *
-	 * The host used to be part of this test, so a job stamped with another hostname vanished from
-	 * the panel — and a hostname changes on its own: a rebuilt container, a machine renamed by
-	 * DHCP, a restored backup. What you got was a job sitting enabled in `jobs.json`, never running,
-	 * invisible in the one place you would look. The terminal always listed it and said whose it
-	 * was; so does this, and the count of everything in other projects goes with it, because a list
-	 * that silently drops things is worse than a longer list.
+	 * This project's jobs, and the count of everything in other projects goes with it, because a
+	 * list that silently drops things is worse than a longer list.
 	 */
 	const inThisProject = (j) => sameProject(j.cwd, cwd);
 	const allJobs = jobsFile.jobs ?? [];
@@ -492,7 +488,6 @@ function automation(cwd) {
 		lastError: j.lastError,
 		running: !!j.running,
 		// Set only when it is not this machine's: the panel says so, and nothing else has to guess.
-		otherHost: j.host && j.host !== HOST ? j.host : undefined,
 		// What to type to fix it. The terminal's version of this line says `/cron set <n>`, where n
 		// is the position in a numbered list — which this panel does not have, so telling someone to
 		// use one was telling them to go and find a terminal. A name or a full id resolves anywhere.
@@ -502,7 +497,9 @@ function automation(cwd) {
 		// follows. A time that has already passed is a stale answer rather than a next run (the job
 		// fired and no tick has rewritten the file yet), and saying nothing beats saying something
 		// visibly wrong.
-		next: j.enabled && !(j.host && j.host !== HOST) ? futureOnly(nexts[j.id]) : undefined,
+		next: j.enabled && (j.stateful || (currentSession && j.sessionId === currentSession)) ? futureOnly(nexts[j.id]) : undefined,
+		// Set for a plain job of a session that is not this one: it is asleep, and this is what wakes it.
+		asleep: !j.stateful && !(currentSession && j.sessionId === currentSession) ? "session " + String(j.sessionId || "?").slice(0, 8) + " — resume it to run" : undefined,
 	}));
 	const allRules = readJson(path.join(LOOPS_DIR, "triggers.json"), { rules: [] }).rules ?? [];
 	const rules = allRules
@@ -547,6 +544,8 @@ const PAGE_COMMANDS = [
 	{ name: "clear", description: "start a new session — this one stays on disk, /resume brings it back" },
 	{ name: "new", description: "start a new session — this one stays on disk, /resume brings it back" },
 	{ name: "resume", description: "go back to an earlier session in this project" },
+	{ name: "sessions", description: "list this project's sessions: id, when, what was first said" },
+	{ name: "session", description: "export [path] | import <path> — the .pisession archive commands" },
 	{ name: "compact", description: "compact the context; anything after it steers the summary" },
 ];
 
@@ -1363,7 +1362,11 @@ const server = http.createServer(async (req, res) => {
 			// Submitting while a turn runs queues instead of racing it, as the TUI does.
 			const type = mode === "steer" ? "steer" : mode === "follow_up" ? "follow_up" : "prompt";
 			const message = expandMentions(text ?? "", sessionCwd);
-			return void json(res, await rpc({ type, message, ...(images?.length ? { images } : {}) }));
+			// pi answers a prompt command when the command has *finished*, and a slash command may
+			// sit in a dialog for as long as a person takes to read what it shows (a setup script,
+			// say). Sixty seconds reported that as "timed out" while the command went on to succeed.
+			const patience = message.trimStart().startsWith("/") ? 15 * 60_000 : undefined;
+			return void json(res, await rpc({ type, message, ...(images?.length ? { images } : {}) }, patience));
 		}
 		if (url.pathname === "/model" && req.method === "POST") {
 			// Recorded below, once pi has accepted it.
@@ -1727,7 +1730,7 @@ function liveHostPid() {
  * their automation is dead when it is not.
  */
 function automationToKeepRunning() {
-	const ours = (x) => x.enabled && (!x.host || x.host === HOST);
+	const ours = (x) => x.enabled;
 	const jobs = (readJson(path.join(LOOPS_DIR, "jobs.json"), { jobs: [] }).jobs ?? []).filter((j) => ours(j) && j.stateful);
 	const rules = (readJson(path.join(LOOPS_DIR, "triggers.json"), { rules: [] }).rules ?? []).filter(ours);
 	return jobs.length + rules.length;
@@ -3425,9 +3428,9 @@ function renderSidebar(s) {
         '<button data-run="' + safeText(j.id) + '">run</button></div>' +
         '<div class="m">' + safeText(str(j.prompt).slice(0, 90)) + "</div>" +
         '<div class="m">' + (j.running ? "running · " : "") + "runs " + num(j.runCount) + (j.next ? " · next " + safeText(whenNext(j.next)) : "") + "</div>" +
+        (j.asleep ? '<div class="m" style="color:#c93">' + safeText(j.asleep) + "</div>" : "") +
         // A job belonging to a hostname this machine no longer has: it is listed, because it exists,
         // and it says why nothing is happening rather than leaving you to find out from the silence.
-        (j.otherHost ? '<div class="m" style="color:#c93">other host: ' + safeText(j.otherHost) + " — run <b>/cron set " + safeText(j.ref) + " --host here</b></div>" : "") +
         (j.lastError ? '<div class="m" style="color:#c66">' + safeText(str(j.lastError).slice(0, 120)) + "</div>" : "") + "</div>";
     }
     for (const r of a.rules) {
@@ -3784,7 +3787,7 @@ $("input").addEventListener("paste", (e) => {
 $("composer").onsubmit = async (e) => {
   e.preventDefault();
   const input = $("input");
-  const text = input.value.trim();
+  let text = input.value.trim();
   if (!text && !images.length) return;
   input.value = ""; hidePop();
   if (text) { sentPrompts.push(text); if (sentPrompts.length > 200) sentPrompts.shift(); }
@@ -3793,6 +3796,9 @@ $("composer").onsubmit = async (e) => {
   // instead of being sent: anything attached stays in the tray, and a session about to be replaced
   // is not given a message it would carry nowhere.
   if (pageCommand(text)) return;
+  // '/session export|import' are the archive commands here. pi's own '/session' is a terminal
+  // command that does not exist over rpc, so the two-word spelling is free to mean the extension's.
+  text = text.replace(/^\/session\s+(export|import)\b/i, (_m, sub) => "/session-" + sub.toLowerCase());
   const payload = { text, images, mode: busy ? "follow_up" : undefined };
   const shown = text + (images.length ? "\n[" + images.length + " image(s)]" : "");
   if (!busy) {
@@ -3914,14 +3920,31 @@ function pageCommand(text) {
   if (!m) return false;
   const name = m[1].toLowerCase();
   const rest = m[2].trim();
-  if (name !== "clear" && name !== "new" && name !== "resume" && name !== "compact") return false;
+  if (name === "session" && /^(export|import)\b/i.test(rest)) return false; // an extension command, sent as one
+  if (name !== "clear" && name !== "new" && name !== "resume" && name !== "compact" && name !== "sessions" && name !== "session") return false;
   row("user", "you", text.trim());
   if (name === "compact") compactNow(rest);
   else if (name === "resume") openSessions();
+  else if (name === "sessions") listSessionsHere();
+  else if (name === "session") row("system", "session", "usage: /session export [path] [--exclude-triggers] | /session import <path>\n/sessions lists this project's sessions; the header shows this one's model, cost and context.");
   else swap("/session/new", {}, "new session — the one you left is under resume");
   return true;
 }
 
+/* /sessions: one line per session, newest first — short id, when it started, what was first said. No backticks in here: this is inside the page template. */
+async function listSessionsHere() {
+  const r = await api("/sessions");
+  const list = r.sessions || [];
+  if (!list.length) return row("system", "sessions", "(no sessions for this project yet)");
+  const lines = list.map((s) => {
+    const when = String(s.startedAt || "").slice(0, 16);
+    const said = plain(s.name || s.first || "").replace(/\s+/g, " ");
+    const chars = [...said];
+    return String(s.id).slice(0, 16) + "  " + when + (s.current ? "  [this one]" : "") + "  " + (chars.length > 80 ? chars.slice(0, 80).join("") + "…" : said);
+  });
+  row("system", "sessions", lines.join("\n"));
+}
+
 $("compact").onclick = () => compactNow("");
 $("clear").onclick = () => swap("/session/new", {}, "new session — the one you left is under resume");