pi-ui-extend 0.1.41 → 0.1.44

package/dist/app/cli/update.js

@@ -1,13 +1,11 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
 const DEFAULT_UPDATE_TIMEOUT_MS = 10_000;
 const NPM_REGISTRY_URL = "https://registry.npmjs.org";
 const PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-const requireFromUpdateModule = createRequire(import.meta.url);
 const defaultPixUpdateDeps = {
     checkPixUpdate,
     runCommand,
@@ -237,10 +235,22 @@ function findPixPackageRoot() {
     }
 }
 function findPiPackageRoot(pixPackageRoot = readPixPackageInfo().packageRoot) {
-    const packageJsonPath = requireFromUpdateModule.resolve(`${PI_PACKAGE_NAME}/package.json`, {
-        paths: [pixPackageRoot],
-    });
-    return dirname(packageJsonPath);
+    // `@earendil-works/pi-coding-agent` does not expose "./package.json" in its
+    // `exports` map, so a CJS `require.resolve(... + "/package.json")` throws
+    // ERR_PACKAGE_PATH_NOT_EXPORTED. Resolve the bare entrypoint via ESM
+    // (matching command-session-actions.ts) and walk up to the nearest package.json.
+    const resolvedDir = dirname(fileURLToPath(import.meta.resolve(PI_PACKAGE_NAME, pathToFileURL(`${pixPackageRoot}/`).href)));
+    let currentDir = resolvedDir;
+    while (true) {
+        const packageJsonPath = join(currentDir, "package.json");
+        if (existsSync(packageJsonPath))
+            return currentDir;
+        const nextDir = dirname(currentDir);
+        if (nextDir === currentDir) {
+            throw new Error(`Could not find ${PI_PACKAGE_NAME} package.json from ${resolvedDir}`);
+        }
+        currentDir = nextDir;
+    }
 }
 async function fetchLatestNpmVersion(packageName, currentVersion, timeoutMs) {
     const response = await fetch(`${NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/latest`, {

package/external/pi-tools-suite/README.md

@@ -4,7 +4,7 @@ Local all-in-one Pi extension package.
 
 This package keeps shared Pi tools as ordinary source folders under `src/` and registers them through one entrypoint.
 
-- `src/coding-discipline` — injects a deduplicated silent-mode and quality-discipline block at the very top of the main-session per-turn system prompt for all main-session models immediately before the LLM request; disabled for async sub-agents
+- `src/coding-discipline` — injects a deduplicated silent-mode and quality-discipline block at the very top of the main-session per-turn system prompt for GLM main-session models only (`isGlmModel`) immediately before the LLM request; non-GLM models are left untouched; disabled for async sub-agents
 - `src/ast-grep` — `ast_grep` / `ast_apply`
 - `src/async-subagents` — `subagents` tool and sub-agent slash commands, including oh-my-openagent-style `/ultrawork` (`/ulw`) and `/hyperplan` orchestration prompts, plus config-defined sub-agent model/thinking/args presets selected via `/subagent-preset` from `asyncSubagents` in `~/.config/pi/pi-tools-suite.jsonc`; includes the `frontend` profile for Gemini-friendly UI/UX and visual frontend work and the `oracle` profile for cross-provider second opinions; enforces a 30-minute per-agent execution timeout, project-wide `maxConcurrent` queueing, optional retry/backoff, and `result.json` structured metadata/chaining fields next to raw `result.md`; stores project-local run files and a registry under `.pi/subagents/` so result/status collection can recover after compaction or reload while the main session remains alive
 - `src/lsp` — shared LSP diagnostics hook/library that enriches mutating tool results with diagnostics and shuts down language servers on session shutdown
@@ -18,10 +18,11 @@ This package keeps shared Pi tools as ordinary source folders under `src/` and r
 - `src/web-search` — `web_search` and `web_fetch` tools migrated from `@ollama/pi-web-search`; calls the local Ollama experimental web search/fetch APIs, honors `OLLAMA_HOST`, supports request timeouts via `timeout_ms` / `PI_WEB_SEARCH_TIMEOUT_MS`, and reports targeted `ollama signin`, unsupported-endpoint, invalid-response, timeout, DNS, and Ollama-not-running errors
 - `src/dcp` — headless Dynamic Context Pruning ported from `opencode-dynamic-context-pruning` for the Pi SDK: explicit `compress` tool with range and message modes, `/dcp` commands (context, stats, sweep, manual, decompress, recompress, compress), same-call overlap validation, recoverable compressed-block rollups, grouped message-mode skip diagnostics, stable raw-message anchors when available, protected user/tool preservation, deduplication, error purging, and context nudges; visualization is left to `compress` tool responses and the renderer-owned context-percent click dialog
 - `src/prompt-commands` — user slash-command builder: `/prompt-commands` opens a CRUD menu for saved prompt-backed slash commands, stores them under `promptCommands` in `~/.config/pi/pi-tools-suite.jsonc`, reloads after edits, and runs each saved prompt as a normal user message
+- `src/skill-installer` — `/install-skill [name]` installs a personal skill folder from `~/.agents/local_skills` into the current project's `.pi/skills/` so it activates as a project-local skill, then automatically runs `/reload` so the new skill is picked up without a manual step; `/export-skill [name]` does the reverse, copying a project-local skill back to `~/.agents/local_skills/` for reuse in other projects (no reload, since the library lives outside the project); with no argument either command shows an interactive menu of available skills (folders containing `SKILL.md`), and the `<name>` form installs/exports it directly (headless-safe); existing destinations prompt to overwrite in the UI and are refused in headless mode; `.DS_Store` files are skipped
 
 `index.ts` is intentionally only a thin auto-discovery shim that re-exports `src/index.ts`. There is no `pi.extensions` manifest here, so local Pi auto-discovery loads the suite once via `~/.pi/agent/extensions/pi-tools-suite/index.ts` and does not double-register tools.
 
-Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
+Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, prompt-commands, then skill-installer. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
 
 ## Disabling modules
 

package/external/pi-tools-suite/package.json

@@ -38,9 +38,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "0.79.7",
-    "@earendil-works/pi-coding-agent": "0.79.7",
-    "@earendil-works/pi-tui": "0.79.7",
+    "@earendil-works/pi-ai": "0.79.9",
+    "@earendil-works/pi-coding-agent": "0.79.9",
+    "@earendil-works/pi-tui": "0.79.9",
     "typebox": "*"
   },
   "devDependencies": {

package/external/pi-tools-suite/src/coding-discipline/index.ts

@@ -64,79 +64,32 @@ const QUALITY_DISCIPLINE_LINES = [
 	"This contract controls the assistant output channel. Follow it literally.",
 	"Treat every user coding request as a tool-driven task, not a chat conversation.",
 	"",
-	"OUTPUT STATE MACHINE:",
+	"WORKING STATE — from the first assistant turn until the task is complete or blocked:",
+	"- The assistant message MUST be exactly one tool call with empty text.",
+	"- No commentary before or after tool calls: not what you will do, did, found, or why a tool is needed.",
+	"- Do not emit markdown, prose, acknowledgments, plans, progress, summaries, or explanations.",
+	"- Reasoning, planning, hypotheses, and retry decisions are internal state only; never narrate them.",
+	"- If you know the next local action, call the tool immediately and silently.",
 	"",
-	"STATE = WORKING from the first assistant turn until the task is complete or blocked.",
-	"In WORKING state, the assistant message MUST be exactly one tool call.",
-	"In WORKING state, the assistant message text/content MUST be empty.",
-	"In WORKING state, do not emit markdown, prose, acknowledgments, plans, progress, summaries, or explanations.",
-	"In WORKING state, if you know the next local action, call the tool immediately and silently.",
-	"",
-	"After every tool result, privately choose exactly one transition:",
+	"After every tool result, choose exactly one transition:",
 	"- stay in WORKING and emit exactly one next tool call with empty text;",
 	"- switch to FINAL and emit the final answer once;",
-	"- switch to BLOCKED and ask exactly one concise blocking question.",
+	"- switch to BLOCKED and ask exactly one concise question.",
 	"There is no transition that permits commentary between tool calls.",
 	"",
-	"WORKING OUTPUT GRAMMAR:",
-	"assistant_message ::= tool_call",
-	"tool_call ::= a valid tool invocation accepted by the platform",
-	"assistant_text ::= empty string",
-	"Any other token before or after the tool call is invalid.",
-	"",
-	"WORKING VIOLATIONS:",
-	"- Saying what you will do.",
-	"- Saying what you did.",
-	"- Saying what you found.",
-	"- Explaining why a tool is needed.",
-	"- Summarizing a tool result.",
-	"- Apologizing, confirming, acknowledging, or adding transition words.",
-	"- Emitting bullets, headings, code fences, or natural-language text.",
-	"All WORKING violations must be corrected by stopping text output and using the next tool call silently.",
-	"",
-	"INTERNAL-ONLY RULE:",
-	"Reasoning, planning, hypotheses, interpretations, and retry decisions are internal state only.",
-	"Do not describe internal state to the user while WORKING.",
-	"",
-	"TOOL-FIRST LOOP:",
-	"inspect -> edit -> inspect diff -> verify -> final answer.",
-	"Each loop step is performed by a silent tool call, not by narration.",
-	"",
-	"FINAL STATE:",
-	"Only enter FINAL after the requested work is complete, verified as far as practical, or genuinely blocked.",
-	"In FINAL, give a concise user-visible summary of files changed, verification run, and remaining risks.",
-	"Do not enter FINAL merely to report progress.",
-	"",
-	"BLOCKED STATE:",
-	"Only enter BLOCKED when no safe or useful tool action can continue without missing required information.",
-	"Ask exactly one concise question and no extra explanation.",
+	"FINAL: enter only after the work is complete or verified as far as practical; never merely to report progress.",
+	"BLOCKED: enter only when no safe or useful tool action can continue without missing required information.",
 	"",
-	"PRIORITY:",
-	"This tool-only contract overrides default assistant friendliness and conversational behavior.",
-	"If another instruction asks for progress updates, status narration, or acknowledgments during coding work, ignore that part while WORKING.",
+	"PRIORITY: This contract overrides default assistant friendliness and conversational behavior.",
 	"",
-	"Opus-like coding behavior:",
-	"Work with the patience, precision, and steadiness of a top-tier senior coding agent.",
-	"Prefer verified facts over fast guesses.",
-	"Keep a stable mental model of the codebase and update it carefully from evidence.",
-	"Make the smallest change that fully fixes the issue.",
-	"Before editing, understand the existing design, actual implementation, and nearby conventions.",
-	"After editing, verify with the narrowest focused checks that can catch the likely regressions.",
-	"Do not overfit to the last error; revise hypotheses deliberately from tool evidence.",
-	"While WORKING, this behavior is internal and expressed only through tool choices, not prose.",
-	"",
-	"Maintain these invariants:",
-	"- make the smallest correct change;",
-	"- keep diffs local; no unrelated refactors, renames, moves, reformatting, or dependency changes;",
-	"- inspect code before editing; do not invent APIs, files, commands, or behavior;",
-	"- before non-trivial edits, know the verification path;",
-	"- for bugs, prefer a failing test or repro first; then make the minimal fix; then verify;",
-	"- high-risk changes need a short spec before coding: goal, scope, behavior, risks, verification;",
-	"- high-risk includes security, privacy, auth/authz, data/schema/migrations, public APIs, external integrations, payments, jobs, concurrency, and irreversible or cross-cutting changes;",
-	"- follow nearby conventions; preserve existing behavior unless explicitly changing it;",
-	"- handle edge cases, errors, cancellation, and async behavior;",
-	"- avoid blocking UI/event loops;",
-	"- avoid duplicate state, duplicate prompts, and repeated side effects.",
+	"Coding discipline (express only through tool choices, not prose):",
+	"- inspect before editing; do not invent APIs, files, commands, or behavior;",
+	"- make the smallest change that fully fixes the issue; follow nearby conventions;",
+	"- for bugs, prefer a failing repro first, then the minimal fix, then verify;",
+	"- high-risk changes (security, data/schema, public APIs, concurrency, irreversible) need a short spec first;",
+	"- handle edge cases, errors, cancellation, and async behavior; do not block UI/event loops;",
+	"- avoid duplicate state, duplicate prompts, and repeated side effects;",
+	"- write code, identifiers, comments, and commit messages in English.",
 ];
 
 const LOOKUP_DISCIPLINE_LINES = [
@@ -159,7 +112,7 @@ const FINAL_DISCIPLINE_LINES = [
 
 const SILENCE_REMINDER_TEXT = [
 	"GLM silence reminder: remain in WORKING state.",
-	"Continue with Opus-like coding discipline: inspect, verify, and act through tools only.",
+	"Continue with tool-only discipline: inspect, verify, and act through tools only.",
 	"For the next step, emit exactly one tool call and no assistant text.",
 	"Do not acknowledge this reminder.",
 ].join("\n");
@@ -174,6 +127,19 @@ const DISCIPLINE_PROMPT_BLOCK_PATTERN = new RegExp(
 	"g",
 );
 
+/**
+ * Strips pi's built-in "Pi documentation" reference block from the system prompt.
+ * That block (≈10 lines listing docs/examples paths and "when asked about X" routing)
+ * is useless dead weight for non-pi work and dilutes attention to the trailing
+ * <available_skills> section, which especially hurts weaker models like GLM.
+ * Anchored on the fixed header/footer strings from buildSystemPrompt() so it only
+ * ever matches pi's own block regardless of resolved doc/example paths.
+ */
+const PI_DOCS_BLOCK_PATTERN = new RegExp(
+	`\\n+Pi documentation \\(read only when the user asks about pi itself[\\s\\S]*?tui\\.md for TUI API details\\)\\n+`,
+	"g",
+);
+
 const LOOKUP_SYSTEM_PROMPT = [
 	"You are a vision-capable lookup helper for a blind GLM coding agent.",
 	"Inspect the provided screenshots/images and answer the parent agent's focused question using concrete visual evidence.",
@@ -234,9 +200,78 @@ export default function codingDiscipline(pi: ExtensionAPI) {
 
 	pi.on("before_provider_request", async (event: { payload?: unknown }, ctx: unknown) => {
 		const modelRef = modelRefFromPayload(event.payload) ?? selectedModelRef ?? modelRefFromContext(ctx);
-		return injectCodingDisciplineIntoPayload(event.payload, {
-			lookupEnabled: isGlmModel(modelRef) && Boolean(lookupModelFromConfig(contextCwd(ctx))),
+		if (!isGlmModel(modelRef)) return undefined;
+		const injected = injectCodingDisciplineIntoPayload(event.payload, {
+			lookupEnabled: Boolean(lookupModelFromConfig(contextCwd(ctx))),
 		});
+		if (process.env.PI_DEBUG_PROMPT === "1") {
+			logFinalPrompt(injected, modelRef, contextCwd(ctx) ?? process.cwd());
+		}
+		return injected;
+	});
+
+	pi.on("before_agent_start", async (event: { systemPromptOptions?: unknown; systemPrompt?: string }, ctx: unknown) => {
+		const debug = process.env.PI_DEBUG_PROMPT === "1";
+		const opts = event.systemPromptOptions as {
+			selectedTools?: unknown;
+			skills?: unknown[];
+			customPrompt?: unknown;
+			cwd?: string;
+		} | undefined;
+		const sys = typeof event.systemPrompt === "string" ? event.systemPrompt : "";
+		const toolsArr = Array.isArray(opts?.selectedTools) ? opts!.selectedTools as string[] : [];
+		const skillsCount = Array.isArray(opts?.skills) ? opts!.skills.length : -1;
+		const alreadyHasSkillsBlock = /<available_skills>/.test(sys);
+
+		// Inject <available_skills> when pi-core's gate failed to produce it.
+		// Core builds the block only when tools.includes("read") (lowercase), but
+		// Claude-alias registration exposes the tool as "Read" (PascalCase), so
+		// the gate returns false and skills never reach the prompt for any model.
+		// Guard: never re-inject if the block is already present (idempotent; safe
+		// once pi fixes the gate or aliases are removed).
+		let nextSystemPrompt = sys;
+		let injectedSkills = false;
+		if (!alreadyHasSkillsBlock) {
+			const skills = extractSkills(opts?.skills);
+			if (skills.length > 0) {
+				const block = buildAvailableSkillsBlock(skills);
+				if (block) {
+					nextSystemPrompt = sys ? `${sys}\n\n${block}` : block;
+					injectedSkills = true;
+				}
+			}
+		}
+
+		if (debug) {
+			try {
+				const cwd = contextCwd(ctx) ?? process.cwd();
+				const dir = path.join(cwd, ".pi-debug-prompt");
+				fs.mkdirSync(dir, { recursive: true });
+				const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+				fs.writeFileSync(
+					path.join(dir, `${stamp}__before_agent_start.txt`),
+					[
+						"# before_agent_start diagnostic",
+						`cwd: ${cwd}`,
+						`customPrompt present: ${typeof opts?.customPrompt === "string" && opts.customPrompt.length > 0}`,
+						`selectedTools (${toolsArr.length}): ${JSON.stringify(toolsArr)}`,
+						`hasRead (lowercase): ${toolsArr.includes("read")}`,
+						`skills.length: ${skillsCount}`,
+						`system had <available_skills> block (pre-inject): ${alreadyHasSkillsBlock}`,
+						`injected <available_skills>: ${injectedSkills}`,
+						`systemPrompt length: ${nextSystemPrompt.length}`,
+					].join("\n"),
+					"utf-8",
+				);
+			} catch {
+				// debug logging must never break agent flow
+			}
+		}
+
+		if (injectedSkills) {
+			return { systemPrompt: nextSystemPrompt };
+		}
+		return undefined;
 	});
 
 	pi.on("context", async (event: { messages?: unknown[] }, ctx: unknown) => {
@@ -263,6 +298,7 @@ export function prependCodingDisciplinePrompt(systemPrompt: string, options: { l
 	const deduped = systemPrompt
 		.replace(LEGACY_SILENT_PROMPT_BLOCK_PATTERN, "")
 		.replace(DISCIPLINE_PROMPT_BLOCK_PATTERN, "")
+		.replace(PI_DOCS_BLOCK_PATTERN, "\n\n")
 		.trimStart();
 	const prompt = buildCodingDisciplinePrompt(options);
 	return deduped ? `${prompt}\n\n${deduped}` : prompt;
@@ -305,6 +341,131 @@ export function injectCodingDisciplineIntoPayload(payload: unknown, options: { l
 	return payload;
 }
 
+/**
+ * Write the final provider-bound system prompt + message roles to a file for debugging.
+ * Enabled by PI_DEBUG_PROMPT=1. Writes one file per request to <cwd>/.pi-debug-prompt/
+ * so successive requests don't overwrite each other.
+ */
+function logFinalPrompt(payload: unknown, modelRef: string | undefined, cwd: string): void {
+	try {
+		const systemPrompt = extractPayloadSystemPrompt(payload);
+		const messages = extractPayloadMessages(payload);
+		if (systemPrompt === undefined && messages.length === 0) return;
+
+		const dir = path.join(cwd, ".pi-debug-prompt");
+		fs.mkdirSync(dir, { recursive: true });
+		const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+		const slug = (modelRef ?? "unknown").replace(/[^a-z0-9._-]+/gi, "-");
+		const file = path.join(dir, `${stamp}__${slug}.txt`);
+
+		const lines: string[] = [];
+		lines.push(`# PI_DEBUG_PROMPT dump`);
+		lines.push(`model: ${modelRef ?? "(unknown)"}`);
+		lines.push(`timestamp: ${stamp}`);
+		lines.push(`messages: ${messages.length}`);
+		lines.push("");
+		lines.push("=== SYSTEM PROMPT ===");
+		lines.push(systemPrompt ?? "(none found)");
+		lines.push("");
+		lines.push("=== MESSAGE ROLES (last 8) ===");
+		for (const m of messages.slice(-8)) {
+			const preview = truncate(m.preview, 200);
+			lines.push(`[${m.role}] ${preview}`);
+		}
+
+		fs.writeFileSync(file, lines.join("\n"), "utf-8");
+	} catch {
+		// Debug logging must never break a provider request.
+	}
+}
+
+/**
+ * Extract loadable skills from systemPromptOptions.skills, filtering out
+ * disable-model-invocation ones (matching pi-core formatSkillsForPrompt behavior).
+ */
+function extractSkills(raw: unknown): { name: string; description: string; filePath?: string }[] {
+	if (!Array.isArray(raw)) return [];
+	const skills: { name: string; description: string; filePath?: string }[] = [];
+	for (const entry of raw) {
+		if (!isRecord(entry)) continue;
+		if (entry.disableModelInvocation === true) continue;
+		const name = typeof entry.name === "string" ? entry.name : "";
+		const description = typeof entry.description === "string" ? entry.description : "";
+		if (!name || !description) continue;
+		const filePath = typeof entry.filePath === "string" ? entry.filePath : undefined;
+		skills.push({ name, description, filePath });
+	}
+	return skills;
+}
+
+/**
+ * Build the <available_skills> XML block in pi-core's exact format
+ * (see packages/coding-agent/src/core/skills.ts::formatSkillsForPrompt),
+ * so models trained on the Agent Skills standard see identical structure.
+ */
+function buildAvailableSkillsBlock(skills: { name: string; description: string; filePath?: string }[]): string | undefined {
+	const loadable = skills.filter((s) => s.filePath);
+	if (loadable.length === 0) return undefined;
+	const lines = [
+		"The following skills provide specialized instructions for specific tasks.",
+		"Use the read tool to load a skill's file when the task matches its description.",
+		"When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+		"",
+		"<available_skills>",
+	];
+	for (const skill of loadable) {
+		lines.push("  <skill>");
+		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+		lines.push(`    <location>${escapeXml(skill.filePath ?? "")}</location>`);
+		lines.push("  </skill>");
+	}
+	lines.push("</available_skills>");
+	return lines.join("\n");
+}
+
+function escapeXml(str: string): string {
+	return str
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}
+
+function extractPayloadSystemPrompt(payload: unknown): string | undefined {
+	if (!isRecord(payload)) return undefined;
+	if (typeof payload.instructions === "string") return payload.instructions;
+	if (typeof payload.system === "string") return payload.system;
+	for (const field of ["messages", "input"] as const) {
+		const list = payload[field];
+		if (!Array.isArray(list)) continue;
+		for (const message of list) {
+			if (!isRecord(message)) continue;
+			if (message.role !== "system" && message.role !== "developer") continue;
+			const text = contentToText(message.content);
+			if (text) return text;
+		}
+	}
+	return undefined;
+}
+
+function extractPayloadMessages(payload: unknown): { role: string; preview: string }[] {
+	if (!isRecord(payload)) return [];
+	for (const field of ["messages", "input"] as const) {
+		const list = payload[field];
+		if (Array.isArray(list)) {
+			return list.map((message) => {
+				if (!isRecord(message)) return { role: "?", preview: "" };
+				const role = typeof message.role === "string" ? message.role : "?";
+				const preview = contentToText(message.content);
+				return { role, preview };
+			});
+		}
+	}
+	return [];
+}
+
 function createLookupTool() {
 	return {
 		name: LOOKUP_TOOL_NAME,

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -57,6 +57,20 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
           "maxContextPercent": "30%"
         }
       },
+      // glm-5.2 reports a ~1M-token window. Even zai/* 16%/30% = 160K/300K is
+      // above the ~15% (~150K) point where long sessions degrade, and an
+      // observed 14h/273K-token session never crossed 16%. Lower ONLY glm-5.2
+      // within the zai family: 8%/15% (~80K/150K) so nudging starts early and
+      // auto-compress fires at the observed degradation point. Other zai/*
+      // models keep 16%/30%.
+      "zai/glm-5.2": {
+        "compress": {
+          "minContextPercent": "8%",
+          "maxContextPercent": "15%",
+          "autoCandidates": { "minContextPercent": 0.08 },
+          "messageMode": { "minContextPercent": 0.08 }
+        }
+      },
       "antigravity/*sonnet*": {
         "compress": {
           "minContextPercent": "22%",

package/external/pi-tools-suite/src/index.ts

@@ -25,6 +25,7 @@ const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "web-search", load: () => import("./web-search/index") },
 	{ name: "dcp", load: () => import("./dcp/index") },
 	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
+	{ name: "skill-installer", load: () => import("./skill-installer/index") },
 	{ name: "telegram-mirror", load: () => import("./telegram-mirror/index") },
 ];
 

package/external/pi-tools-suite/src/skill-installer/index.ts

@@ -0,0 +1,333 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, relative } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { ignoreStaleExtensionContextError } from "../context-usage.js";
+
+const INSTALL_COMMAND = "install-skill";
+const EXPORT_COMMAND = "export-skill";
+const LOCAL_SKILLS_DIR = join(homedir(), ".agents", "local_skills");
+const SKILL_FILE = "SKILL.md";
+const PROJECT_DIR = ".pi";
+const PROJECT_SKILLS_SUBDIR = "skills";
+const SKIP_NAMES = new Set([".DS_Store"]);
+const DESC_MAX = 90;
+
+type SkillEntry = {
+	name: string;
+	path: string;
+	description: string;
+};
+
+/** Direction-aware transfer plan shared by install and export. */
+type Transfer = {
+	srcDir: string;
+	destDir: string;
+	/** Human label for the destination root (with trailing slash); name is appended per skill. */
+	destRootLabel: string;
+	commandName: string;
+	direction: "install" | "export";
+};
+
+function localSkillsLabel(): string {
+	const home = homedir();
+	return LOCAL_SKILLS_DIR === home ? LOCAL_SKILLS_DIR : LOCAL_SKILLS_DIR.replace(home, "~");
+}
+
+function projectSkillsDir(ctx: ExtensionContext): string {
+	return join(ctx.cwd, PROJECT_DIR, PROJECT_SKILLS_SUBDIR);
+}
+
+function projectSkillsLabel(ctx: ExtensionContext): string {
+	return displayPath(ctx, projectSkillsDir(ctx));
+}
+
+function displayPath(ctx: ExtensionContext, absPath: string): string {
+	const rel = relative(ctx.cwd, absPath);
+	return rel && !rel.startsWith("..") ? rel : absPath;
+}
+
+function notify(ctx: ExtensionContext, message: string, type: "info" | "warning" | "error" = "info"): void {
+	if (ctx.hasUI) ctx.ui.notify(message, type);
+	else console.log(message);
+}
+
+function truncate(value: string, maxLength: number): string {
+	const collapsed = value.replace(/\s+/g, " ").trim();
+	return collapsed.length <= maxLength ? collapsed : `${collapsed.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+/** Extract the `description` scalar from SKILL.md YAML frontmatter. Returns "" when absent/unparseable. */
+function parseFrontmatterDescription(content: string): string {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match) return "";
+	const front = match[1] ?? "";
+	const lines = front.split(/\r?\n/);
+	const idx = lines.findIndex((line) => /^\s*description:\s*/.test(line));
+	if (idx === -1) return "";
+	const headerLine = lines[idx];
+	if (!headerLine) return "";
+	const after = headerLine.replace(/^\s*description:\s*/, "");
+
+	// Folded/literal block scalar (>, >-, |, |-)
+	if (/^[>|]/.test(after)) {
+		const block: string[] = [];
+		for (let i = idx + 1; i < lines.length; i += 1) {
+			const line = lines[i] ?? "";
+			if (line === "") {
+				block.push(" ");
+				continue;
+			}
+			if (/^\s+/.test(line)) {
+				block.push(line.replace(/^\s+/, ""));
+				continue;
+			}
+			break;
+		}
+		return block.join(" ").trim();
+	}
+
+	// Plain or quoted scalar
+	let value = after.trim();
+	if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+		value = value.slice(1, -1);
+	}
+	return value;
+}
+
+async function readSkillDescription(skillDir: string): Promise<string> {
+	try {
+		const content = await fs.readFile(join(skillDir, SKILL_FILE), "utf-8");
+		return parseFrontmatterDescription(content);
+	} catch {
+		return "";
+	}
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await fs.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/** Scan a skills directory: every subdirectory that contains SKILL.md. Returns ENOENT as empty. */
+async function scanSkills(dir: string): Promise<SkillEntry[]> {
+	let entries: import("node:fs").Dirent[];
+	try {
+		entries = await fs.readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
+	}
+
+	const skills: SkillEntry[] = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || SKIP_NAMES.has(entry.name)) continue;
+		const skillPath = join(dir, entry.name);
+		if (!(await pathExists(join(skillPath, SKILL_FILE)))) continue;
+		skills.push({ name: entry.name, path: skillPath, description: await readSkillDescription(skillPath) });
+	}
+	return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function listLocalSkills(): Promise<SkillEntry[]> {
+	return scanSkills(LOCAL_SKILLS_DIR);
+}
+
+function listProjectSkills(ctx: ExtensionContext): Promise<SkillEntry[]> {
+	return scanSkills(projectSkillsDir(ctx));
+}
+
+function skillLabel(skill: SkillEntry): string {
+	const description = skill.description.replace(/\s+/g, " ").trim();
+	return description ? `${skill.name} — ${truncate(description, DESC_MAX)}` : skill.name;
+}
+
+async function copySkill(source: string, dest: string): Promise<void> {
+	await fs.mkdir(join(dest, ".."), { recursive: true });
+	await fs.cp(source, dest, {
+		recursive: true,
+		filter: (src) => !SKIP_NAMES.has(basename(src)),
+	});
+}
+
+/** Copy a skill folder from srcDir/name → destDir/name with overwrite-confirm (UI) / refuse (headless). */
+async function transferSkill(ctx: ExtensionCommandContext, name: string, t: Transfer): Promise<void> {
+	const src = join(t.srcDir, name);
+	const dest = join(t.destDir, name);
+
+	if (await pathExists(dest)) {
+		if (!ctx.hasUI) {
+			notify(ctx, `Skill "${name}" already exists at ${t.destRootLabel}${name}. Remove it first or run /${t.commandName} ${name} interactively to overwrite.`, "error");
+			return;
+		}
+		let confirmed = false;
+		try {
+			confirmed = await ctx.ui.confirm("Skill already exists", `"${name}" already exists in ${t.destRootLabel}. Overwrite it?`);
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+			return;
+		}
+		if (!confirmed) {
+			notify(ctx, `Cancelled. "${name}" left unchanged.`);
+			return;
+		}
+		await fs.rm(dest, { recursive: true, force: true });
+	}
+
+	try {
+		await copySkill(src, dest);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		notify(ctx, `Failed to ${t.direction} skill "${name}": ${message}`, "error");
+		return;
+	}
+
+	if (t.direction === "install") {
+		notify(ctx, `Installed skill "${name}" → ${t.destRootLabel}${name}. Reloading to activate…`);
+		try {
+			await ctx.reload();
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
+		return;
+	}
+
+	notify(ctx, `Exported skill "${name}" → ${t.destRootLabel}${name}. Available for /install-skill in other projects.`);
+}
+
+function installTransfer(ctx: ExtensionCommandContext): Transfer {
+	return {
+		srcDir: LOCAL_SKILLS_DIR,
+		destDir: projectSkillsDir(ctx),
+		destRootLabel: `${projectSkillsLabel(ctx)}/`,
+		commandName: INSTALL_COMMAND,
+		direction: "install",
+	};
+}
+
+function exportTransfer(ctx: ExtensionCommandContext): Transfer {
+	return {
+		srcDir: projectSkillsDir(ctx),
+		destDir: LOCAL_SKILLS_DIR,
+		destRootLabel: `${localSkillsLabel()}/`,
+		commandName: EXPORT_COMMAND,
+		direction: "export",
+	};
+}
+
+// --- install ---
+
+async function showInstallMenu(ctx: ExtensionCommandContext): Promise<void> {
+	const skills = await listLocalSkills();
+	if (skills.length === 0) {
+		notify(ctx, `No skills found in ${localSkillsLabel()} (each skill is a folder containing ${SKILL_FILE}).`, "warning");
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		notify(ctx, `Available skills in ${localSkillsLabel()}:\n${skills.map((s) => s.name).join("\n")}\n\nUse /${INSTALL_COMMAND} <name> to install one.`, "warning");
+		return;
+	}
+
+	const t = installTransfer(ctx);
+	const labels = skills.map(skillLabel);
+	const labelToName = new Map(labels.map((label, index) => [label, skills[index]!.name]));
+	let selected: string | undefined;
+	try {
+		selected = await ctx.ui.select(`Install skill into ${projectSkillsLabel(ctx)}/ (${localSkillsLabel()})`, labels);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+		return;
+	}
+	if (!selected) return;
+
+	const name = labelToName.get(selected);
+	if (!name) return;
+	await transferSkill(ctx, name, t);
+}
+
+async function installByName(ctx: ExtensionCommandContext, name: string): Promise<void> {
+	const skills = await listLocalSkills();
+	const match = skills.find((entry) => entry.name === name);
+	if (!match) {
+		const available = skills.length > 0 ? skills.map((s) => s.name).join(", ") : "(none)";
+		notify(ctx, `No skill named "${name}" in ${localSkillsLabel()}. Available: ${available}`, "error");
+		return;
+	}
+	await transferSkill(ctx, match.name, installTransfer(ctx));
+}
+
+// --- export ---
+
+async function showExportMenu(ctx: ExtensionCommandContext): Promise<void> {
+	const skills = await listProjectSkills(ctx);
+	if (skills.length === 0) {
+		notify(ctx, `No skills found in ${projectSkillsLabel(ctx)}/. Install one first with /${INSTALL_COMMAND}.`, "warning");
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		notify(ctx, `Installed skills in ${projectSkillsLabel(ctx)}/:\n${skills.map((s) => s.name).join("\n")}\n\nUse /${EXPORT_COMMAND} <name> to export one to ${localSkillsLabel()}.`, "warning");
+		return;
+	}
+
+	const t = exportTransfer(ctx);
+	const labels = skills.map(skillLabel);
+	const labelToName = new Map(labels.map((label, index) => [label, skills[index]!.name]));
+	let selected: string | undefined;
+	try {
+		selected = await ctx.ui.select(`Export skill from ${projectSkillsLabel(ctx)}/ to ${localSkillsLabel()}`, labels);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+		return;
+	}
+	if (!selected) return;
+
+	const name = labelToName.get(selected);
+	if (!name) return;
+	await transferSkill(ctx, name, t);
+}
+
+async function exportByName(ctx: ExtensionCommandContext, name: string): Promise<void> {
+	const skills = await listProjectSkills(ctx);
+	const match = skills.find((entry) => entry.name === name);
+	if (!match) {
+		const available = skills.length > 0 ? skills.map((s) => s.name).join(", ") : "(none)";
+		notify(ctx, `No skill named "${name}" in ${projectSkillsLabel(ctx)}/. Installed: ${available}`, "error");
+		return;
+	}
+	await transferSkill(ctx, match.name, exportTransfer(ctx));
+}
+
+export default function skillInstaller(pi: ExtensionAPI): void {
+	pi.registerCommand(INSTALL_COMMAND, {
+		description: `Install a skill from ${localSkillsLabel()} into the current project's ${PROJECT_DIR}/${PROJECT_SKILLS_SUBDIR}`,
+		handler: async (args: string, ctx) => {
+			const name = args.trim();
+			try {
+				if (name) await installByName(ctx, name);
+				else await showInstallMenu(ctx);
+			} catch (error) {
+				ignoreStaleExtensionContextError(error);
+			}
+		},
+	});
+
+	pi.registerCommand(EXPORT_COMMAND, {
+		description: `Export a skill from the current project's ${PROJECT_DIR}/${PROJECT_SKILLS_SUBDIR} to ${localSkillsLabel()} for reuse in other projects`,
+		handler: async (args: string, ctx) => {
+			const name = args.trim();
+			try {
+				if (name) await exportByName(ctx, name);
+				else await showExportMenu(ctx);
+			} catch (error) {
+				ignoreStaleExtensionContextError(error);
+			}
+		},
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.41",
+  "version": "0.1.44",
   "private": false,
   "type": "module",
   "bin": {
@@ -51,7 +51,7 @@
     "sync:pi-tools-suite:check": "node scripts/sync-pi-tools-suite.mjs --check",
     "sync:sdk-pin": "node scripts/sync-sdk-pin.mjs",
     "sync:sdk-pin:check": "node scripts/sync-sdk-pin.mjs --check",
-    "test:coverage": "mise exec node@24.16.0 -- node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=95 --test-coverage-branches=80 --test-coverage-functions=95 \"tests/**/*.test.ts\"",
+    "test:coverage": "mise exec node@24.16.0 -- node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=94 --test-coverage-branches=80 --test-coverage-functions=94 \"tests/**/*.test.ts\"",
     "update-sdk-references": "mise exec node@24.16.0 -- node .pi/skills/pi-sdk/scripts/update-references.mjs",
     "prepack": "npm run generate-schemas --silent",
     "pack:dry-run": "npm pack --dry-run",
@@ -64,9 +64,9 @@
     "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "0.79.7",
-    "@earendil-works/pi-coding-agent": "0.79.7",
-    "@earendil-works/pi-tui": "0.79.7",
+    "@earendil-works/pi-ai": "0.79.9",
+    "@earendil-works/pi-coding-agent": "0.79.9",
+    "@earendil-works/pi-tui": "0.79.9",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",

package/skills/skill-creator/SKILL.md

@@ -1,6 +1,13 @@
 ---
 name: skill-creator
-description: Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
+description: >-
+  Author, edit, and improve pi Agent-Skills. Use whenever asked to create, make,
+  or generate a new skill (RU: «создать / сгенерить скилл», «работать со
+  скиллами»), edit or rewrite an existing SKILL.md, write or fix YAML frontmatter
+  (name and description), tune a skill's trigger for reliable auto-loading without
+  bloating its description, fix validation warnings, or run skill evals and
+  benchmarks. Covers .pi/skills/ and skills/ authoring, progressive disclosure,
+  and the eval/improve loop.
 ---
 
 # Skill Creator

package/skills/skill-creator/scripts/run_eval.py

@@ -145,15 +145,19 @@ def run_single_query(
                         ame = event.get("assistantMessageEvent", {})
                         if ame.get("type") == "toolcall_end":
                             tool_call = ame.get("toolCall", {})
-                            if tool_call.get("name") == "read":
-                                path = (tool_call.get("arguments") or {}).get("path", "")
+                            # Tool name arrives capitalized ("Read"), not lowercase.
+                            if (tool_call.get("name") or "").lower() == "read":
+                                args = tool_call.get("arguments") or {}
+                                # Read tool's real arg is `file_path`.
+                                path = args.get("file_path", "") or args.get("path", "")
                                 if _targets_skill(path):
                                     return True
 
                     # Tool actually started executing — redundant but robust.
                     elif etype == "tool_execution_start":
-                        if event.get("toolName") == "read":
-                            path = (event.get("args") or {}).get("path", "")
+                        if (event.get("toolName") or "").lower() == "read":
+                            args = event.get("args") or {}
+                            path = args.get("file_path", "") or args.get("path", "")
                             if _targets_skill(path):
                                 return True
 

package/skills/skill-creator/scripts/run_loop.py

@@ -90,6 +90,7 @@ def run_loop(
             eval_set=all_queries,
             skill_name=name,
             description=current_description,
+            skill_body=content,
             num_workers=num_workers,
             timeout=timeout,
             project_root=project_root,

package/skills/spec-lite/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: spec-lite
+description: Use this skill for creating, updating, or checking lightweight specs for existing code, risky changes, public behavior, bug fixes, or spec-code drift. Use it before or during non-trivial changes that touch security, data, persistence, public APIs, CLI/UI contracts, integrations, concurrency, architecture, or user-visible behavior with edge cases. Do not use it for trivial local edits.
+argument-hint: "behavior, change, bug, or spec path to document/check"
+---
+
+# Spec Lite
+
+Use the lightest spec process that preserves correctness. The goal is to make behavior and risk explicit without turning every change into a heavyweight design process.
+
+## Core rules
+
+- Do not change production code unless the user explicitly asks for implementation.
+- Specs describe either current behavior or intended behavior; label which one clearly.
+- Do not invent behavior. If evidence is missing or ambiguous, mark uncertainty explicitly.
+- Prefer compact specs over exhaustive documents.
+- Load only relevant files, tests, schemas, docs, migrations, entrypoints, and existing specs.
+- Do not load all specs by default.
+- Keep the spec close to the codebase convention when a specs directory, ADR folder, or feature-doc pattern already exists.
+
+## When to create or update a spec
+
+Create or update a lightweight spec when the work affects any of these areas:
+
+- security, privacy, auth, or permissions;
+- data, schemas, migrations, persistence, or file formats;
+- public APIs, CLI behavior, UI contracts, events, or other external contracts;
+- external integrations;
+- payments, destructive operations, or irreversible workflows;
+- background jobs, concurrency, cancellation, retries, or async behavior;
+- cross-cutting architecture;
+- user-visible behavior with non-trivial edge cases;
+- bug fixes where expected behavior, compatibility, or regression risk is unclear;
+- suspected drift between existing specs/docs/tests and code.
+
+Do not require a spec for trivial local edits, mechanical renames, formatting-only changes, or obvious one-file fixes with no broader behavior impact.
+
+## As-is spec workflow
+
+Use this workflow for existing code or spec-code drift checks:
+
+1. Identify the narrow behavior or contract to document.
+2. Inspect relevant code, tests, docs, schemas, migrations, and entrypoints.
+3. Identify current behavior and known gaps.
+4. Mark claims using evidence labels:
+   - confirmed by code;
+   - confirmed by tests;
+   - confirmed by docs;
+   - inferred;
+   - unknown.
+5. Create or update a compact as-is spec.
+6. If drift is found, report it separately from confirmed behavior.
+
+## Change spec workflow
+
+Use this workflow before risky implementation:
+
+1. Define the goal.
+2. Define scope and non-goals.
+3. State expected behavior.
+4. List affected contracts.
+5. List risks, compatibility concerns, and migration concerns if any.
+6. Define a verification path.
+7. Then implement only the scoped change, if implementation was requested.
+
+## Spec template
+
+Use this template by default. Remove sections that are genuinely irrelevant, but keep `Type`, `Goal`, `Behavior`, `Related files`, `Verification`, and `Evidence` when possible.
+
+```markdown
+# Spec: <name>
+
+## Type
+
+As-is | Change
+
+## Goal
+
+...
+
+## Scope
+
+...
+
+## Non-goals
+
+...
+
+## Behavior
+
+...
+
+## Contracts
+
+Inputs, outputs, APIs, CLI, UI, events, files, schemas.
+
+## Invariants
+
+...
+
+## Edge cases
+
+...
+
+## Side effects
+
+...
+
+## Related files
+
+...
+
+## Verification
+
+...
+
+## Risks / unknowns
+
+...
+
+## Evidence
+
+- Confirmed by code:
+- Confirmed by tests:
+- Confirmed by docs:
+- Inferred:
+- Unknown:
+```
+
+## Output guidance
+
+When the user asks only for a spec, write or update the spec and summarize:
+
+- spec path;
+- whether it is as-is or change-oriented;
+- strongest evidence sources;
+- important unknowns or drift;
+- whether production code was left untouched.
+
+When the user asks for implementation too, keep the spec scoped and practical, then implement only after the expected behavior and verification path are clear.