@andares/pi-toolkits 0.9.2 → 0.9.3

package/package.json

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

@@ -145,7 +145,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>;
 
@@ -159,6 +162,7 @@ interface Harness {
 	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,6 +194,7 @@ 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"] = [];
@@ -226,6 +231,9 @@ async function makeHarness(
 		setHistory(entries) {
 			history = entries;
 		},
+		setSessionId(id) {
+			sessionId = id;
+		},
 		async start(reason: string) {
 			await handler({ reason }, {
 				cwd,
@@ -235,7 +243,10 @@ async function makeHarness(
 						notifications.push({ message, type });
 					},
 				},
-				sessionManager: { buildContextEntries: () => history },
+				sessionManager: {
+					buildContextEntries: () => history,
+					getSessionId: () => sessionId,
+				},
 			});
 		},
 		cwd,
@@ -286,6 +297,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 +315,21 @@ describe("registerAutostart", () => {
 		expect(h.notifications).toEqual([]);
 	});
 
+	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

@@ -87,6 +87,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 +111,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 +154,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),

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

@@ -51,6 +51,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 +63,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 +75,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 +115,9 @@ function makeHarness(): Harness {
 		statuses,
 		notes,
 		branch,
+		setSessionId(id: string) {
+			sessionId = id;
+		},
 		async evaluate(event) {
 			return gate.evaluate(event, ctx);
 		},
@@ -214,6 +222,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");

package/src/features/permission/index.ts

@@ -99,6 +99,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 +115,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 +246,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 ────────────────────────────────────────────────────────────