@andares/pi-toolkits 0.9.0 → 0.9.2

package/README.md

@@ -106,6 +106,8 @@ Enter with `/ask` (press it again to exit). Meant for the case where you only wa
 - `/ask-perm allow allow allow ask` — positional form (`in-read in-write out-read out-write`), enables immediately without a dialog. Missing arguments fall back to the defaults. This is the form autostart uses.
 - `/ask-perm` again — turns it off.
 
+Repeating the argument form with the modes already in force is a **no-op**: no second "ON" notice and no loss of the session grants collected so far. Changing any mode notifies and clears those grants, because they were made under the old policy.
+
 **Defaults**: in-project read/write allowed, outside read allowed, outside write asks.
 
 | Scope | reads | writes / exec |
@@ -307,15 +309,20 @@ No file = feature disabled, zero overhead, silently skipped.
 
 The global list runs first, so a project can override an earlier setting (for example a later `/ask-perm` with different arguments). Use the global file only when you want the same commands in every project; per-project files remain the recommended default.
 
+An **identical command line** declared by both sources runs once: a duplicate is skipped for that replay, so a global `/ask-perm ...` copied into a project does not run (or announce itself) twice. Different commands still both run, which is what keeps a project override working.
+
 **When it runs**:
 
 | session_start reason | Replayed | Why |
 | --- | --- | --- |
-| `startup` / `new` | ✅ | a new session, replay as declared |
-| `fork` | ✅ | the branch point may predate the config's appearance |
-| `resume` | ❌ | the restored branch already carries the mount state from its time, replaying would conflict |
+| `startup` / `new`, empty session | ✅ | a new session, replay as declared |
+| `startup` on a session that already has history | ❌ | that is a process started on an existing session (`pi -c` / `-r` / `--session` / `--fork`), and its branch already carries the state a replay would rebuild |
+| `fork` (in-process) | ✅ | the branch point may predate the config's appearance |
+| `resume` (in-process `/resume`) | ❌ | the restored branch already carries the mount state from its time, replaying would conflict |
 | `reload` | ❌ | extensions are rebuilt, replaying would duplicate side effects |
 
+> The `startup` split is not cosmetic: pi reports `startup` for **every** process start, including one that opens an existing session. `resume` is emitted only for in-process session switches, never for `pi -c`. Lines 1–2 of the table are therefore decided by the session's content (does it already hold a message?), not by the reason alone.
+
 **Safety gates** (in order):
 
 1. **project trust** — no command runs automatically in an untrusted directory (a warning is shown); a config parse failure likewise prevents execution (an error is shown)

package/README.zh-CN.md

@@ -106,6 +106,8 @@ pi -e ./src/index.ts
 - `/ask-perm allow allow allow ask` —— 位置参数形式(`in-read in-write out-read out-write`),不弹窗直接开启;没给全的参数回落到默认值。这也是 autostart 使用的形式
 - 再输入一次 `/ask-perm` —— 关闭
 
+参数形式重复执行、且四项模式与当前一致时是**空操作**:不会再出一条「ON」提示,也不会清掉已经攒下的会话授权。只有模式真的变了才会提示并清空授权——那些授权是按旧策略给的。
+
 **默认值**:项目内读/写全放行,项目外读放行,项目外写询问。
 
 | 作用域 | 读 | 写 / 执行 |
@@ -307,15 +309,20 @@ run = [
 
 全局列表先执行,项目列表后执行,因此项目可以覆盖此前的设置(例如后面再执行一条不同参数的 `/ask-perm`)。只有希望所有项目都用同一套命令时才用全局文件;仍然建议以项目级配置为主。
 
+**完全相同的命令行**若同时出现在两个来源,一次重放里只执行一次:重复项跳过,所以把全局的 `/ask-perm ...` 复制到项目里不会再跑一遍、也不会再提示一遍。不同的命令仍然各跑一次——这正是「项目覆盖全局」得以成立的原因。
+
 **执行时机**:
 
 | session_start reason | 是否重放 | 原因 |
 | --- | --- | --- |
-| `startup` / `new` | ✅ | 新会话,按声明重放 |
-| `fork` | ✅ | 分支点可能早于配置出现 |
-| `resume` | ❌ | 恢复的分支已携带当时的挂载状态,重放反而会冲突 |
+| `startup` / `new`,空会话 | ✅ | 新会话,按声明重放 |
+| `startup`,但会话已有历史 | ❌ | 这是「进程启动即带着旧会话」(`pi -c` / `-r` / `--session` / `--fork`),其分支已携带重放本该重建的状态 |
+| `fork`(进程内) | ✅ | 分支点可能早于配置出现 |
+| `resume`(进程内 `/resume`) | ❌ | 恢复的分支已携带当时的挂载状态,重放反而会冲突 |
 | `reload` | ❌ | 扩展重建,重放会重复副作用 |
 
+> `startup` 这一行为什么要拆开:pi 对**每一次进程启动**都报 `startup`,包括「启动即打开旧会话」的情形;`resume` 只在进程内切换会话时发出,`pi -c` 永远不会报它。所以前两行的判定依据是**会话内容**(是否已有消息),不能只看 reason。
+
 **安全门**(按序):
 
 1. **project trust** —— 未信任目录不自动执行任何命令(warning 提示);配置解析失败同样不执行(error 提示)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andares/pi-toolkits",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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

@@ -19,6 +19,7 @@ import {
 	GLOBAL_AUTOSTART_FILENAME,
 	parseAutostartConfig,
 	RUNNABLE_REASONS,
+	shouldReplay,
 } from "./autostart.js";
 import { registerAutostart } from "./index.js";
 
@@ -112,6 +113,28 @@ describe("RUNNABLE_REASONS", () => {
 	});
 });
 
+describe("shouldReplay", () => {
+	it("replays a genuinely new session", () => {
+		expect(shouldReplay("startup", false)).toBe(true);
+		expect(shouldReplay("new", false)).toBe(true);
+	});
+
+	it("skips a startup that already has history (a resumed process)", () => {
+		// `pi -c`, `-r`, `--session` and `--fork` all report `startup` for a
+		// session that already carries history.
+		expect(shouldReplay("startup", true)).toBe(false);
+	});
+
+	it("replays a fork even though the branch has history", () => {
+		expect(shouldReplay("fork", true)).toBe(true);
+	});
+
+	it("skips in-process resume and reload", () => {
+		expect(shouldReplay("resume", true)).toBe(false);
+		expect(shouldReplay("reload", true)).toBe(false);
+	});
+});
+
 /* ------------------------------------------------------------------ */
 /* registerAutostart integration (mocked pi surface)                   */
 /* ------------------------------------------------------------------ */
@@ -122,6 +145,7 @@ type SessionStartHandler = (
 		cwd: string;
 		isProjectTrusted: () => boolean;
 		ui: { notify: (message: string, type?: string) => void };
+		sessionManager: { buildContextEntries: () => Array<{ type: string }> };
 	},
 ) => Promise<void>;
 
@@ -133,6 +157,8 @@ interface Harness {
 	commands: Array<{ name: string; source: string }>;
 	failCommands: Set<string>;
 	setTrusted(trusted: boolean): void;
+	/** Simulate a session that already had a conversation (resumed process). */
+	setHistory(entries: Array<{ type: string }>): void;
 	start(reason: string): Promise<void>;
 }
 
@@ -158,6 +184,12 @@ async function makeHarness(
 		await writeFile(join(cwd, AUTOSTART_CONFIG_PATH), config, "utf8");
 	}
 	let trusted = true;
+	// Boot-level entries every session has; a resumed session adds messages.
+	let history: Array<{ type: string }> = [
+		{ type: "session" },
+		{ type: "model_change" },
+		{ type: "thinking_level_change" },
+	];
 	let handler: SessionStartHandler = async () => {};
 	const sent: Harness["sent"] = [];
 	const notifications: Harness["notifications"] = [];
@@ -191,6 +223,9 @@ async function makeHarness(
 		setTrusted(value: boolean) {
 			trusted = value;
 		},
+		setHistory(entries) {
+			history = entries;
+		},
 		async start(reason: string) {
 			await handler({ reason }, {
 				cwd,
@@ -200,6 +235,7 @@ async function makeHarness(
 						notifications.push({ message, type });
 					},
 				},
+				sessionManager: { buildContextEntries: () => history },
 			});
 		},
 		cwd,
@@ -266,6 +302,38 @@ describe("registerAutostart", () => {
 		expect(h.notifications).toEqual([]);
 	});
 
+	it("skips a process started on an existing session (pi -c reports startup)", async () => {
+		const h = await harness(fullConfig);
+		h.setHistory([
+			{ type: "session" },
+			{ type: "model_change" },
+			{ type: "message" },
+		]);
+		await h.start("startup");
+		expect(h.sent).toEqual([]);
+		expect(h.notifications).toEqual([]);
+	});
+
+	it("still replays when the session holds only boot-level entries", async () => {
+		const h = await harness(fullConfig);
+		h.setHistory([
+			{ type: "session" },
+			{ type: "model_change" },
+			{ type: "thinking_level_change" },
+			{ type: "session_info" },
+			{ type: "custom" },
+		]);
+		await h.start("startup");
+		expect(h.sent).toHaveLength(2);
+	});
+
+	it("replays a fork of a session that has history", async () => {
+		const h = await harness(fullConfig);
+		h.setHistory([{ type: "message" }]);
+		await h.start("fork");
+		expect(h.sent).toHaveLength(2);
+	});
+
 	it("silently skips when no config file exists", async () => {
 		const h = await harness(null);
 		await h.start("startup");
@@ -350,6 +418,29 @@ describe("registerAutostart", () => {
 		expect(h.notifications[0]?.type).toBe("warning");
 	});
 
+	it("runs an identical command only once across sources", async () => {
+		const h = await harness(
+			"[command]\nrun = [\"/ask on\"]",
+			false,
+			"[command]\nrun = [\"/ask on\"]",
+		);
+		await h.start("startup");
+		expect(h.sent.map((entry) => entry.command)).toEqual(["/ask on"]);
+	});
+
+	it("still runs different commands from both sources", async () => {
+		const h = await harness(
+			"[command]\nrun = [\"/ask on\", \"/add-dir ../p\"]",
+			false,
+			"[command]\nrun = [\"/ask on\"]",
+		);
+		await h.start("startup");
+		expect(h.sent.map((entry) => entry.command)).toEqual([
+			"/ask on",
+			"/add-dir ../p",
+		]);
+	});
+
 	it("keeps running the project config when the global one is absent", async () => {
 		const h = await harness('[command]\nrun = ["/ask on"]', false, null);
 		await h.start("startup");

package/src/features/autostart/autostart.ts

@@ -41,6 +41,30 @@ export const RUNNABLE_REASONS: ReadonlySet<string> = new Set([
 	"fork",
 ]);
 
+/**
+ * Whether this session start should replay the command lists.
+ *
+ * The reason alone is not enough at process start. `pi -c` (`--continue`),
+ * `-r` (`--resume`), `--session <path>` and `--fork <path>` all open an
+ * existing session *before* the first runtime exists, and that runtime is
+ * created without an explicit session_start event, so extensions see pi's
+ * default reason — `startup` — not `resume` (verified on pi 1.0.0–1.3.0:
+ * `main.js` builds the initial session manager from those flags and calls
+ * `createAgentSessionRuntime` with no `sessionStartEvent`;
+ * `agent-session.js` defaults it to `{ reason: "startup" }`). `resume` is only
+ * emitted for in-process session switches, never for a resumed process.
+ *
+ * So the session content decides: a `startup` on a session that already has
+ * conversation history is a resumed (or forked) process, and its branch already
+ * carries the state a replay would rebuild. `hasHistory` is the same signal pi
+ * itself uses to recognise an existing session
+ * (`buildSessionContext().messages.length > 0`).
+ */
+export function shouldReplay(reason: string, hasHistory: boolean): boolean {
+	if (reason === "startup") return !hasHistory;
+	return RUNNABLE_REASONS.has(reason);
+}
+
 /** Parse/validation failure with a user-facing message. */
 export class AutostartParseError extends Error {}
 

package/src/features/autostart/index.ts

@@ -12,7 +12,9 @@
  *
  * Execution gates, in order:
  *
- *  - reason filter — only startup/new/fork replay (see RUNNABLE_REASONS)
+ *  - reason filter — see `shouldReplay`: startup/new/fork replay, but a
+ *    `startup` that already carries conversation history is a process started
+ *    on an existing session (`pi -c`/`-r`/`--session`/`--fork`) and does not
  *  - config file exists — a missing file is a silent opt-in skip
  *  - project trust (project source only)
  *  - per-command pre-validation against `pi.getCommands()`: only commands
@@ -44,7 +46,7 @@ import {
 	commandNameOf,
 	GLOBAL_AUTOSTART_FILENAME,
 	parseAutostartConfig,
-	RUNNABLE_REASONS,
+	shouldReplay,
 } from "./autostart.js";
 
 export interface AutostartOptions {
@@ -63,6 +65,38 @@ function messageOf(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
+/**
+ * Entry types that prove the session already held a conversation.
+ *
+ * `buildContextEntries()` returns the active branch's entries including the
+ * boot-level ones (`session`, `model_change`, `thinking_level_change`), so
+ * presence alone is not enough — a brand-new session has those too.
+ */
+const HISTORY_ENTRY_TYPES: ReadonlySet<string> = new Set([
+	"message",
+	"custom_message",
+	"compaction",
+	"branch_summary",
+]);
+
+/**
+ * Whether the session already carries conversation history.
+ *
+ * This is how a `startup` on an existing session (a resumed process) is told
+ * apart from a genuinely new one — see {@link shouldReplay}. An unreadable
+ * session manager counts as new, which keeps the feature working in hosts where
+ * the session surface is unavailable.
+ */
+function hasConversationHistory(ctx: ExtensionContext): boolean {
+	try {
+		return ctx.sessionManager
+			.buildContextEntries()
+			.some((entry) => HISTORY_ENTRY_TYPES.has(entry.type));
+	} catch {
+		return false;
+	}
+}
+
 export function registerAutostart(
 	pi: ExtensionAPI,
 	options: AutostartOptions = {},
@@ -101,7 +135,10 @@ export function registerAutostart(
 	}
 
 	pi.on("session_start", async (event, ctx) => {
-		if (!RUNNABLE_REASONS.has(event.reason)) return;
+		// `pi -c` / `-r` / `--session` / `--fork` report `startup` for a session
+		// that already has history; the content is what tells them apart. See
+		// shouldReplay in autostart.ts for the host-side evidence.
+		if (!shouldReplay(event.reason, hasConversationHistory(ctx))) return;
 
 		const sources: Source[] = [
 			{
@@ -126,6 +163,13 @@ export function registerAutostart(
 				),
 		);
 
+		// The same line may be declared by both sources (global defaults plus a
+		// project copy). Running an identical command twice in one replay is
+		// never meaningful — a repeated `/ask-perm` would re-notify, and a
+		// repeated `/add-dir` is pure noise — so identical text runs once.
+		// Different commands still both run, which keeps the project's override.
+		const dispatched = new Set<string>();
+
 		for (const source of sources) {
 			const commands = await readCommands(ctx, source);
 			if (commands === undefined || commands.length === 0) continue;
@@ -147,6 +191,8 @@ export function registerAutostart(
 					);
 					continue;
 				}
+				if (dispatched.has(command)) continue;
+				dispatched.add(command);
 				// One failing command must not cancel the rest of the list.
 				try {
 					await pi.sendUserMessage(command, { expandPromptTemplates: true });

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

@@ -269,15 +269,30 @@ describe("/ask-perm", () => {
 		expect(await h.evaluate(customEvent("mcp"))).toBeUndefined();
 	});
 
-	it("clears session grants when the mode is reconfigured", async () => {
+	it("is idempotent: repeating the same command notifies once and keeps grants", async () => {
 		const h = makeHarness();
 		await h.command("allow allow allow ask");
+		expect(h.notes).toHaveLength(1);
+
 		asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/x"))).request.apply(
 			"allow-session",
 		);
+		await h.command("allow allow allow ask");
+		expect(h.notes).toHaveLength(1);
+		// The grant collected before the repeat is still in force.
 		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).toBeUndefined();
+	});
 
+	it("notifies and clears session grants when the modes actually change", async () => {
+		const h = makeHarness();
 		await h.command("allow allow allow ask");
+		asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/x"))).request.apply(
+			"allow-session",
+		);
+		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).toBeUndefined();
+
+		await h.command("ask allow allow ask");
+		expect(h.notes).toHaveLength(2);
 		expect(asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).kind).toBe("ask");
 	});
 });

package/src/features/permission/index.ts

@@ -31,6 +31,7 @@ import {
 import {
 	formatModes,
 	parsePermissionArgs,
+	sameModes,
 	shortMode,
 } from "./modes.js";
 import { openPermissionPanel } from "./panel.js";
@@ -253,9 +254,16 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 					ctx.ui.notify(`ask-perm: ${parsed.error}`, "error");
 					return;
 				}
+				// Idempotent: the same command may arrive twice in one session start
+				// (both autostart sources declaring it, a duplicated config line, …).
+				// Re-applying an unchanged policy is a no-op — no second "ON" notice,
+				// and no loss of the session grants collected so far.
+				if (enabled && sameModes(modes, parsed.modes)) return;
+
+				const changed = !sameModes(modes, parsed.modes);
 				modes = parsed.modes;
-				// A new policy invalidates grants made under the old one.
-				rules.clear();
+				// A changed policy invalidates grants made under the old one.
+				if (changed) rules.clear();
 				enabled = true;
 				syncStatus(ctx);
 				ctx.ui.notify(
@@ -284,7 +292,9 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 				);
 				return;
 			}
+			// The panel only opens while off, so this always transitions on.
 			modes = chosen;
+			rules.clear();
 			enabled = true;
 			syncStatus(ctx);
 			ctx.ui.notify(

package/src/features/permission/modes.ts

@@ -80,3 +80,13 @@ export function shortMode(mode: TriMode | "allow"): string {
 			return "D";
 	}
 }
+
+/** Structural equality for the four modes. */
+export function sameModes(a: PermissionModes, b: PermissionModes): boolean {
+	return (
+		a.inRead === b.inRead &&
+		a.inWrite === b.inWrite &&
+		a.outRead === b.outRead &&
+		a.outWrite === b.outWrite
+	);
+}