@tinoy/pi-canon 0.6.0 → 0.6.2

package/README.md

@@ -24,7 +24,7 @@ pi install npm:@tinoy/pi-canon
 - **Commands** — `/canon` (list, add, remove, edit, category management) and `/canon-dump`.
 - **Injection** — the block is appended at `before_agent_start` and re-normalized on every provider request, so a run started by an injected message carries the same bytes as an interactive prompt.
 - **Category headings** — a category sub-heading inside a scope group prints the store id after the word `category` (`#### Behavioural Preferences [category 1cg5lr]`), which is the same id a `canon_add` refusal lists; the word keeps it from reading as an entry handle, which the block renders as `[1i15c2]`. Uncategorized entries carry no id, and a scope group holding a single category stays flat with no sub-heading.
-- **Peer notices** — entry changes are published over the `ipc` transport's bus (namespace `canon`); receivers match the entry scope against their own model and audience.
+- **Peer notices** — entry changes are published over the `ipc` transport's bus (namespace `canon`); receivers match the entry scope against their own model and audience. A matching notice steers into a run that is already in flight, landing at the next tool boundary, and queues for the next turn when the session is idle, so it never wakes anything.
 - **Tail sections** — another extension contributes prompt text through the `canon:section` event; its ids are published on `canon:sections`.
 
 ## Exports

package/index.ts

@@ -610,6 +610,23 @@ export default function (pi: ExtensionAPI) {
 		pi.events.emit("canon:sections", { ids: registeredSectionIds() });
 	});
 
+	// A notice steered into a live run lands at the next tool boundary, before the next
+	// LLM call; the passive queue drains only when a new turn starts, so a notice emitted
+	// mid-run would otherwise wait for the operator's next prompt. The passive route keeps
+	// the no-wake guarantee where it is needed — an idle session — and steer is used only
+	// while a run is in flight, where it cannot wake anything. A steer queued as the run
+	// settles can carry it one more LLM call; that is the price of a notice landing with the
+	// trajectory rather than after it.
+	let runInFlight = false;
+
+	pi.on("agent_start", () => {
+		runInFlight = true;
+	});
+
+	pi.on("agent_settled", () => {
+		runInFlight = false;
+	});
+
 	// keep the cached model fresh for notification filtering
 	pi.on("before_agent_start", async (event, ctx) => {
 		hookFiredSinceLastRequest = true;
@@ -764,7 +781,25 @@ export default function (pi: ExtensionAPI) {
 			const payload = event.payload as Partial<CanonNotice> | null;
 			if (!payload || payload.type !== "canon" || !payload.scope || !payload.id)
 				return;
-			if (!matches(payload.scope, currentModel(), audiences)) return;
+			if (!matches(payload.scope, currentModel(), audiences)) {
+				// Withholding is otherwise unattributable: nothing is delivered and nothing is
+				// sent back, so a scope mismatch leaves no trace on either side. The decision is
+				// unchanged here — only the record of it is added.
+				hookLog("canon", "notice-withheld", {
+					namespace: NAMESPACE,
+					id: payload.id,
+					op: payload.op,
+					entryModel: payload.scope.model,
+					entryAudience: payload.scope.audience,
+					sessionModel: currentModel(),
+					sessionAudience: sessionLabel(audiences),
+					mismatch:
+						payload.scope.audience !== "all" && !audiences.has(payload.scope.audience)
+							? "audience"
+							: "model",
+				});
+				return;
+			}
 			const sender = payload.sender?.trim() || event.fromSessionId.slice(0, 8);
 			const verb =
 				payload.op === "remove" || payload.op === "category_remove"
@@ -779,9 +814,10 @@ export default function (pi: ExtensionAPI) {
 					display: true,
 					details: { fromSessionId: event.fromSessionId, canonId: payload.id },
 				},
-				// PASSIVE (user 2026-09-01): "steer" wakes idle sessions like a
-				// prompt; "nextTurn" queues for the next user turn, no wake-up.
-				{ deliverAs: "nextTurn" },
+				// An idle session takes the passive queue, because steer would wake it like a
+				// prompt; a run already in flight takes steer, which lands at the next tool
+				// boundary instead of waiting for a turn that has not started.
+				{ deliverAs: runInFlight ? "steer" : "nextTurn" },
 			);
 		},
 		onReady(readyChannel: CanonChannel): void {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tinoy/pi-canon",
-	"version": "0.6.0",
+	"version": "0.6.2",
 	"description": "Durable system-prompt rules for pi: an on-disk canon store, its tools, and the /canon commands.",
 	"license": "MIT",
 	"repository": {