@arhen/pi-core-subagent 1.3.65 → 1.3.66

package/README.md

@@ -327,9 +327,12 @@ still applies Pi\'s global script-only policy; this extension does not override
 - `/subagents mode codemode` — explicitly select script-based routing (direct fallback when unavailable).
 - `/subagents mode direct` — return to legacy direct behavior.
 
-Choice is stored per session branch. New sessions/branches without a preference start direct;
-existing explicit choices remain intact. Published 1.3.63 defaulted to `auto`: this compatibility
-correction requires the corrected source/package, not a retroactive change to that npm release.
+Choice is stored globally in `~/.pi/agent/subagents-config.json` (the same file as `auto-limit`,
+written with a merge, never a clobber) and applies to every session — reload, resume, fork and tree
+navigation included. Sessions that chose a mode before the preference moved into that file keep their
+branch entry only while the config has no `mode`; the built-in default is still `direct`. Published
+1.3.63 defaulted to `auto`: this compatibility correction requires the corrected source/package, not
+a retroactive change to that npm release.
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.65",
+	"version": "1.3.66",
 	"type": "module",
 	"description": "pi extension: fast in-process subagents with a dependency-graph scheduler (needs edges gate tasks and carry upstream output into dependent prompts), plus background runs, intercom and agent-to-agent mailbox. Leader defines agents inline.",
 	"license": "MIT",

package/src/config.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Shared user config for the extension: exposure mode plus the auto-limit ceiling. One file, so a
+ * write of one key must never drop the other — every writer merges through `writeSubagentConfig`.
+ */
+export const SUBAGENT_CONFIG_FILENAME = "subagents-config.json";
+
+/**
+ * Presentation preference for the subagent toolset, stored globally in `subagents-config.json`.
+ * - auto: native codemode presentation when the codemode tool is active, direct otherwise.
+ * - direct (default): legacy native declarations and active-tool script callability.
+ * - codemode: subagent tools are callable from codemode scripts but not declared or listed.
+ */
+export type SubagentMode = "auto" | "direct" | "codemode";
+
+export const DEFAULT_SUBAGENT_MODE: SubagentMode = "direct";
+
+export function isSubagentMode(value: unknown): value is SubagentMode {
+	return value === "auto" || value === "direct" || value === "codemode";
+}
+
+/** Resolved per call, so a test or `PI_CODING_AGENT_DIR` override applies to the running process. */
+export function subagentConfigPath(): string {
+	return join(getAgentDir(), SUBAGENT_CONFIG_FILENAME);
+}
+
+/**
+ * Tolerant read: a missing, unreadable or non-object file degrades to an empty object, so a config
+ * typo can neither break delegation nor hide the built-in defaults.
+ */
+export function readSubagentConfig(path = subagentConfigPath()): Record<string, unknown> {
+	try {
+		const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+		return raw as Record<string, unknown>;
+	} catch {
+		return {};
+	}
+}
+
+/** The stored exposure mode, or undefined when the file has no usable one. */
+export function readStoredMode(path = subagentConfigPath()): SubagentMode | undefined {
+	const mode = readSubagentConfig(path).mode;
+	return isSubagentMode(mode) ? mode : undefined;
+}
+
+let writeQueue: Promise<unknown> = Promise.resolve();
+
+/** Read-modify-write on a single queue, so concurrent writers of different keys cannot clobber each other. */
+export function writeSubagentConfig(patch: Record<string, unknown>, path = subagentConfigPath()): Promise<void> {
+	const write = writeQueue.then(async () => {
+		await writeFile(path, `${JSON.stringify({ ...readSubagentConfig(path), ...patch }, null, 2)}\n`);
+	});
+	writeQueue = write.catch(() => {});
+	return write;
+}

package/src/index.ts

@@ -92,7 +92,7 @@ export default function (pi: ExtensionAPI) {
 	};
 	pi.registerCommand("subagents", {
 		description:
-			"List subagent runs. `/subagents peek` opens the browsable pane; `/subagents mode [auto|direct|codemode]` reports or switches the tool exposure profile; `/subagents auto-limit on|off` toggles the 1 h default runtime ceiling (default off = 6 h).",
+			"List subagent runs. `/subagents peek` opens the browsable pane; `/subagents mode [auto|direct|codemode]` reports or switches the globally stored tool exposure profile; `/subagents auto-limit on|off` toggles the 1 h default runtime ceiling (default off = 6 h).",
 		handler: async (args, ctx) => {
 			const arg = String(args ?? "")
 				.trim()

package/src/manager.ts

@@ -23,6 +23,7 @@ import {
 import type { TUI } from "@earendil-works/pi-tui";
 import { resolveAgentFile } from "./agentfile.ts";
 import { CHILD_TALK_TOOLS, type ChildHandlers, createChildTools } from "./child.ts";
+import { readSubagentConfig, writeSubagentConfig } from "./config.ts";
 import {
 	activitySnippet,
 	describeCall,
@@ -368,16 +369,14 @@ export class SubagentManager {
 
 	constructor(private readonly pi: ExtensionAPI) {
 		try {
-			const cfg = JSON.parse(readFileSync(join(getAgentDir(), "subagents-config.json"), "utf8"));
+			const cfg = readSubagentConfig();
 			if (typeof cfg.autoLimit === "boolean") this.autoLimit = cfg.autoLimit;
 		} catch {}
 	}
 
 	setAutoLimit(on: boolean): boolean {
 		this.autoLimit = on;
-		void writeFile(join(getAgentDir(), "subagents-config.json"), JSON.stringify({ autoLimit: on }, null, 2)).catch(
-			() => {},
-		);
+		void writeSubagentConfig({ autoLimit: on }).catch(() => {});
 		return on;
 	}
 

package/src/presentation.ts

@@ -7,17 +7,18 @@ import type {
 	ToolLoadoutChanges,
 	ToolNamespace,
 } from "@earendil-works/pi-coding-agent";
-
-/**
- * Presentation preference for the subagent toolset.
- * - auto: native codemode presentation when the codemode tool is active, direct otherwise.
- * - direct (default): legacy native declarations and active-tool script callability.
- * - codemode: subagent tools are callable from codemode scripts but not declared or listed.
- */
-export type SubagentMode = "auto" | "direct" | "codemode";
+import {
+	DEFAULT_SUBAGENT_MODE,
+	isSubagentMode,
+	readStoredMode,
+	type SubagentMode,
+	writeSubagentConfig,
+} from "./config.ts";
+
+export { isSubagentMode, type SubagentMode } from "./config.ts";
 export type EffectiveMode = "direct" | "codemode";
 
-/** Branch-scoped custom entry holding the preference, so resume/tree keep it. */
+/** Branch-scoped custom entry holding the legacy preference; the global config file now wins. */
 export const MODE_ENTRY_TYPE = "subagent-mode";
 export const CODEMODE_TOOL_NAME = "codemode";
 
@@ -30,7 +31,7 @@ export const SUBAGENT_NAMESPACE: ToolNamespace = {
 - direct (default): legacy native tool declarations and active-tool script callability; activating codemode alone does not switch profiles.
 - auto (opt-in): codemode presentation while the \`codemode\` tool is active, direct otherwise.
 - codemode: active tools are callable from scripts but not declared; inactive tools stay model-only and are not callable at all.
-Switch with \`/subagents mode auto|direct|codemode\`. The preference is stored on the session branch and restored on reload, resume and tree navigation.
+Switch with \`/subagents mode auto|direct|codemode\`. The preference is stored in the global \`subagents-config.json\` and applies to every session — reload, resume and tree navigation included.
 
 ## Operations
 Object arguments, exactly as validated when issued by the model:
@@ -67,10 +68,6 @@ export const CODEMODE_DISCOVERY_GUIDELINE =
 /** The full-reference pointer only resolves while codemode scripts can reach `describeNamespace`. */
 const NAMESPACE_REFERENCE = / Full reference: `describeNamespace\('subagents'\)`\./;
 
-export function isSubagentMode(value: unknown): value is SubagentMode {
-	return value === "auto" || value === "direct" || value === "codemode";
-}
-
 export type AnyToolDefinition = ToolDefinition<any, any, any>;
 
 export interface Presentation {
@@ -82,7 +79,7 @@ export interface Presentation {
 	/** Report preference, effective mode and codemode availability. */
 	describe(): string;
 	setPreference(mode: SubagentMode): void;
-	/** Restore the latest preference stored on the session branch. */
+	/** Restore the globally stored preference, with the session branch as the legacy fallback. */
 	restore(ctx: ExtensionContext): void;
 	/** Register the tools for the current effective mode; no-op when already applied. */
 	sync(): boolean;
@@ -90,6 +87,17 @@ export interface Presentation {
 	registerInitial(): void;
 }
 
+/** Latest mode stored by an older package version on this session branch, if any. */
+function branchPreference(ctx: ExtensionContext): SubagentMode | undefined {
+	let restored: SubagentMode | undefined;
+	for (const entry of ctx.sessionManager.getBranch()) {
+		const candidate = entry as { type?: string; customType?: string; data?: { mode?: unknown } };
+		if (candidate.type === "custom" && candidate.customType === MODE_ENTRY_TYPE && isSubagentMode(candidate.data?.mode))
+			restored = candidate.data.mode;
+	}
+	return restored;
+}
+
 /**
  * Owns the subagent exposure profile. Tools stay registered while only their exposure changes, so
  * the active selection (and the running manager) is preserved across mode switches.
@@ -169,25 +177,19 @@ export function createPresentation(pi: ExtensionAPI, definitions: readonly AnyTo
 			const availability = available ? "codemode is active" : "codemode is not active";
 			const fallback = !available && preference === "codemode" ? "; using direct fallback" : "";
 			const pending = target !== shown ? `; pending ${target} at the next request boundary` : "";
-			return `Subagent exposure: mode ${preference} → effective ${shown} (${availability}${fallback}${pending}). Use /subagents mode auto|direct|codemode.`;
+			return `Subagent exposure: mode ${preference} → effective ${shown} (${availability}${fallback}${pending}). Saved for all sessions. Use /subagents mode auto|direct|codemode.`;
 		},
 		setPreference(mode) {
 			preference = mode;
+			// The global config file is authoritative for every session; the branch entry stays as a
+			// fallback for sessions that predate it and for readers of older package versions.
+			void writeSubagentConfig({ mode }).catch(() => {});
 			pi.appendEntry(MODE_ENTRY_TYPE, { mode });
 		},
 		restore(ctx) {
-			let restored: SubagentMode | undefined;
-			for (const entry of ctx.sessionManager.getBranch()) {
-				const candidate = entry as { type?: string; customType?: string; data?: { mode?: unknown } };
-				if (
-					candidate.type === "custom" &&
-					candidate.customType === MODE_ENTRY_TYPE &&
-					isSubagentMode(candidate.data?.mode)
-				)
-					restored = candidate.data.mode;
-			}
-			// Branch-sensitive state: a branch without an entry uses the package default again.
-			preference = restored ?? "direct";
+			// Global preference wins over the branch; the branch entry is the legacy fallback for
+			// sessions that chose a mode before the preference moved into the config file.
+			preference = readStoredMode() ?? branchPreference(ctx) ?? DEFAULT_SUBAGENT_MODE;
 		},
 		sync() {
 			const own = new Set(ownNames());