@andares/pi-toolkits 0.9.2 → 0.9.4

package/README.md

@@ -133,6 +133,8 @@ Repeating the argument form with the modes already in force is a **no-op**: no s
 
 **Composition with `/ask`**: the two features are independent gates on one bus. Each answers only its own question — ask: "does this mutate?", permission: "does this cross the boundary?" — and either can block. Ask mode still denies credential reads, and permission still applies while the read-only sandbox is active. Neither feature needs to know the other exists.
 
+**Startup is quiet**: when the command comes from autostart, the chat notice is suppressed and only the footer status (`perm i:… o:…`) announces the mode. This is deliberate — the host keeps every info notice in the chat but renders all of them from one shared "last status" field, so an info notice emitted after another extension's warning (for example `/lens-toggle`) makes the earlier line display the new text too, i.e. the same message twice. A manual `/ask-perm` still prints the notice.
+
 **Enable it for every session** (the state itself is never persisted — this is the opt-in):
 
 ```toml

package/README.zh-CN.md

@@ -133,6 +133,8 @@ pi -e ./src/index.ts
 
 **与 `/ask` 的组合**:两者是同一总线上的独立闸门,各自只回答自己的问题 —— ask 回答「会不会产生变更」,permission 回答「有没有越过边界」,任一拦截都生效。所以 ask 模式下凭据仍然读不到,permission 在只读沙箱下也照常工作;两个功能互不需要知道对方存在。
 
+**启动时保持安静**:命令由 autostart 触发时不再往聊天区发提示,只由 footer 状态(`perm i:… o:…`)体现。这是有意的——宿主会把每条 info 提示留在聊天记录里,但所有这种行都渲染同一个「最新状态」字段,于是紧跟在别的扩展 warning(例如 `/lens-toggle`)之后的 info 提示会让前一行也显示新文案,也就是同一条消息出现两次。手动执行 `/ask-perm` 仍然会提示。
+
 **每个会话自动开启**(状态本身不落盘,这就是持久化的替身):
 
 ```toml

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andares/pi-toolkits",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Integrated toolkit extension for pi — ask mode (read-only Q&A), session-scoped permission checks, model favorites, prompt stash, third-party code review, session autostart, and a dedicated compaction model",
   "type": "module",
   "license": "MIT",

package/src/features/autostart/autostart.test.ts

@@ -21,6 +21,7 @@ import {
 	RUNNABLE_REASONS,
 	shouldReplay,
 } from "./autostart.js";
+import { consumeQuiet } from "../../lib/quiet.js";
 import { registerAutostart } from "./index.js";
 
 describe("parseAutostartConfig", () => {
@@ -145,7 +146,10 @@ type SessionStartHandler = (
 		cwd: string;
 		isProjectTrusted: () => boolean;
 		ui: { notify: (message: string, type?: string) => void };
-		sessionManager: { buildContextEntries: () => Array<{ type: string }> };
+		sessionManager: {
+			buildContextEntries: () => Array<{ type: string }>;
+			getSessionId: () => string;
+		};
 	},
 ) => Promise<void>;
 
@@ -156,9 +160,11 @@ interface Harness {
 	notifications: Array<{ message: string; type?: string }>;
 	commands: Array<{ name: string; source: string }>;
 	failCommands: Set<string>;
+	quietAtDispatch: Array<{ command: string; quiet: boolean }>;
 	setTrusted(trusted: boolean): void;
 	/** Simulate a session that already had a conversation (resumed process). */
 	setHistory(entries: Array<{ type: string }>): void;
+	setSessionId(id: string): void;
 	start(reason: string): Promise<void>;
 }
 
@@ -190,13 +196,16 @@ async function makeHarness(
 		{ type: "model_change" },
 		{ type: "thinking_level_change" },
 	];
+	let sessionId = "session-1";
 	let handler: SessionStartHandler = async () => {};
 	const sent: Harness["sent"] = [];
 	const notifications: Harness["notifications"] = [];
 	const commands: Harness["commands"] = [
 		{ name: "add-dir", source: "extension" },
 		{ name: "ask", source: "extension" },
+		{ name: "ask-perm", source: "extension" },
 	];
+	const quietAtDispatch: Harness["quietAtDispatch"] = [];
 	const failCommands = new Set<string>();
 	const pi = {
 		on: (event: string, h: SessionStartHandler) => {
@@ -208,6 +217,7 @@ async function makeHarness(
 			options?: { expandPromptTemplates?: boolean },
 		) => {
 			sent.push({ command, options }); // records attempts, including failures
+			quietAtDispatch.push({ command, quiet: consumeQuiet("ask-perm") });
 			if (failCommands.has(command)) {
 				return Promise.reject(new Error("boom"));
 			}
@@ -217,6 +227,7 @@ async function makeHarness(
 	return {
 		handler,
 		sent,
+		quietAtDispatch,
 		notifications,
 		commands,
 		failCommands,
@@ -226,6 +237,9 @@ async function makeHarness(
 		setHistory(entries) {
 			history = entries;
 		},
+		setSessionId(id) {
+			sessionId = id;
+		},
 		async start(reason: string) {
 			await handler({ reason }, {
 				cwd,
@@ -235,7 +249,10 @@ async function makeHarness(
 						notifications.push({ message, type });
 					},
 				},
-				sessionManager: { buildContextEntries: () => history },
+				sessionManager: {
+					buildContextEntries: () => history,
+					getSessionId: () => sessionId,
+				},
 			});
 		},
 		cwd,
@@ -286,6 +303,8 @@ describe("registerAutostart", () => {
 	it("replays on new and fork", async () => {
 		const h = await harness('[command]\nrun = ["/ask on"]');
 		await h.start("new");
+		// A fork is a different session, so it replays again.
+		h.setSessionId("forked-session");
 		await h.start("fork");
 		expect(h.sent).toEqual([
 			{ command: "/ask on", options: { expandPromptTemplates: true } },
@@ -302,6 +321,36 @@ describe("registerAutostart", () => {
 		expect(h.notifications).toEqual([]);
 	});
 
+	it("marks our own command quiet for the dispatch and clears the mark", async () => {
+		const h = await harness('[command]\nrun = ["/ask-perm allow"]');
+		await h.start("startup");
+		expect(h.quietAtDispatch).toEqual([
+			{ command: "/ask-perm allow", quiet: true },
+		]);
+		expect(consumeQuiet("ask-perm")).toBe(false);
+	});
+
+	it("leaves other extensions' commands unmarked", async () => {
+		const h = await harness(fullConfig);
+		await h.start("startup");
+		expect(h.quietAtDispatch.every((entry) => entry.quiet === false)).toBe(true);
+	});
+
+	it("replays once per session even if session_start is emitted twice", async () => {
+		const h = await harness(fullConfig);
+		await h.start("startup");
+		await h.start("startup");
+		expect(h.sent).toHaveLength(2);
+	});
+
+	it("replays again for a new session id", async () => {
+		const h = await harness(fullConfig);
+		await h.start("startup");
+		h.setSessionId("session-2");
+		await h.start("startup");
+		expect(h.sent).toHaveLength(4);
+	});
+
 	it("skips a process started on an existing session (pi -c reports startup)", async () => {
 		const h = await harness(fullConfig);
 		h.setHistory([

package/src/features/autostart/index.ts

@@ -40,6 +40,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { clearQuiet, markQuiet } from "../../lib/quiet.js";
 import {
 	AUTOSTART_CONFIG_PATH,
 	AutostartParseError,
@@ -87,6 +88,15 @@ const HISTORY_ENTRY_TYPES: ReadonlySet<string> = new Set([
  * session manager counts as new, which keeps the feature working in hosts where
  * the session surface is unavailable.
  */
+/** Session id, or `undefined` when the host exposes none. */
+function sessionIdOf(ctx: ExtensionContext): string | undefined {
+	try {
+		return ctx.sessionManager.getSessionId();
+	} catch {
+		return undefined;
+	}
+}
+
 function hasConversationHistory(ctx: ExtensionContext): boolean {
 	try {
 		return ctx.sessionManager
@@ -102,6 +112,11 @@ export function registerAutostart(
 	options: AutostartOptions = {},
 ): void {
 	const agentDir = options.agentDir ?? getAgentDir();
+	// One replay per session. The host can emit `session_start` more than once
+	// for the same session (a runtime rebind during startup reports `startup`
+	// again), and replaying on the second emission would announce everything
+	// twice.
+	const replayedSessions = new Set<string>();
 
 	async function readCommands(
 		ctx: ExtensionContext,
@@ -140,6 +155,12 @@ export function registerAutostart(
 		// shouldReplay in autostart.ts for the host-side evidence.
 		if (!shouldReplay(event.reason, hasConversationHistory(ctx))) return;
 
+		const sessionId = sessionIdOf(ctx);
+		if (sessionId !== undefined) {
+			if (replayedSessions.has(sessionId)) return;
+			replayedSessions.add(sessionId);
+		}
+
 		const sources: Source[] = [
 			{
 				path: join(agentDir, GLOBAL_AUTOSTART_FILENAME),
@@ -193,6 +214,12 @@ export function registerAutostart(
 				}
 				if (dispatched.has(command)) continue;
 				dispatched.add(command);
+				// Our own commands stay silent on startup: the host keeps every
+				// info notice and re-renders old lines with the newest text, so a
+				// second info notice after another extension's warning would show
+				// the same message twice (see lib/quiet.ts).
+				const quiet = name === "ask-perm";
+				if (quiet) markQuiet(name);
 				// One failing command must not cancel the rest of the list.
 				try {
 					await pi.sendUserMessage(command, { expandPromptTemplates: true });
@@ -201,6 +228,8 @@ export function registerAutostart(
 						`autostart: "${command}" failed — ${messageOf(err)}`,
 						"error",
 					);
+				} finally {
+					if (quiet) clearQuiet(name);
 				}
 			}
 		}

package/src/features/permission/index.test.ts

@@ -15,6 +15,7 @@ import type {
 	ToolCallEvent,
 } from "@earendil-works/pi-coding-agent";
 import type { AskDecision, GateHub, ToolGate } from "../../lib/gates.js";
+import { markQuiet } from "../../lib/quiet.js";
 import { registerPermission } from "./index.js";
 
 function bashEvent(command: string): ToolCallEvent {
@@ -51,6 +52,7 @@ interface Harness {
 	readonly statuses: Array<[string, string | undefined]>;
 	readonly notes: Array<{ message: string; kind?: string }>;
 	readonly branch: Array<Record<string, unknown>>;
+	setSessionId(id: string): void;
 	evaluate(event: ToolCallEvent): Promise<unknown>;
 	command(args: string): Promise<void>;
 	sessionStart(): Promise<void>;
@@ -62,6 +64,7 @@ function makeHarness(): Harness {
 	const statuses: Harness["statuses"] = [];
 	const notes: Harness["notes"] = [];
 	const branch: Harness["branch"] = [];
+	let sessionId = "session-1";
 	const ctx = {
 		cwd,
 		hasUI: true,
@@ -73,7 +76,10 @@ function makeHarness(): Harness {
 			custom: async () => undefined,
 			select: async () => undefined,
 		},
-		sessionManager: { getBranch: () => branch },
+		sessionManager: {
+			getBranch: () => branch,
+			getSessionId: () => sessionId,
+		},
 	} as unknown as ExtensionContext;
 
 	const captured: ToolGate[] = [];
@@ -110,6 +116,9 @@ function makeHarness(): Harness {
 		statuses,
 		notes,
 		branch,
+		setSessionId(id: string) {
+			sessionId = id;
+		},
 		async evaluate(event) {
 			return gate.evaluate(event, ctx);
 		},
@@ -214,6 +223,25 @@ describe("/ask-perm", () => {
 		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).toBeUndefined();
 	});
 
+	it("keeps the state when the same session emits session_start again", async () => {
+		const h = makeHarness();
+		await h.sessionStart(); // the real first emission
+		await h.command("allow allow allow ask");
+		// A startup rebind reports the same session again; state must survive.
+		await h.sessionStart();
+		expect(asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).kind).toBe(
+			"ask",
+		);
+	});
+
+	it("resets on session_start for a different session", async () => {
+		const h = makeHarness();
+		await h.command("allow allow allow ask");
+		h.setSessionId("session-2");
+		await h.sessionStart();
+		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).toBeUndefined();
+	});
+
 	it("resets on session_start", async () => {
 		const h = makeHarness();
 		await h.command("allow allow allow ask");
@@ -269,6 +297,25 @@ describe("/ask-perm", () => {
 		expect(await h.evaluate(customEvent("mcp"))).toBeUndefined();
 	});
 
+	it("suppresses the chat notice when autostart started the command", async () => {
+		const h = makeHarness();
+		markQuiet("ask-perm");
+		await h.command("allow allow allow ask");
+		// The footer carries the state; the chat stays quiet at startup.
+		expect(h.notes).toHaveLength(0);
+		expect(h.statuses.at(-1)?.[1]).toContain("perm");
+		expect(asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).kind).toBe(
+			"ask",
+		);
+	});
+
+	it("still reports an invalid argument from autostart", async () => {
+		const h = makeHarness();
+		markQuiet("ask-perm");
+		await h.command("deny");
+		expect(h.notes.at(-1)?.kind).toBe("error");
+	});
+
 	it("is idempotent: repeating the same command notifies once and keeps grants", async () => {
 		const h = makeHarness();
 		await h.command("allow allow allow ask");

package/src/features/permission/index.ts

@@ -22,6 +22,7 @@ import type {
 	ToolCallEvent,
 } from "@earendil-works/pi-coding-agent";
 import type { AskRequest, GateHub } from "../../lib/gates.js";
+import { consumeQuiet } from "../../lib/quiet.js";
 import {
 	DEFAULT_MODES,
 	type PermissionModes,
@@ -99,6 +100,10 @@ function toolUnit(
 export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 	let enabled = false;
 	let modes: PermissionModes = { ...DEFAULT_MODES };
+	// Session this state belongs to. A runtime rebind can emit `session_start`
+	// again for the same session; resetting then would wipe a mode that the
+	// autostart replay had just enabled, so only a different session resets.
+	let currentSessionId: string | undefined;
 	const rules = new SessionRules();
 	let rootsCache:
 		| { cwd: string; branchLength: number; roots: string[] }
@@ -111,6 +116,15 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 		rootsCache = undefined;
 	}
 
+	/** Session id, or `undefined` when the host exposes none. */
+	function sessionIdOf(ctx: ExtensionContext): string | undefined {
+		try {
+			return ctx.sessionManager.getSessionId();
+		} catch {
+			return undefined;
+		}
+	}
+
 	function syncStatus(ctx: ExtensionContext): void {
 		if (!enabled) {
 			ctx.ui.setStatus(PERMISSION_STATUS_KEY, undefined);
@@ -233,12 +247,16 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 	// ── Lifecycle ──────────────────────────────────────────────────────────
 
 	pi.on("session_start", (_event, ctx) => {
+		const sessionId = sessionIdOf(ctx);
+		// Same session, repeated emission (a startup rebind): keep the state.
+		if (sessionId !== undefined && sessionId === currentSessionId) {
+			syncStatus(ctx);
+			return;
+		}
+		currentSessionId = sessionId;
 		reset();
 		syncStatus(ctx);
 	});
-	pi.on("session_shutdown", () => {
-		reset();
-	});
 
 	// ── Command ────────────────────────────────────────────────────────────
 
@@ -246,12 +264,21 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 		description:
 			"Toggle permission checks; with arguments: /ask-perm [in-read] [in-write] [out-read] [out-write]",
 		handler: async (args, ctx) => {
+			// Started by autostart: the footer status is the notice (lib/quiet.ts).
+			const quietNotice = consumeQuiet("ask-perm");
+			const notify = (
+				message: string,
+				type: "info" | "warning" | "error" = "info",
+			): void => {
+				if (type === "info" && quietNotice) return;
+				ctx.ui.notify(message, type);
+			};
 			const raw = args.trim();
 
 			if (raw !== "") {
 				const parsed = parsePermissionArgs(raw);
 				if ("error" in parsed) {
-					ctx.ui.notify(`ask-perm: ${parsed.error}`, "error");
+					notify(`ask-perm: ${parsed.error}`, "error");
 					return;
 				}
 				// Idempotent: the same command may arrive twice in one session start
@@ -266,7 +293,7 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 				if (changed) rules.clear();
 				enabled = true;
 				syncStatus(ctx);
-				ctx.ui.notify(
+				notify(
 					`Permission ON — ${formatModes(modes)}. /ask-perm to turn off.`,
 					"info",
 				);
@@ -277,7 +304,7 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 				enabled = false;
 				rules.clear();
 				syncStatus(ctx);
-				ctx.ui.notify(
+				notify(
 					"Permission OFF — no boundary checks in this session.",
 					"info",
 				);
@@ -286,7 +313,7 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 
 			const chosen = await openPermissionPanel(ctx, modes);
 			if (!chosen) {
-				ctx.ui.notify(
+				notify(
 					"ask-perm: cancelled. Use /ask-perm allow allow allow ask to enable from the argument form.",
 					"info",
 				);
@@ -297,7 +324,7 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 			rules.clear();
 			enabled = true;
 			syncStatus(ctx);
-			ctx.ui.notify(
+			notify(
 				`Permission ON — ${formatModes(modes)}. /ask-perm to turn off.`,
 				"info",
 			);

package/src/lib/quiet.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { clearQuiet, consumeQuiet, markQuiet } from "./quiet.js";
+
+describe("quiet handoff", () => {
+	it("consumes a mark exactly once", () => {
+		markQuiet("ask-perm");
+		expect(consumeQuiet("ask-perm")).toBe(true);
+		expect(consumeQuiet("ask-perm")).toBe(false);
+	});
+
+	it("ignores other commands", () => {
+		markQuiet("ask-perm");
+		expect(consumeQuiet("third-review")).toBe(false);
+		expect(consumeQuiet("ask-perm")).toBe(true);
+	});
+
+	it("can be cleared without a consumer", () => {
+		markQuiet("ask-perm");
+		clearQuiet("ask-perm");
+		expect(consumeQuiet("ask-perm")).toBe(false);
+	});
+});

package/src/lib/quiet.ts

@@ -0,0 +1,35 @@
+/**
+ * Quiet handoff for commands dispatched by autostart.
+ *
+ * The host's interactive status line keeps every info notice in the chat, but
+ * each line renders one shared "last status message" field
+ * (`interactive-mode.js#showStatus`: `new ThemedText(() => ... this.lastStatusMessage)`).
+ * A warning emitted between two info notices breaks the coalescing, so a second
+ * info notice creates a new line — and *both* lines then render the newest
+ * text. The visible result is the same message twice, separated by the warning.
+ *
+ * That is a host display quirk, not a second execution. Startup replay is the
+ * worst case: `/add-dir` (info) → `/lens-toggle` (warning) → `/ask-perm` (info)
+ * shows "Permission ON" twice. Autostart therefore marks the commands it
+ * dispatches as quiet, and our own commands skip the chat notice when they were
+ * started that way. The footer status still reflects the new state.
+ *
+ * The mark is keyed by command name and is always cleared by the dispatcher
+ * (`finally`), so it cannot leak into a later manual invocation.
+ */
+const quietCommands = new Set<string>();
+
+/** Mark `commandName` as dispatched by autostart (no chat notice). */
+export function markQuiet(commandName: string): void {
+	quietCommands.add(commandName);
+}
+
+/** Drop a mark whether or not the command consumed it. */
+export function clearQuiet(commandName: string): void {
+	quietCommands.delete(commandName);
+}
+
+/** `true` once, when the command was marked quiet; consumes the mark. */
+export function consumeQuiet(commandName: string): boolean {
+	return quietCommands.delete(commandName);
+}