@selesai/code 0.8.6 → 0.8.7

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to `@selesai/code` will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.7] - 2026-08-17
+
+### Added
+- **Pi Subagents updated through upstream 0.50.0.** The bundled extension advances through upstream 0.49/0.50 (single-child `{ agent, task }` runs, per-tool-call `toolTimeoutMs` with config/env precedence, `debug.run` inspection, builtin role overrides with `tools: "inherit"`, resumable retained-child listings, indexed async result inboxes) with the Selesai fork layers on top: branding, `.selesai` config routing, `SELESAI_SUBAGENT*` env vars, declarative `chain`/`tasks`/`clarify` modes, workflow auto-relaunch wiring, and same-model retry for transient provider errors.
+- **`model-prompt-injector` extension.** Bundled and registered in the extensions manifest, it injects model-specific prompts into the system prompt when the active model matches a configured rule (provider/model globs, bare id/name patterns, first-match-wins, enabled toggle). Modes: `prepend`, `append`, or `replace`.
+- **Wire-level tool schema pruning.** `pruneToolDescriptions` (default `true`) strips every per-field `description` from tool input schemas before they reach the model, keeping one-line tool descriptions. Stripped schemas are memoized and never mutated; UI/docs definitions keep full descriptions; `keepParameterDescriptions` opts a tool out.
+- **Compact subagent tool description by default.** `toolDescriptionMode` now defaults to `"compact"` (~3.2 KB vs ~6.3 KB per model turn), and a missing/invalid custom description file falls back to compact.
+
+### Changed
+- **Slimmer default system prompt.** The always-on Pi-docs block shrank from 8 lines to 2 (paths only); docs are still read on demand when the user asks about pi.
+- **Bundled defaults** now set `pruneToolDescriptions: true`.
+- **Test coverage.** `src/extensions` (pi-* excluded) now enforces 100% stmt/branch/func/line coverage via vitest thresholds; `safeMaxTokens()` clamps missing/oversized context-window metadata to a sane default.
+
+### Fixed
+- **Subagent prompt-runtime suite passes inside subagent child environments.** The watchdog-lifecycle test now scrubs the steer env vars (`SELESAI_SUBAGENT_STEER_*`) before registering, so the steering inbox's extra `agent_end` handler cannot skew the handler count.
+
 ## [0.8.6] - 2026-08-15
 
 ### Added

package/dist/core/agent-session.js

@@ -35,7 +35,7 @@ import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-man
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
-import { createAllToolDefinitions } from "./tools/index.js";
+import { createAllToolDefinitions, stripToolParameterDescriptions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
 /** Parse consecutive skill blocks at the start of a user message. */
@@ -2056,6 +2056,18 @@ export class AgentSession {
             toolRegistry.set(tool.name, tool);
         }
         this._toolRegistry = toolRegistry;
+        if (this.settingsManager.getPruneToolDescriptions()) {
+            const keepDescriptions = new Set();
+            for (const [name, entry] of definitionRegistry) {
+                if (entry.definition.keepParameterDescriptions)
+                    keepDescriptions.add(name);
+            }
+            for (const [name, tool] of toolRegistry) {
+                if (!keepDescriptions.has(name)) {
+                    toolRegistry.set(name, stripToolParameterDescriptions(tool));
+                }
+            }
+        }
         const nextActiveToolNames = (options?.activeToolNames ? [...options.activeToolNames] : [...previousActiveToolNames]).filter((name) => isAllowedTool(name));
         if (allowedToolNames) {
             for (const toolName of this._toolRegistry.keys()) {

package/dist/core/extensions/types.d.ts

@@ -353,6 +353,8 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
     promptGuidelines?: string[];
     /** Parameter schema (TypeBox) */
     parameters: TParams;
+    /** When global pruneToolDescriptions is enabled, keep this tool's per-field parameter descriptions on the wire (already pruned by the tool itself). */
+    keepParameterDescriptions?: boolean;
     /** Optional provider-side constrained sampling request for this tool. Set false to explicitly disable it, equivalent to leaving it undefined. */
     constrainedSampling?: false | ConstrainedSamplingConfig;
     /** Controls whether ToolExecutionComponent renders the standard colored shell or the tool renders its own framing. */

package/dist/core/provider-composer.js

@@ -2,6 +2,17 @@ import { lazyStream, } from "@earendil-works/pi-ai";
 import { getApiProvider } from "@earendil-works/pi-ai/compat";
 import { clearConfigValueCache, getConfigValueEnvVarNames, isCommandConfigValue, isConfigValueConfigured, resolveConfigValueOrThrow, resolveHeadersOrThrow, } from "./resolve-config-value.js";
 export const clearApiKeyCache = clearConfigValueCache;
+/** Sane default when a model definition omits maxTokens (kept small so providers never reject it). */
+const DEFAULT_MAX_TOKENS = 16384;
+/**
+ * Resolve a safe max output token count. Missing or non-positive values fall back
+ * (to a sane default or an inherited value); explicit values are never allowed to
+ * exceed the model's context window.
+ */
+function safeMaxTokens(value, contextWindow, fallback = DEFAULT_MAX_TOKENS) {
+    const resolved = typeof value === "number" && value > 0 ? value : fallback;
+    return Math.min(resolved, Math.max(contextWindow, 1));
+}
 function mergeCompat(base, override) {
     if (!override)
         return base;
@@ -20,6 +31,7 @@ function mergeCompat(base, override) {
     return merged;
 }
 function applyModelOverride(model, override) {
+    const contextWindow = override.contextWindow ?? model.contextWindow;
     return {
         ...model,
         name: override.name ?? model.name,
@@ -37,8 +49,8 @@ function applyModelOverride(model, override) {
                 tiers: override.cost.tiers ?? model.cost.tiers,
             }
             : model.cost,
-        contextWindow: override.contextWindow ?? model.contextWindow,
-        maxTokens: override.maxTokens ?? model.maxTokens,
+        contextWindow,
+        maxTokens: safeMaxTokens(override.maxTokens ?? model.maxTokens, contextWindow, model.maxTokens),
         compat: mergeCompat(model.compat, override.compat),
     };
 }
@@ -56,6 +68,7 @@ function modelFromJson(providerId, definition, providerConfig, defaults) {
     if (definition.maxTokens !== undefined && definition.maxTokens <= 0) {
         throw new Error(`Provider ${providerId}, model ${definition.id}: invalid maxTokens`);
     }
+    const contextWindow = definition.contextWindow ?? 128000;
     return {
         id: definition.id,
         name: definition.name ?? definition.id,
@@ -66,8 +79,8 @@ function modelFromJson(providerId, definition, providerConfig, defaults) {
         thinkingLevelMap: definition.thinkingLevelMap,
         input: (definition.input ?? ["text"]),
         cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: definition.contextWindow ?? 128000,
-        maxTokens: definition.maxTokens ?? 16384,
+        contextWindow,
+        maxTokens: safeMaxTokens(definition.maxTokens, contextWindow),
         headers: undefined,
         compat: mergeCompat(providerConfig.compat, definition.compat),
     };

package/dist/core/settings-manager.d.ts

@@ -77,6 +77,7 @@ export interface Settings {
     branchSummary?: BranchSummarySettings;
     retry?: RetrySettings;
     hideThinkingBlock?: boolean;
+    pruneToolDescriptions?: boolean;
     showCacheMissNotices?: boolean;
     externalEditor?: string;
     shellPath?: string;
@@ -236,6 +237,7 @@ export declare class SettingsManager {
     };
     getWebSocketConnectTimeoutMs(): number | undefined;
     getHideThinkingBlock(): boolean;
+    getPruneToolDescriptions(): boolean;
     getShowCacheMissNotices(): boolean;
     getExternalEditorCommand(): string;
     setHideThinkingBlock(hide: boolean): void;

package/dist/core/settings-manager.js

@@ -598,6 +598,9 @@ export class SettingsManager {
     getHideThinkingBlock() {
         return this.settings.hideThinkingBlock ?? false;
     }
+    getPruneToolDescriptions() {
+        return this.settings.pruneToolDescriptions ?? true;
+    }
     getShowCacheMissNotices() {
         return this.settings.showCacheMissNotices ?? false;
     }

package/dist/core/system-prompt.js

@@ -103,14 +103,8 @@ In addition to the tools above, you may have access to other custom tools depend
 Guidelines:
 ${guidelines}
 
-Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
-- Main documentation: ${readmePath}
-- Additional docs: ${docsPath}
-- Examples: ${examplesPath} (extensions, custom tools, SDK)
-- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
-- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md), environment variables (docs/environment-variables.md)
-- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
-- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI): main docs ${readmePath}, additional docs ${docsPath}, examples ${examplesPath}.
+When working on pi topics, resolve docs/... and examples/... under those paths (not cwd), read the relevant .md files completely, and follow cross-references before implementing.`;
     if (appendSection) {
         prompt += appendSection;
     }

package/dist/core/system-prompt.test.js

@@ -12,6 +12,12 @@ describe("buildSystemPrompt", () => {
         expect(prompt).toMatch(/Guidelines:/);
         expect(prompt).toContain("Current working directory: /tmp/project");
     });
+    it("keeps the collapsed Pi-docs block without the per-topic filename map", () => {
+        const prompt = buildSystemPrompt({ cwd: "/tmp/project" });
+        expect(prompt).toContain("Pi documentation");
+        expect(prompt).not.toContain("When asked about:");
+        expect(prompt).not.toContain("(docs/extensions.md");
+    });
     it("keeps the default tool snippets, skills, and agents XML read-gated", () => {
         const skill = {
             name: "test-skill",

package/dist/core/tools/index.d.ts

@@ -5,6 +5,7 @@ export { createFindTool, createFindToolDefinition, type FindOperations, type Fin
 export { createGrepTool, createGrepToolDefinition, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, } from "./grep.ts";
 export { createLsTool, createLsToolDefinition, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, } from "./ls.ts";
 export { createReadTool, createReadToolDefinition, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, } from "./read.ts";
+export { stripSchemaDescriptions, stripToolParameterDescriptions, } from "./schema-prune.ts";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.ts";
 export { createWriteTool, createWriteToolDefinition, type WriteOperations, type WriteToolInput, type WriteToolOptions, } from "./write.ts";
 import type { AgentTool } from "@earendil-works/pi-agent-core";

package/dist/core/tools/index.js

@@ -5,6 +5,7 @@ export { createFindTool, createFindToolDefinition, } from "./find.js";
 export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
+export { stripSchemaDescriptions, stripToolParameterDescriptions, } from "./schema-prune.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
 import { createBashTool, createBashToolDefinition } from "./bash.js";

package/dist/core/tools/schema-prune.d.ts

@@ -0,0 +1,16 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { TSchema } from "typebox";
+/**
+ * Structural deep clone that omits every `description` key at any depth while
+ * preserving all other own keys (including TypeBox internals such as `~kind`
+ * and `~optional` symbols and function-valued keys). Uses Reflect.ownKeys +
+ * property descriptors so non-enumerable metadata survives; never mutates the
+ * input.
+ */
+export declare function stripSchemaDescriptions<T>(value: T): T;
+/**
+ * Returns a shallow copy of the tool with its parameter schema descriptions
+ * stripped. Top-level tool fields (name, description, execute, ...) are
+ * untouched.
+ */
+export declare function stripToolParameterDescriptions<T extends TSchema>(tool: AgentTool<T>): AgentTool<T>;

package/dist/core/tools/schema-prune.js

@@ -0,0 +1,39 @@
+// Memoized stripped clones, keyed by the original schema root. The input is
+// never mutated; repeat calls return the same cached clone.
+const strippedSchemaCache = new WeakMap();
+/**
+ * Structural deep clone that omits every `description` key at any depth while
+ * preserving all other own keys (including TypeBox internals such as `~kind`
+ * and `~optional` symbols and function-valued keys). Uses Reflect.ownKeys +
+ * property descriptors so non-enumerable metadata survives; never mutates the
+ * input.
+ */
+export function stripSchemaDescriptions(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    const cached = strippedSchemaCache.get(value);
+    if (cached !== undefined)
+        return cached;
+    const result = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            continue;
+        if (key === "description")
+            continue;
+        if ("value" in descriptor) {
+            descriptor.value = stripSchemaDescriptions(descriptor.value);
+        }
+        Object.defineProperty(result, key, descriptor);
+    }
+    strippedSchemaCache.set(value, result);
+    return result;
+}
+/**
+ * Returns a shallow copy of the tool with its parameter schema descriptions
+ * stripped. Top-level tool fields (name, description, execute, ...) are
+ * untouched.
+ */
+export function stripToolParameterDescriptions(tool) {
+    return { ...tool, parameters: stripSchemaDescriptions(tool.parameters) };
+}

package/dist/core/tools/schema-prune.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/tools/schema-prune.test.js

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { SettingsManager } from "../settings-manager.js";
+import { stripSchemaDescriptions, stripToolParameterDescriptions } from "./schema-prune.js";
+describe("stripSchemaDescriptions", () => {
+    it("removes description keys at all depths (properties, anyOf arrays, items)", () => {
+        const schema = {
+            type: "object",
+            description: "root",
+            properties: {
+                name: { type: "string", description: "the name" },
+                tags: {
+                    type: "array",
+                    description: "the tags",
+                    items: { type: "string", description: "a tag" },
+                },
+                choice: {
+                    anyOf: [{ type: "string", description: "string branch" }, { type: "number" }],
+                },
+            },
+        };
+        const stripped = stripSchemaDescriptions(schema);
+        expect("description" in stripped).toBe(false);
+        expect("description" in stripped.properties).toBe(false);
+        expect("description" in stripped.properties.tags).toBe(false);
+        expect("description" in stripped.properties.tags.items).toBe(false);
+        expect("description" in stripped.properties.choice.anyOf[0]).toBe(false);
+    });
+    it("preserves non-description keys such as type, enum, required, minimum, additionalProperties", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                level: { type: "string", enum: ["a", "b"], description: "level desc" },
+                count: { type: "integer", minimum: 1, description: "count desc" },
+            },
+            required: ["level"],
+            additionalProperties: false,
+        };
+        const stripped = stripSchemaDescriptions(schema);
+        expect(stripped).toEqual({
+            type: "object",
+            properties: {
+                level: { type: "string", enum: ["a", "b"] },
+                count: { type: "integer", minimum: 1 },
+            },
+            required: ["level"],
+            additionalProperties: false,
+        });
+    });
+    it("never mutates the input schema", () => {
+        const schema = {
+            type: "object",
+            properties: { name: { type: "string", description: "the name" } },
+        };
+        const snapshot = structuredClone(schema);
+        stripSchemaDescriptions(schema);
+        expect(schema).toEqual(snapshot);
+        expect(schema.properties.name.description).toBe("the name");
+    });
+    it("memoizes stripped clones per original root", () => {
+        const schema = {
+            type: "object",
+            properties: { name: { type: "string", description: "the name" } },
+        };
+        const first = stripSchemaDescriptions(schema);
+        const second = stripSchemaDescriptions(schema);
+        expect(first).toBe(second);
+    });
+    it("keeps real TypeBox schemas valid after stripping (symbols survive)", () => {
+        const schema = Type.Object({
+            name: Type.String({ description: "the name" }),
+            age: Type.Optional(Type.Integer({ minimum: 0, description: "the age" })),
+        });
+        const stripped = stripSchemaDescriptions(schema);
+        expect(Value.Check(schema, { name: "pi", age: 3 })).toBe(true);
+        expect(Value.Check(stripped, { name: "pi", age: 3 })).toBe(true);
+        expect(Value.Check(stripped, { name: "pi", age: -1 })).toBe(false);
+    });
+});
+describe("stripToolParameterDescriptions", () => {
+    it("keeps the tool description and name while stripping parameter descriptions", () => {
+        const tool = {
+            name: "read",
+            label: "Read",
+            description: "Read a file",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string", description: "file path" } },
+            },
+            execute: () => Promise.resolve({ content: [], details: {} }),
+        };
+        const stripped = stripToolParameterDescriptions(tool);
+        expect(stripped).not.toBe(tool);
+        expect(stripped.name).toBe("read");
+        expect(stripped.description).toBe("Read a file");
+        expect("description" in stripped.parameters.properties.path).toBe(false);
+        // Original tool is untouched.
+        expect("description" in tool.parameters.properties.path).toBe(true);
+    });
+});
+describe("pruneToolDescriptions setting", () => {
+    it("defaults to true", () => {
+        const manager = SettingsManager.inMemory();
+        expect(manager.getPruneToolDescriptions()).toBe(true);
+    });
+    it("respects explicit true and false", () => {
+        expect(SettingsManager.inMemory({ pruneToolDescriptions: true }).getPruneToolDescriptions()).toBe(true);
+        expect(SettingsManager.inMemory({ pruneToolDescriptions: false }).getPruneToolDescriptions()).toBe(false);
+    });
+});

package/dist/defaults/settings.json

@@ -25,6 +25,7 @@
     "git:github.com/MasuRii/pi-tool-display",
     "git:github.com/omaclaren/pi-markdown-preview"
   ],
+  "pruneToolDescriptions": true,
   "quietStartup": true,
   "retry": {
     "enabled": true,

package/dist/extensions/model-prompt-injector/config.json

@@ -0,0 +1,10 @@
+{
+  "rules": [
+    {
+      "match": ["deepseek-v4-pro"],
+      "mode": "prepend",
+      "prompt": "text: You are a helpful software engineer assistant.\n\ndescription: Bootstrap with shell/read, then expose the full Standard tool catalog after the first durable tool call.\n\nwhen you thought, start with `we need...`",
+      "enabled": true
+    }
+  ]
+}

package/dist/extensions/model-prompt-injector/index.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ExtensionAPI } from "@selesai/code";
+import modelPromptInjector, {
+	findRule,
+	patternMatches,
+	type InjectConfig,
+	type InjectRule,
+	type ModelRef,
+} from "./index.ts";
+
+const model = (provider: string, id: string, name = id): ModelRef => ({ provider, id, name });
+
+function harness(config: InjectConfig, activeModel: ModelRef | undefined) {
+	const handlers: Record<string, Function> = {};
+	const pi = {
+		on: vi.fn((event: string, handler: Function) => {
+			handlers[event] = handler;
+		}),
+	} as unknown as ExtensionAPI;
+	const ctx = {
+		model: activeModel,
+		ui: { setStatus: vi.fn() },
+	};
+	modelPromptInjector(pi, config);
+	return { handlers, ctx };
+}
+
+describe("patternMatches", () => {
+	it("matches provider/model exactly, case-insensitively", () => {
+		expect(patternMatches("deepseek/deepseek-v4-pro", model("DeepSeek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(false);
+	});
+
+	it("supports wildcards in provider and id", () => {
+		expect(patternMatches("*/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-chat"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("openai", "gpt-5"))).toBe(false);
+	});
+
+	it("bare patterns match id or display name", () => {
+		expect(patternMatches("deepseek-v4-pro", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("gpt-*", model("openai", "gpt-5", "GPT-5"))).toBe(true);
+		expect(patternMatches("deepseek*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+	});
+
+	it("matches * against any model", () => {
+		expect(patternMatches("*", model("openai", "gpt-5"))).toBe(true);
+	});
+});
+
+describe("findRule", () => {
+	const rules: InjectRule[] = [
+		{ match: ["deepseek/*"], prompt: "A" },
+		{ match: ["*/deepseek-v4-pro"], prompt: "B" },
+		{ match: ["*"], prompt: "C", enabled: false },
+	];
+
+	it("first matching rule wins", () => {
+		expect(findRule(rules, model("deepseek", "deepseek-v4-pro"))?.prompt).toBe("A");
+		expect(findRule(rules, model("openrouter", "deepseek-v4-pro"))?.prompt).toBe("B");
+	});
+
+	it("skips disabled rules", () => {
+		expect(findRule([{ match: ["*"], prompt: "C", enabled: false }], model("openai", "gpt-5"))).toBeUndefined();
+	});
+});
+
+describe("before_agent_start", () => {
+	it("appends the rule prompt to the system prompt", async () => {
+		const { handlers, ctx } = harness({ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] }, model("deepseek", "deepseek-chat"));
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "BASE\n\nEXTRA" });
+	});
+
+	it("prepends the rule prompt to the top of the system prompt", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "TOP", mode: "prepend" }] },
+			model("deepseek", "deepseek-chat"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "TOP\n\nBASE" });
+	});
+
+	it("replaces the system prompt in replace mode", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "ONLY ME", mode: "replace" }] },
+			model("deepseek", "deepseek-chat"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "ONLY ME" });
+	});
+
+	it("returns undefined when no rule matches", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] },
+			model("openai", "gpt-5"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toBeUndefined();
+	});
+});
+
+describe("model_select", () => {
+	it("shows status when the selected model matches, clears otherwise", async () => {
+		const { handlers, ctx } = harness({ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] }, undefined);
+		await handlers["model_select"]({ model: model("deepseek", "deepseek-chat") }, ctx);
+		expect(ctx.ui.setStatus).toHaveBeenLastCalledWith("model-prompt-injector", "prompt-inject: active");
+		await handlers["model_select"]({ model: model("openai", "gpt-5") }, ctx);
+		expect(ctx.ui.setStatus).toHaveBeenLastCalledWith("model-prompt-injector", undefined);
+	});
+});

package/dist/extensions/model-prompt-injector/index.ts

@@ -0,0 +1,151 @@
+/**
+ * model-prompt-injector
+ *
+ * Injects a model-specific prompt into the system prompt whenever the active
+ * model matches a rule in config.json (sibling of this file).
+ *
+ * Config lives only here in host code — nothing is exposed to user settings.
+ * `/reload` re-reads it.
+ *
+ * config.json format:
+ * {
+ *   "rules": [
+ *     {
+ *       "match": ["provider/model", "provider/*", "<any>/model", "bare-name", "*"],
+ *       "mode": "prepend" | "append" | "replace",   // default: "append"
+ *       "prompt": "...",
+ *       "enabled": true                 // default: true
+ *     }
+ *   ]
+ * }
+ *
+ * Matching (case-insensitive, "*" is a wildcard):
+ * - "provider/model" — glob against `<provider>/<id>`.
+ * - bare pattern (no "/") — glob against model id OR display name.
+ * - First matching rule wins; later rules are ignored.
+ * - mode "prepend" puts the prompt at the very top of the system prompt;
+ *   mode "append" adds it to the end; mode "replace" replaces the whole system prompt.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@selesai/code";
+
+export type InjectMode = "prepend" | "append" | "replace";
+
+export interface InjectRule {
+	match: string[];
+	prompt: string;
+	mode?: InjectMode;
+	enabled?: boolean;
+}
+
+export interface InjectConfig {
+	rules: InjectRule[];
+}
+
+/** Model shape needed for matching (structurally compatible with pi's Model). */
+export interface ModelRef {
+	provider: string;
+	id: string;
+	name: string;
+}
+
+const CONFIG_PATH = join(dirname(fileURLToPath(import.meta.url)), "config.json");
+
+function globToRegex(glob: string): RegExp {
+	const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`, "i");
+}
+
+export function patternMatches(pattern: string, model: ModelRef): boolean {
+	const slash = pattern.indexOf("/");
+	if (slash >= 0) {
+		return (
+			globToRegex(pattern.slice(0, slash)).test(model.provider) &&
+			globToRegex(pattern.slice(slash + 1)).test(model.id)
+		);
+	}
+	return globToRegex(pattern).test(model.id) || globToRegex(pattern).test(model.name);
+}
+
+export function findRule(rules: readonly InjectRule[], model: ModelRef): InjectRule | undefined {
+	for (const rule of rules) {
+		if (rule.enabled === false) continue;
+		if (rule.match.some((pattern) => patternMatches(pattern, model))) return rule;
+	}
+	return undefined;
+}
+
+export function loadConfig(path: string = CONFIG_PATH): InjectConfig {
+	const fail = (message: string): InjectConfig => {
+		console.error(`[model-prompt-injector] ${message}`);
+		return { rules: [] };
+	};
+
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		return fail(`cannot load ${path}: ${(error as Error).message}`);
+	}
+
+	if (typeof raw !== "object" || raw === null || !Array.isArray((raw as { rules?: unknown }).rules)) {
+		return fail(`invalid config: expected { "rules": [...] }`);
+	}
+
+	const rules: InjectRule[] = [];
+	for (const [index, entry] of (raw as { rules: unknown[] }).rules.entries()) {
+		const label = `rule #${index + 1}`;
+		if (typeof entry !== "object" || entry === null) {
+			console.error(`[model-prompt-injector] ${label} is not an object — skipped`);
+			continue;
+		}
+		const rule = entry as Partial<InjectRule>;
+		if (!Array.isArray(rule.match) || rule.match.length === 0 || !rule.match.every((m) => typeof m === "string")) {
+			console.error(`[model-prompt-injector] ${label} needs a non-empty "match" string array — skipped`);
+			continue;
+		}
+		if (typeof rule.prompt !== "string" || rule.prompt.trim() === "") {
+			console.error(`[model-prompt-injector] ${label} needs a non-empty "prompt" string — skipped`);
+			continue;
+		}
+		if (rule.mode !== undefined && rule.mode !== "prepend" && rule.mode !== "append" && rule.mode !== "replace") {
+			console.error(`[model-prompt-injector] ${label}: "mode" must be "prepend", "append" or "replace" — skipped`);
+			continue;
+		}
+		rules.push({
+			match: rule.match,
+			prompt: rule.prompt,
+			mode: rule.mode ?? "append",
+			enabled: rule.enabled ?? true,
+		});
+	}
+	return { rules };
+}
+
+export default function modelPromptInjector(pi: ExtensionAPI, config: InjectConfig = loadConfig()) {
+	const ruleFor = (model: ModelRef | undefined): InjectRule | undefined =>
+		model ? findRule(config.rules, model) : undefined;
+
+	const active = config.rules.filter((rule) => rule.enabled !== false);
+	if (active.length > 0) {
+		console.log(
+			`[model-prompt-injector] ${active.length} rule(s) active: ${active
+				.map((rule) => rule.match.join(","))
+				.join(" | ")}`,
+		);
+	}
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		const rule = ruleFor(ctx.model);
+		if (!rule) return;
+		if (rule.mode === "replace") return { systemPrompt: rule.prompt };
+		if (rule.mode === "prepend") return { systemPrompt: `${rule.prompt}\n\n${event.systemPrompt}` };
+		return { systemPrompt: `${event.systemPrompt}\n\n${rule.prompt}` };
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		ctx.ui.setStatus("model-prompt-injector", ruleFor(event.model) ? "prompt-inject: active" : undefined);
+	});
+}