@alphacoder-v0/pi-loops 0.22.8 → 0.24.0

package/src/trigger-runtime.ts

@@ -9,12 +9,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { realpathish } from "./paths.ts";
-import { type PresenceEntry, type PresenceSelf, chooseRuleOwner, isSelf, withinProject } from "./presence.ts";
+import { sameProject, withinProject } from "./paths.ts";
 import { capRedacted, previewRedacted } from "./redact.ts";
 import { type RunnerResult, type SubagentRunner, failedRun } from "./runner.ts";
 import { type SubagentSlot, SubagentSlots } from "./slots.ts";
 import type { JobStore } from "./store.ts";
+import type { Inbox } from "./inbox.ts";
 import { backoffWaitMs, stamp } from "./schedule.ts";
+import { type Look, PathLooks, watchOf } from "./path-precheck.ts";
 import {
 	DEFAULT_TRIGGER_POLL_INTERVAL_SECS,
 	DedupWindow,
@@ -24,11 +26,15 @@ import {
 	type DynamicTriggerRule,
 	type Trigger,
 	TriggerStore,
+	checkDecidedFinding,
 	buildPeriodicCheckTrigger,
 	extractDynamicRuleIds,
 	renderDynamicTriggerPrompt,
  newTraceId } from "./triggers.ts";
 
+/** Bounded, display-only status of a periodic check. */
+export type LastPoll = { at: string; cwd: string; outcome: string; traceId: string; sourceLabel: string; eventLabel: string; summary: string };
+
 export type TriggerDelivery = "sub_agent" | "inject_summary" | "inject_and_run";
 
 export interface RunningTrigger {
@@ -54,12 +60,15 @@ export interface TriggerOutcome {
 	sessionFile?: string;
 }
 
-/** Where a promotion / injection actually went: the chat of this process, or the inbox (wrong project here). */
-export type PromoteTarget = "chat" | "inbox";
+/** Where a promotion / injection went: the chat of this process, the queue of the conversation that created the rule (src/requests.ts), the inbox, or nowhere because an earlier one with its key is still queued. */
+export type PromoteTarget = "chat" | "queued" | "inbox" | "collapsed";
 
 export interface TriggerRuntimeHooks {
-	/** Insert text into the parent chat context (no model turn). Already carries the `[Trigger …]` prefix. Returns where it went. */
-	onPromote?: (content: string, trigger: Trigger) => PromoteTarget | Promise<PromoteTarget>;
+	/**
+	 * Insert text into the parent chat context (no model turn). Already carries the `[Trigger …]` prefix.
+	 * `forSession` is the conversation that created the promoting rules, when they agree on one. Returns where it went.
+	 */
+	onPromote?: (content: string, trigger: Trigger, forSession?: string) => PromoteTarget | Promise<PromoteTarget>;
 	/** Inject `prompt` into the parent chat and run one model turn. Returns where it went. */
 	onInjectAndRun?: (prompt: string, trigger: Trigger) => PromoteTarget | Promise<PromoteTarget>;
 	onStarted?: (running: RunningTrigger) => void;
@@ -80,19 +89,8 @@ export interface TriggerRuntimeOptions {
 	dedupFile?: string;
 	/** Trigger hop of this process (0 for the interactive pi); children get hop + 1. */
 	hop?: number;
-	/**
-	 * Presence of every pi on the machine and this process's own identity. With both, a project's
-	 * checks and push evaluations are run by a pi open in that project (preferring the session
-	 * that created the rules); without them the machine leader does everything (tests).
-	 */
-	presence?: () => PresenceEntry[];
-	self?: PresenceSelf;
-	/** Whether this process is the machine leader right now (used outside tick(), e.g. for pushes). */
-	isLeader?: () => boolean;
 	/** Default cap on a check/action sub-agent (`[triggers] run_timeout_secs`); a rule's `timeoutMs` overrides it. */
 	runTimeoutMs?: number;
-	/** How long a push deferred to another process waits for that process to claim it (see `admit`). */
-	deferredTakeoverMs?: number;
 	/**
 	 * Checks and actions in flight at once. Spawning every accepted trigger concurrently is
 	 * bounded in practice by a person watching the feed; a headless host has nobody watching, and a
@@ -108,10 +106,20 @@ export interface TriggerRuntimeOptions {
 	slots?: SubagentSlots;
 	/** Today's automation spend against `[limits] daily_budget_usd`, shared with the scheduler. */
 	budget?: () => { spent: number; cap: number; over: boolean };
+	/**
+	 * Where a matched rule's result is filed, whatever `promote_to_chat` says (docs/triggers.md).
+	 * Both processes pass the scheduler's inbox; omitted, a result is only audited.
+	 */
+	inbox?: Pick<Inbox, "appendOnce">;
+	/** The `stat` a waiting rule's look uses; tests inject one that hangs. */
+	stat?: (p: string) => Promise<unknown>;
 }
 
 export const DEFAULT_MAX_CONCURRENT_CHECKS = 3;
 
+/** The scheduler's tick, which `tick` here runs on (`DEFAULT_TICK_MS` in scheduler.ts): no poll comes sooner. */
+const POLL_TICK_MS = 30_000;
+
 /**
  * Pushes held while every slot is busy. Retries drain at most `maxConcurrent` (3) per scheduler
  * tick (30s), so 32 is about five minutes of backlog — the width of the dedup window that defines
@@ -151,12 +159,6 @@ export function triggerSessionKey(cwd: string): string {
 export const TRIGGER_SESSIONS_KEPT = 40;
 
 export const DEFAULT_TRIGGER_RUN_TIMEOUT_MS = 15 * 60_000;
-/**
- * A push handed to the presence-chosen owner is only really handled if that process has the MCP
- * server connected — it authenticates per process, so it may not. The receiving process waits this
- * long for the owner to claim the machine-wide dedup key and takes the push back if it does not.
- */
-export const DEFAULT_DEFERRED_TAKEOVER_MS = 5_000;
 
 /** The engine prefixes `[Trigger <trace>] ` and injects the payload summary itself, capped. */
 export function promotionBody(trigger: Trigger, summary: string): string {
@@ -176,12 +178,30 @@ export function promotionSummaryBody(trigger: Trigger, summary: string): string
 	return capRedacted(`[Trigger ${trigger.traceId}] ${trigger.sourceLabel} fired ${trigger.eventLabel}.\nResult: ${summary}`, SUMMARY_CAP_CHARS);
 }
 
+/**
+ * A promoted result no conversation can take, filed in the inbox: what both processes do when the
+ * promotion falls back. A rule check decided its finding already (checkDecidedFinding), filed or
+ * skipped as a repeat; a push with no rule did not, and is filed once by its run.
+ */
+export async function promotionToInbox(inbox: Pick<Inbox, "appendOnce">, audit: Pick<TriggerStore, "listAudit">, content: string, trigger: { sourceLabel: string; traceId: string }, where: { cwd: string; sessionId?: string }): Promise<void> {
+	if (checkDecidedFinding(audit, trigger.traceId)) return;
+	const source = `trigger:${trigger.sourceLabel}`;
+	await inbox.appendOnce({ source, text: content.replace(/^\[Trigger [^\]]+\]\s*/, ""), run_id: trigger.traceId, job_id: trigger.sourceLabel, cwd: where.cwd, session_id: where.sessionId }, { run_id: trigger.traceId, source });
+}
+
 /**
  * The envelope fields carried on every audit row, in every state a trigger passes through. Without
  * the idempotency key on each of them, "which pushes collapsed into which" cannot be answered after
  * the fact — and that question is the whole reason the dedup window is allowed to drop anything.
  * Bounded and redacted: a key is caller-supplied text.
  */
+/** Rules by the conversation that created them: one check's result goes to each of those once. */
+function byCreator(rules: readonly DynamicTriggerRule[]): Map<string | undefined, DynamicTriggerRule[]> {
+	const out = new Map<string | undefined, DynamicTriggerRule[]>();
+	for (const r of rules) out.set(r.createdBy?.sessionId, [...(out.get(r.createdBy?.sessionId) ?? []), r]);
+	return out;
+}
+
 function envelopeOf(trigger: Trigger): Record<string, unknown> {
 	return { idempotency_key: capRedacted(trigger.idempotencyKey, 256), replacement_policy: trigger.replacementPolicy, received_at: trigger.receivedAt };
 }
@@ -197,25 +217,28 @@ export class TriggerRuntime {
 	/** Pushes that inject into this window are deduplicated here only: every window reacts. */
 	private readonly localDedup = new DedupWindow();
 	private readonly ledger: PollLedger;
-	private readonly presence?: () => PresenceEntry[];
-	private readonly self?: PresenceSelf;
-	private readonly isLeader?: () => boolean;
 	private readonly hop: number;
 	/** Mutable so a config reload at session start takes effect. */
 	runTimeoutMs: number;
-	private readonly deferredTakeoverMs: number;
 	private readonly running = new Map<string, RunningTrigger>();
 	/** Pushes refused for want of a slot, waiting for the next tick to retry them (see `queuePush`). */
 	private readonly pending = new Map<string, { trigger: Trigger; delivery: TriggerDelivery }>();
 	/** Every sub-agent this process starts takes a slot from here, loop runs included. */
 	readonly slots: SubagentSlots;
 	private readonly budget: () => { spent: number; cap: number; over: boolean };
+	private readonly inbox: Pick<Inbox, "appendOnce"> | undefined;
 	pollIntervalSecs: number;
 	lastCheckAt = 0;
 	/** Bounded, display-only status of the latest periodic check. */
-	lastPoll: { at: string; cwd: string; outcome: string; traceId: string; sourceLabel: string; eventLabel: string; summary: string } | undefined;
+	lastPoll: LastPoll | undefined;
+	/** The same, per project: the host checks every project's rules, and a window shows its own. */
+	readonly lastPolls = new Map<string, LastPoll>();
 	dedupedCount = 0;
 	cycleSuppressedCount = 0;
+	/** The `stat`s of rules that wait for a path (src/path-precheck.ts): one in flight per rule. */
+	private readonly looks: PathLooks;
+	/** Each waiting rule's last look in this process and when it was made; the audit row is written on a change only. */
+	private readonly lastLooks = new Map<string, { look: Look; at: number }>();
 
 	constructor(opts: TriggerRuntimeOptions) {
 		this.store = opts.store;
@@ -227,14 +250,12 @@ export class TriggerRuntime {
 		this.pollIntervalSecs = opts.pollIntervalSecs ?? DEFAULT_TRIGGER_POLL_INTERVAL_SECS;
 		this.dedup = new DedupWindow(undefined, opts.dedupFile);
 		this.ledger = new PollLedger(opts.dedupFile ? path.join(path.dirname(opts.dedupFile), "polls.json") : undefined);
-		this.presence = opts.presence;
-		this.self = opts.self;
-		this.isLeader = opts.isLeader;
 		this.hop = opts.hop ?? 0;
 		this.runTimeoutMs = opts.runTimeoutMs ?? DEFAULT_TRIGGER_RUN_TIMEOUT_MS;
-		this.deferredTakeoverMs = opts.deferredTakeoverMs ?? DEFAULT_DEFERRED_TAKEOVER_MS;
 		this.slots = opts.slots ?? new SubagentSlots(opts.maxConcurrent ?? DEFAULT_MAX_CONCURRENT_CHECKS);
 		this.budget = opts.budget ?? (() => ({ spent: 0, cap: 0, over: false }));
+		this.inbox = opts.inbox;
+		this.looks = new PathLooks({ stat: opts.stat });
 		// Audit writes are best-effort — a failed write never fails a trigger; say so once per distinct error.
 		let lastReported: string | undefined;
 		this.store.onPersistenceError ??= (message) => {
@@ -279,60 +300,30 @@ export class TriggerRuntime {
 		this.abortAll();
 	}
 
-	/** The process that must evaluate `rule`; `undefined` when nobody owns it and the leader steps in. */
-	private ownerOf(rule: DynamicTriggerRule): PresenceEntry | undefined {
-		if (!this.self) return undefined;
-		return chooseRuleOwner(this.presence?.() ?? [], rule.cwd, this.self.host, rule.createdBy?.sessionId);
-	}
-
-	/**
-	 * Whether this process evaluates `rule`. A rule belongs to the session that created it, not to
-	 * its directory, so two pi windows in one repo each check their own rules and a result can only
-	 * be promoted into the chat that asked for it. `ownIfUnowned` covers only the rules nobody owns —
-	 * their creating session has closed and their project has no pi open — which the machine leader
-	 * checks, into the inbox. It never takes a rule away from the process that does own it.
-	 */
-	ownsRule(rule: DynamicTriggerRule, ownIfUnowned: boolean): boolean {
-		if (!this.self) return ownIfUnowned;
-		const owner = this.ownerOf(rule);
-		return owner ? isSelf(owner, this.self) : ownIfUnowned;
-	}
-
-	/**
-	 * The slot a rule's work occupies machine-wide (poll ledger, push dedup): its creating session
-	 * while that session is open — nobody else may take it — else the project's shared slot, so a
-	 * hand-over between processes still never double-checks.
-	 */
-	private slotOf(rule: DynamicTriggerRule): string {
-		const sid = rule.createdBy?.sessionId;
-		return sid && this.ownerOf(rule)?.sessionId === sid ? sid : "";
-	}
-
 	/**
-	 * This host's enabled rules that govern `cwd`, split into the ones this process owns. A rule
-	 * created at `~/proj` still governs a pi opened at `~/proj/src` or through a symlink to it:
-	 * comparing the cwd strings silently diverted those promotions to the inbox.
-	 *
-	 * `ownIfUnowned` is passed straight to `ownsRule`: it only adds the rules nobody owns.
+	 * The enabled rules that govern `cwd`. A rule created at `~/proj` still governs a push received
+	 * at `~/proj/src` or through a symlink to it: comparing the cwd strings silently diverted those
+	 * promotions to the inbox.
 	 */
-	private rulesFor(cwd: string | undefined, ownIfUnowned: boolean): { applicable: DynamicTriggerRule[]; owned: DynamicTriggerRule[] } {
+	private rulesFor(cwd: string | undefined): DynamicTriggerRule[] {
 		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)) };
+		return cwd ? all.filter((r) => withinProject(r.cwd, cwd)) : all;
 	}
 
 	/**
-	 * Scheduler tick (every process): emit one periodic check per project whose rules this process
-	 * owns, at most once per poll interval machine-wide. The ledger is claimed per ownership slot,
-	 * not per project, so two windows in one repo each check their own rules once per interval while
-	 * a hand-over of the project's own rules still never double-checks.
+	 * Scheduler tick of the host, the one process that checks rules: one periodic check per project,
+	 * at most once per poll interval.
+	 *
+	 * The poll ledger is shared with pi-loops 0.22 windows during an upgrade. Those claim
+	 * `<host>:<cwd>` for a project's unowned rules and `<host>:<cwd>#<session>` for the rules of a
+	 * session they have open, so this claims the same keys: a project another process has just
+	 * checked is skipped, and so are the rules of a session an old window checked itself.
 	 */
-	async tick(now: number, leader: boolean): Promise<void> {
-		// Before raising new work: the pushes this process refused while it was busy. They are its own
-		// backlog, not the leader's, so leadership does not gate them.
+	async tick(now: number): Promise<void> {
+		// Before raising new work: the pushes this process refused while it was busy.
 		this.retryPending();
-		const host = this.self?.host ?? os.hostname();
-		const rules = this.store.load().filter((r) => r.enabled && this.ownsRule(r, leader) && !this.inBackoff(r, now));
+		const host = os.hostname();
+		const rules = this.store.load().filter((r) => r.enabled && !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]);
@@ -348,30 +339,75 @@ export class TriggerRuntime {
 				continue;
 			}
 			if ([...this.running.values()].some((r) => r.cwd === cwd && r.sourceLabel === "local:dynamic")) continue; // previous check still active
-			const bySlot = new Map<string, DynamicTriggerRule[]>();
+			const interval = this.pollIntervalSecs * 1000;
+			if (!(await this.ledger.claim(`${host}:${cwd}`, now, interval))) continue;
+			const claimed: DynamicTriggerRule[] = [];
+			const bySession = new Map<string, DynamicTriggerRule[]>();
 			for (const r of group) {
-				const slot = this.slotOf(r);
-				bySlot.set(slot, [...(bySlot.get(slot) ?? []), r]);
+				const sid = r.createdBy?.sessionId;
+				if (sid) bySession.set(sid, [...(bySession.get(sid) ?? []), r]);
+				else claimed.push(r);
 			}
-			const claimed: DynamicTriggerRule[] = [];
-			for (const [slot, owned] of bySlot) {
-				if (await this.ledger.claim(`${host}:${cwd}${slot ? `#${slot}` : ""}`, now, this.pollIntervalSecs * 1000)) claimed.push(...owned);
+			for (const [sid, own] of bySession) {
+				if (await this.ledger.claim(`${host}:${cwd}#${sid}`, now, interval)) claimed.push(...own);
 			}
 			if (!claimed.length) continue;
 			this.lastCheckAt = now;
+			// After the claim, so a rule that waits for a path is looked at once per poll, as a model
+			// check would be. A path that is absent keeps its rule out of the prompt; an `unknown` look
+			// (no permission, a hung mount) asks the model, as before there was a pre-check.
+			const looks = await Promise.all(claimed.map((r) => this.lookFor(r)));
+			this.noteLooks(cwd, claimed, looks, now);
+			const due = claimed.filter((_, i) => looks[i] !== "absent");
+			if (!due.length) continue;
+			const prechecked = claimed.filter((_, i) => looks[i] === "present").map((r) => r.id);
 			// `handle` is documented not to reject; the catch is what makes that true rather than
 			// merely intended, since nothing above this would survive one.
-			void this.handle(buildPeriodicCheckTrigger(cwd, claimed.length, new Date(now), this.self ? `${this.self.pid}-${this.self.instance}` : ""), "sub_agent", claimed).catch((err: any) =>
+			void this.handle(buildPeriodicCheckTrigger(cwd, due.length, new Date(now), String(process.pid)), "sub_agent", due, prechecked.length ? { prechecked } : undefined).catch((err: any) =>
 				this.log(`check failed: ${err?.message ?? err}`),
 			);
 		}
 	}
 
+	/** A waiting rule's look, or undefined for a rule the model checks as it always did. */
+	private lookFor(rule: DynamicTriggerRule): Promise<Look | undefined> {
+		const w = watchOf(rule);
+		return w ? this.looks.look(rule.id, w) : Promise.resolve(undefined);
+	}
+
+	/**
+	 * One `trigger` audit row per waiting rule on a change only: `waiting` at the first look this
+	 * process makes and when the path goes away, `appeared` when it comes back. A rule whose path stays
+	 * absent writes nothing more, which is the point: no `running` row and no model call either.
+	 */
+	private noteLooks(cwd: string, rules: DynamicTriggerRule[], looks: Array<Look | undefined>, now: number): void {
+		rules.forEach((rule, i) => {
+			const look = looks[i];
+			const w = watchOf(rule);
+			if (!look || !w) return;
+			const prev = this.lastLooks.get(rule.id)?.look;
+			this.lastLooks.set(rule.id, { look, at: now });
+			const row = (state: string, summary: string) =>
+				this.store.appendAudit({ cwd, type: "trigger", traceId: newTraceId(), state, sourceLabel: "local:dynamic", eventLabel: rule.id, summary, details: { rule_id: rule.id, path: w.raw, resolved: w.resolved } });
+			if (look === "absent" && prev !== "absent") row("waiting", `no model call until ${w.raw} exists`);
+			else if (look === "present" && prev === "absent") row("appeared", `${w.raw} exists; the model checks the rule`);
+		});
+	}
+
+	/**
+	 * What the page's rule row says about a rule that waits for a path: its last look here, and when
+	 * the next one is. Polls ride the scheduler's 30-second tick, so no look comes sooner than that.
+	 */
+	ruleLook(ruleId: string): { look: Look; nextAt: number } | undefined {
+		const last = this.lastLooks.get(ruleId);
+		return last && { look: last.look, nextAt: last.at + Math.max(this.pollIntervalSecs * 1000, POLL_TICK_MS) };
+	}
+
 	/**
 	 * Admit one trigger: dedup, audit, deliver. Resolves when the delivery has finished and
 	 * never rejects: persistence or runner failures are audited (best effort) and logged.
 	 */
-	async handle(trigger: Trigger, delivery: TriggerDelivery, rules?: DynamicTriggerRule[]): Promise<TriggerOutcome | undefined> {
+	async handle(trigger: Trigger, delivery: TriggerDelivery, rules?: DynamicTriggerRule[], opts?: { prechecked?: string[] }): Promise<TriggerOutcome | undefined> {
 		// Sub-agents register no notification hooks and run no dynamic checker, so only the
 		// interactive process (hop 0) ever handles a trigger. Anything reaching a deeper hop is a
 		// cycle and is suppressed, audited as cycle-suppressed.
@@ -390,7 +426,7 @@ export class TriggerRuntime {
 				const outcomes = await Promise.all(cwds.map((cwd, i) => this.admit({ ...trigger, cwd, traceId: i ? newTraceId() : trigger.traceId }, delivery)));
 				return outcomes.find(Boolean);
 			}
-			return await this.admit(trigger, delivery, rules);
+			return await this.admit(trigger, delivery, rules, opts);
 		} catch (err: any) {
 			const message = err?.message ?? String(err);
 			this.running.delete(trigger.traceId);
@@ -400,7 +436,7 @@ export class TriggerRuntime {
 		}
 	}
 
-	private async admit(trigger: Trigger, delivery: TriggerDelivery, rules?: DynamicTriggerRule[]): Promise<TriggerOutcome | undefined> {
+	private async admit(trigger: Trigger, delivery: TriggerDelivery, rules?: DynamicTriggerRule[], opts?: { prechecked?: string[] }): Promise<TriggerOutcome | undefined> {
 		// A sub-agent costs money and a process slot. Both bounds are checked before the dedup claim,
 		// so a refused trigger is never marked handled — a periodic check is simply raised again by the
 		// next poll, and a push (an event that happened once, which no server repeats) is held below.
@@ -440,24 +476,10 @@ export class TriggerRuntime {
 		try {
 			let prev: Awaited<ReturnType<DedupWindow["check"]>>;
 			if (trigger.source.kind === "mcp" && delivery === "sub_agent") {
-				// A push evaluated against dynamic rules: by the process that owns them (each session
-				// evaluates its own registry), and once per ownership slot machine-wide.
+				// A push evaluated against dynamic rules: by the host alone, once per project machine-wide.
 				const cwd = trigger.cwd ?? this.getSession().cwd;
-				const scope = this.rulesFor(cwd, this.isLeader?.() ?? true);
-				rules = scope.owned;
-				if (scope.applicable.length && !scope.owned.length) {
-					// The owner may not have this MCP server connected at all — servers authenticate per
-					// process — and a push nobody handles is simply lost. Record the hand-off, then take the
-					// push back if the owner has not claimed the slot below inside the takeover window; the
-					// claim is machine-wide, so at most one process ever evaluates it.
-					this.store.appendAudit({ cwd, type: "trigger", traceId: trigger.traceId, state: "deferred", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: trigger.payloadSummary, details: { delivery, reason: "another pi in this project owns rule evaluation", takeover_after_ms: this.deferredTakeoverMs, ...envelopeOf(trigger) } });
-					await new Promise((r) => setTimeout(r, this.deferredTakeoverMs));
-					rules = scope.applicable;
-				}
-				prev = await this.dedup.check(this.pushClaimKey(trigger, cwd, rules), trigger.traceId, this.now(), trigger.replacementPolicy);
-				if (!prev && !scope.owned.length && scope.applicable.length) {
-					this.store.appendAudit({ cwd, type: "trigger", traceId: trigger.traceId, state: "taken_over", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: trigger.payloadSummary, details: { delivery, reason: "the owning pi did not claim the push", ...envelopeOf(trigger) } });
-				}
+				rules = this.rulesFor(cwd);
+				prev = await this.dedup.check(`${trigger.idempotencyKey}@${os.hostname()}:${realpathish(cwd)}`, trigger.traceId, this.now(), trigger.replacementPolicy);
 			} else if (trigger.source.kind === "mcp") {
 				// A push injected into the chat: every window that has the server reacts (every
 				// session), so the dedup window is this process's own.
@@ -478,7 +500,7 @@ export class TriggerRuntime {
 			// runs the finally at once, which would release the slot the moment the sub-agent started.
 			if (delivery === "inject_summary") return await this.deliverInjectSummary(trigger);
 			if (delivery === "inject_and_run") return await this.deliverInjectAndRun(trigger);
-			return await this.deliverSubAgent(trigger, rules);
+			return await this.deliverSubAgent(trigger, rules, opts?.prechecked);
 		} finally {
 			// Held for the whole delivery, `deliverSubAgent` included, and released on every path out of
 			// it — a torn dedup file, a runner that rejects, an abort — or the pool leaks a slot.
@@ -578,25 +600,14 @@ export class TriggerRuntime {
 		this.log(`${backing.length} trigger rule(s) failed ${worst} checks in a row; polling them with a widening gap`);
 	}
 
-	/**
-	 * The machine-wide claim a pushed evaluation takes. Keyed by the project (realpath, so two
-	 * windows reaching it by different paths agree) and by the ownership slots of the rules being
-	 * evaluated, so windows checking *different* rules of one project both react while a deferred
-	 * push and its owner still contend for the same key.
-	 */
-	private pushClaimKey(trigger: Trigger, cwd: string, rules: DynamicTriggerRule[]): string {
-		const slots = [...new Set(rules.map((r) => this.slotOf(r)))].sort().join(",");
-		return `${trigger.idempotencyKey}@${this.self?.host ?? os.hostname()}:${realpathish(cwd)}${slots ? `#${slots}` : ""}`;
-	}
-
 	private async deliverInjectSummary(trigger: Trigger): Promise<TriggerOutcome> {
 		const start = this.now();
 		const summary = trigger.payloadSummary ?? "";
 		let promoted = false;
 		if (summary) {
 			const target = (await this.hooks.onPromote?.(promotionBody(trigger, summary), trigger)) ?? "chat";
-			promoted = target === "chat";
-			this.store.appendAudit({ cwd: trigger.cwd ?? this.getSession().cwd, type: "trigger_promotion", traceId: trigger.traceId, state: target === "chat" ? "promoted" : "redirected", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary, details: { prefix_injected: true, delivery: "inject_summary", to: target, ...envelopeOf(trigger) } });
+			promoted = target !== "inbox";
+			this.store.appendAudit({ cwd: trigger.cwd ?? this.getSession().cwd, type: "trigger_promotion", traceId: trigger.traceId, state: target === "inbox" ? "redirected" : "promoted", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary, details: { prefix_injected: true, delivery: "inject_summary", to: target, ...envelopeOf(trigger) } });
 		}
 		// `over_budget` on a completed row is the audit's answer to "everything else stopped today —
 		// why did this run": because it cost nothing.
@@ -612,7 +623,7 @@ export class TriggerRuntime {
 		const prompt = `[Trigger ${trigger.traceId}] ${trigger.payloadSummary ?? `${trigger.sourceLabel} fired: ${trigger.eventLabel}`}`;
 		const target = (await this.hooks.onInjectAndRun?.(prompt, trigger)) ?? "chat";
 		this.store.appendAudit({ cwd: trigger.cwd ?? this.getSession().cwd, type: "trigger_result", traceId: trigger.traceId, state: "completed", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: trigger.payloadSummary, details: { delivery: "inject_and_run", prefix_injected: true, cost_usd: 0, to: target, ...envelopeOf(trigger) } });
-		const outcome: TriggerOutcome = { trigger, delivery: "inject_and_run", ok: true, matchedRules: [], summary: trigger.payloadSummary ?? "", durationMs: this.now() - start, cost: 0, promoted: target === "chat" };
+		const outcome: TriggerOutcome = { trigger, delivery: "inject_and_run", ok: true, matchedRules: [], summary: trigger.payloadSummary ?? "", durationMs: this.now() - start, cost: 0, promoted: target !== "inbox" };
 		this.hooks.onFinished?.(outcome);
 		return outcome;
 	}
@@ -626,13 +637,13 @@ export class TriggerRuntime {
 		return trigger.cwd ?? this.getSession().cwd;
 	}
 
-	private async deliverSubAgent(trigger: Trigger, evaluate?: DynamicTriggerRule[]): Promise<TriggerOutcome> {
+	private async deliverSubAgent(trigger: Trigger, evaluate?: DynamicTriggerRule[], prechecked?: string[]): Promise<TriggerOutcome> {
 		const start = this.now();
 		const session = this.getSession();
 		const cwd = this.cwdOf(trigger);
 		// `evaluate` is what the caller already resolved (the tick's claimed rules, a taken-over
 		// push); otherwise this is a direct handle() and we take the rules of this project we own.
-		const rules = evaluate ?? this.rulesFor(trigger.cwd, this.isLeader?.() ?? true).owned;
+		const rules = evaluate ?? this.rulesFor(trigger.cwd);
 		if (!rules.length) {
 			this.store.appendAudit({ cwd, type: "trigger_result", traceId: trigger.traceId, state: "no_rules", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: trigger.payloadSummary, details: { delivery: "sub_agent", ...envelopeOf(trigger) } });
 			const outcome: TriggerOutcome = { trigger, delivery: "sub_agent", ok: true, matchedRules: [], summary: "no enabled dynamic trigger rules", durationMs: 0, cost: 0, promoted: false };
@@ -644,7 +655,7 @@ export class TriggerRuntime {
 		const running: RunningTrigger = { traceId: trigger.traceId, sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, startedAt: stamp(start), promptPreview: previewRedacted(prompt, 80), cwd, ctrl }; // 80 characters is a banner, not a prompt
 		this.running.set(trigger.traceId, running);
 		this.hooks.onStarted?.(running);
-		this.store.appendAudit({ cwd, type: "trigger_result", traceId: trigger.traceId, state: "running", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, details: { rule_count: rules.length, cwd, ...envelopeOf(trigger) } });
+		this.store.appendAudit({ cwd, type: "trigger_result", traceId: trigger.traceId, state: "running", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, details: { rule_count: rules.length, cwd, ...(prechecked?.length ? { prechecked } : {}), ...envelopeOf(trigger) } });
 
 		// The check runs with the model the rules were created under, not whatever the process that
 		// happens to own the timer is using. Both come from the first rule that recorded a model,
@@ -678,6 +689,23 @@ export class TriggerRuntime {
 		if (matchedRules.length) await this.store.markFired(matchedRules.map((r) => r.id));
 		const quiet = result.ok && matchedRules.length === 0;
 		const state = ctrl.signal.aborted ? "aborted" : result.ok ? "completed" : "failed";
+		// Every match is a finding, before any promotion and before the result's row, which records what
+		// was decided (`details.inbox`): the promotion's inbox fallback and the row's dead letter read it
+		// and file nothing more (checkDecidedFinding). The text is what the check said, unedited. It is
+		// news: what a check says comes from outside, and `· waits:` in it must not make it a decision.
+		// A repeating rule that says again what its latest new finding says files nothing.
+		let inboxDecision: "filed" | "repeat" | undefined;
+		if (result.ok && matchedRules.length && this.inbox) {
+			const source = `trigger:${trigger.sourceLabel}`;
+			for (const [forSession, group] of byCreator(matchedRules)) {
+				try {
+					const there = await this.inbox.appendOnce({ source, text: summary, run_id: trigger.traceId, job_id: group[0].id, cwd, session_id: forSession }, { run_id: trigger.traceId, source, session_id: forSession }, { unlessRepeat: true });
+					inboxDecision = there.run_id === trigger.traceId ? "filed" : (inboxDecision ?? "repeat");
+				} catch (err: any) {
+					this.log(`trigger ${trigger.traceId.slice(0, 8)}: inbox append failed: ${err?.message ?? err}`);
+				}
+			}
+		}
 		this.store.appendAudit({
 			cwd,
 			type: "trigger_result",
@@ -686,7 +714,9 @@ export class TriggerRuntime {
 			sourceLabel: trigger.sourceLabel,
 			eventLabel: trigger.eventLabel,
 			summary: result.ok ? summary || NO_MATCH_SENTINEL : result.errorMessage,
-			details: { delivery: "sub_agent", matched_rule_ids: matchedIds, quiet, cost_usd: result.usage.cost, exit_code: result.exitCode, session_file: result.sessionFile, ...envelopeOf(trigger) },
+			// `matched_rule_ids` are this project's rules the check named; `named_rule_ids` is every id it
+			// wrote, a made-up one or another project's included, which only `/triggers audit` shows.
+			details: { delivery: "sub_agent", matched_rule_ids: matchedRules.map((r) => r.id), named_rule_ids: matchedIds, quiet, cost_usd: result.usage.cost, exit_code: result.exitCode, session_file: result.sessionFile, ...(inboxDecision ? { inbox: inboxDecision } : {}), ...envelopeOf(trigger) },
 		});
 		// An abort is the user's decision about this run, not evidence that the rule's check is broken,
 		// so it neither counts against the rule nor clears what earlier failures recorded.
@@ -695,13 +725,20 @@ export class TriggerRuntime {
 		let promoted = false;
 		const promoteRules = matchedRules.filter((r) => r.promoteToChat);
 		if (result.ok && promoteRules.length) {
-			const target = (await this.hooks.onPromote?.(promotionSummaryBody(trigger, summary), trigger)) ?? "chat";
-			promoted = target === "chat";
-			this.store.appendAudit({ cwd, type: "trigger_promotion", traceId: trigger.traceId, state: target === "chat" ? "promoted" : "redirected", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary, details: { prefix_injected: true, rule_ids: promoteRules.map((r) => r.id), to: target, template_name: "default", ...envelopeOf(trigger) } });
+			// One check covers every rule of the project, and two conversations in one repo each get the
+			// result of their own rules: one promotion per creating conversation.
+			for (const [forSession, group] of byCreator(promoteRules)) {
+				const target = (await this.hooks.onPromote?.(promotionSummaryBody(trigger, summary), trigger, forSession)) ?? "chat";
+				promoted ||= target !== "inbox";
+				this.store.appendAudit({ cwd, type: "trigger_promotion", traceId: trigger.traceId, state: target === "inbox" ? "redirected" : "promoted", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary, details: { prefix_injected: true, rule_ids: group.map((r) => r.id), to: target, template_name: "default", ...envelopeOf(trigger) } });
+			}
 		} else if (result.ok && matchedRules.length) {
 			this.store.appendAudit({ cwd, type: "trigger_promotion", traceId: trigger.traceId, state: "skipped", sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, details: { reason: "no matched rule has promote_to_chat", ...envelopeOf(trigger) } });
 		}
-		if (trigger.sourceLabel === "local:dynamic") this.lastPoll = { at: stamp(this.now()), cwd, outcome: state === "completed" ? (quiet ? "no match" : `matched ${matchedRules.length}`) : state, traceId: trigger.traceId, sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: previewRedacted(result.ok ? summary || NO_MATCH_SENTINEL : (result.errorMessage ?? ""), 160) };
+		if (trigger.sourceLabel === "local:dynamic") {
+			this.lastPoll = { at: stamp(this.now()), cwd, outcome: state === "completed" ? (quiet ? "no match" : `matched ${matchedRules.length}`) : state, traceId: trigger.traceId, sourceLabel: trigger.sourceLabel, eventLabel: trigger.eventLabel, summary: previewRedacted(result.ok ? summary || NO_MATCH_SENTINEL : (result.errorMessage ?? ""), 160) };
+			this.lastPolls.set(cwd, this.lastPoll);
+		}
 		const outcome: TriggerOutcome = { trigger, delivery: "sub_agent", ok: result.ok, matchedRules, summary, error: result.ok ? undefined : result.errorMessage, durationMs: this.now() - start, cost: result.usage.cost, promoted, sessionFile: result.sessionFile };
 		this.hooks.onFinished?.(outcome);
 		return outcome;

package/src/triggers.ts

@@ -6,11 +6,13 @@
  * reports the matched `dyn-…` ids, which the runtime marks fired.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { clampFuture, stamp } from "./schedule.ts";
 import { withFileLock, writeFileAtomic } from "./lock.ts";
 import { capRedacted, previewRedacted } from "./redact.ts";
+import { type PathWatch, pathOnlyCondition } from "./path-precheck.ts";
 
 export const DEFAULT_TRIGGER_POLL_INTERVAL_SECS = 10 * 60;
 export const DEDUP_WINDOW_MS = 5 * 60_000;
@@ -40,6 +42,12 @@ export interface DynamicTriggerRule {
 	consecutiveFailures?: number;
 	/** When the last failing check ran: the backoff is measured from here, so a rule that has never been checked is never held back. */
 	lastCheckFailedAt?: string;
+	/**
+	 * Set when the condition is only "<path> exists / appears" (src/path-precheck.ts): each poll
+	 * `stat`s the path first, and no model is asked while it is absent. Recorded at creation only;
+	 * a rule without it is model-checked as before.
+	 */
+	precheck?: PathWatch;
 }
 
 export type SourceKind = "local" | "mcp";
@@ -112,7 +120,8 @@ export function parseTriggerRule(spec: string): ParsedTriggerRule {
 	return { condition, action };
 }
 
-function cleanCondition(raw: string): string {
+/** A condition as the store keeps it: no leading "when" or "if", so a row that says `when …` says it once. */
+export function cleanCondition(raw: string): string {
 	let s = raw.trim();
 	if (s.startsWith(ZH_WHEN)) s = s.slice(ZH_WHEN.length).trim();
 	if (s.startsWith(ZH_IF)) s = s.slice(ZH_IF.length).trim();
@@ -215,7 +224,7 @@ interface RulesFile {
 	rules: DynamicTriggerRule[];
 }
 
-export type AuditType = "trigger" | "trigger_result" | "trigger_promotion" | "cron_control_plane";
+export type AuditType = "trigger" | "trigger_result" | "trigger_promotion" | "cron_control_plane" | "request";
 
 export interface AuditRecord {
 	ts: string;
@@ -258,7 +267,12 @@ export class TriggerStore {
 			throw err;
 		}
 		if (!text.trim()) return [];
-		const parsed = JSON.parse(text) as RulesFile;
+		let parsed: RulesFile;
+		try {
+			parsed = JSON.parse(text) as RulesFile;
+		} catch (err: any) {
+			throw new Error(`${this.rulesFile}: ${err?.message ?? err}`);
+		}
 		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;
@@ -291,7 +305,13 @@ export class TriggerStore {
 			thinking: input.thinking,
 			createdBy: { sessionId: input.sessionId },
 		};
-		await this.mutate((rules) => rules.push(rule));
+		// Here, in the process that creates the rule: `~` is the creator's home, which the background
+		// process started by a service manager may not share.
+		const only = pathOnlyCondition(condition, { cwd: input.cwd, home: os.homedir() });
+		if ("watch" in only) rule.precheck = only.watch;
+		await this.mutate((rules) => {
+			rules.push(rule);
+		});
 		return rule;
 	}
 
@@ -406,6 +426,16 @@ export class TriggerStore {
 	}
 }
 
+/**
+ * Whether the rule check of run `traceId` made its inbox decision: it filed the result, or skipped
+ * it as a repeat of its rule's latest new finding (`details.inbox` on its `trigger_result` row). The
+ * promotion's inbox fallback and the row's dead letter then file nothing: the check's decision for
+ * the run stands, whatever words the promotion wrapped the result in.
+ */
+export function checkDecidedFinding(audit: Pick<TriggerStore, "listAudit">, traceId: string): boolean {
+	return audit.listAudit(1, (r) => r.type === "trigger_result" && r.traceId === traceId && (r.details?.inbox === "filed" || r.details?.inbox === "repeat")).length > 0;
+}
+
 export const AUDIT_USAGE = "usage: /triggers audit [N] [--all]   (N is the number of rows, default 10)";
 
 /**
@@ -437,9 +467,11 @@ export function auditArgs(rest: string): { limit: number; all: boolean } | { usa
  * on_control_plane_prompt hook configured"); a UI-less interactive process is refused; an
  * interactive UI gets to ask. Returns the denial text, or undefined when the caller should ask.
  */
-export function controlPlanePreflight(proc: { hop: number; hasUI: boolean }, reason: string): string | undefined {
-	if (proc.hop > 0) return `${reason} requires user confirmation; sub-agents have no control-plane prompt channel (fail-closed deny)`;
-	if (!proc.hasUI) return `${reason} requires interactive confirmation; use the slash command instead`;
+export function controlPlanePreflight(proc: { hop: number; hasUI: boolean; held?: boolean }, reason: string): string | undefined {
+	// A plain job's turn in a closed conversation: the person's own turn, run where they were not.
+	if (proc.held) return `${reason} requires user confirmation; this turn ran in the background with nobody to ask (fail-closed deny): report what you would have done, so it can be approved when the conversation is open`;
+	if (proc.hop > 0) return `${reason} requires user confirmation; sub-agents have no control-plane prompt channel (fail-closed deny): report what you would have done, so a person can do it`;
+	if (!proc.hasUI) return `${reason} requires interactive confirmation; a person can do it with the slash command`;
 	return undefined;
 }