pi-ui-extend 0.1.43 → 0.1.45

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

@@ -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/src/coding-discipline/index.ts

@@ -88,7 +88,8 @@ const QUALITY_DISCIPLINE_LINES = [
 	"- 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.",
+	"- avoid duplicate state, duplicate prompts, and repeated side effects;",
+	"- write code, identifiers, comments, and commit messages in English.",
 ];
 
 const LOOKUP_DISCIPLINE_LINES = [

package/external/pi-tools-suite/src/dcp/compression-blocks.ts

@@ -383,11 +383,86 @@ export function resolveIdToBoundary(
   }
 
   const meta = state.messageMetaSnapshot.get(id)
-  if (meta) return { timestamp: meta.timestamp, stableId: meta.stableId }
+  if (meta) return resolveMetaBoundary(meta, field, state)
 
   const ts = state.messageIdSnapshot.get(id)
-  if (ts === undefined) throw unknownCompressionIdError(id, state)
-  return { timestamp: ts }
+  if (ts !== undefined) return { timestamp: ts }
+
+  // ── Stale mNNN fallback: direction-only clamp ────────────────────────
+  // When compression or pruning removes messages between context passes,
+  // positional mNNN IDs shift (e.g. an end boundary m145 becomes m123
+  // after 22 messages are removed).  Clamp to the closest valid ID, but
+  // ONLY in a direction that preserves the range's semantics:
+  //   - start boundary: clamp upward to the first available ID at or after
+  //     the requested number.  The start must never move backwards into
+  //     older content; if no such ID exists, the requested start is gone
+  //     and we cannot safely compress — throw.
+  //   - end boundary: clamp downward to the last available ID at or before
+  //     the requested number.  The end must never move forwards into newer
+  //     content; if no such ID exists, throw.
+  // The previous implementation fell back to the highest available ID in
+  // both "no match" cases, which could clamp e.g. m010..m010 over a
+  // snapshot of m001..m003 to a single-message block over m003 — silently
+  // compressing the wrong content.
+  const mMatch = id.match(/^m(\d+)$/i)
+  if (mMatch && state.messageIdSnapshot.size > 0) {
+    const requestedNum = parseInt(mMatch[1]!, 10)
+    const allIds = sortIds([...state.messageIdSnapshot.keys()])
+    const allNums = allIds
+      .map((mid) => {
+        const n = mid.match(/^m(\d+)$/i)
+        return n ? { id: mid, num: parseInt(n[1]!, 10) } : null
+      })
+      .filter((entry): entry is { id: string; num: number } => entry !== null)
+      .sort((a, b) => a.num - b.num)
+
+    if (allNums.length > 0) {
+      let clamped: { id: string; num: number } | undefined
+      if (field === "startTimestamp") {
+        clamped = allNums.find((entry) => entry.num >= requestedNum)
+      } else {
+        for (let i = allNums.length - 1; i >= 0; i--) {
+          if (allNums[i]!.num <= requestedNum) {
+            clamped = allNums[i]
+            break
+          }
+        }
+      }
+      if (clamped) {
+        const clampedMeta = state.messageMetaSnapshot.get(clamped.id)
+        if (clampedMeta) return resolveMetaBoundary(clampedMeta, field, state)
+        const clampedTs = state.messageIdSnapshot.get(clamped.id)
+        if (clampedTs !== undefined) return { timestamp: clampedTs }
+      }
+    }
+  }
+
+  throw unknownCompressionIdError(id, state)
+}
+
+/**
+ * Resolve a `MessageIdMeta` to a compression boundary. When the meta is a
+ * synthetic placeholder for an active compression block (`meta.blockId` is
+ * set), resolve to that block's stored boundary so the caller rolls the
+ * block up instead of nesting a new block on top of the placeholder. This
+ * matters for both exact-match and clamped mNNN IDs: a model-visible mNNN
+ * may itself represent a previously compressed section.
+ */
+function resolveMetaBoundary(
+  meta: MessageIdMeta,
+  field: "startTimestamp" | "endTimestamp",
+  state: DcpState,
+): ResolvedCompressionBoundary {
+  if (meta.blockId !== undefined) {
+    const block = state.compressionBlocks.find((b) => b.id === meta.blockId && b.active)
+    if (block) {
+      return {
+        timestamp: block[field],
+        stableId: field === "startTimestamp" ? block.startMessageId : block.endMessageId,
+      }
+    }
+  }
+  return { timestamp: meta.timestamp, stableId: meta.stableId }
 }
 
 /**

package/external/pi-tools-suite/src/dcp/pruner-compression-blocks.ts

@@ -13,60 +13,76 @@ function findBoundaryIndex(messages: any[], stableId: string | undefined, timest
   return messages.findIndex((m, index) => messageMatchesBoundary(m, index, stableId, timestamp));
 }
 
-function collectToolCallIds(messages: any[]): Set<string> {
-  const ids = new Set<string>();
-  for (const msg of messages) {
-    if (typeof msg?.toolCallId === "string") ids.add(msg.toolCallId);
-    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
-    for (const block of msg.content) {
-      if (block?.type === "toolCall" && typeof block.id === "string") ids.add(block.id);
-    }
-  }
-  return ids;
-}
 
 export function syncCompressionBlocks(messages: any[], state: DcpState, config: DcpConfig): void {
   if (state.compressionBlocks.length === 0) return;
 
-  const toolCallIds = collectToolCallIds(messages);
+  // Determine the conversation's timestamp range so we can tell whether a
+  // block's range is genuinely outside the current session history (which
+  // warrants deactivation) vs merely having its boundary messages pruned
+  // (which is normal and should NOT cause deactivation).
+  let conversationMinTs = Infinity;
+  let conversationMaxTs = -Infinity;
+  for (const msg of messages) {
+    const ts = msg?.timestamp;
+    if (typeof ts === "number" && Number.isFinite(ts)) {
+      if (ts < conversationMinTs) conversationMinTs = ts;
+      if (ts > conversationMaxTs) conversationMaxTs = ts;
+    }
+  }
 
   for (const block of state.compressionBlocks) {
     if (!block.active || block.deactivatedByUser) continue;
 
+    // ── Skip the missing-origin-compress-call check ────────────────────
+    // The compress tool-call that *created* this block is not the block's
+    // content — once the block exists the tool-call is irrelevant and will
+    // naturally be pruned by tool-output pruning, session compaction, or
+    // nested compression.  Deactivating a valid block because its creation
+    // tool-call was pruned silently loses the compressed summary and forces
+    // the original (larger) messages to be re-sent, which also invalidates
+    // the provider's prompt prefix cache.
+
+    // ── Boundary validation ────────────────────────────────────────────
+    // Only deactivate when the block's timestamp range falls entirely
+    // outside the conversation's time range, meaning the session genuinely
+    // does not contain that history (e.g. after a branch switch to a
+    // completely different conversation).  When boundary messages are merely
+    // absent because they were themselves pruned, compressed, or have
+    // fragile timestamp-based stable IDs, the block is still valid —
+    // applyCompressionBlocks already handles missing boundaries gracefully
+    // by skipping splicing when findBoundaryIndex returns -1.
     if (
-      typeof block.createdByToolCallId === "string" &&
-      state.toolCalls.has(block.createdByToolCallId) &&
-      !toolCallIds.has(block.createdByToolCallId)
+      Number.isFinite(block.startTimestamp) &&
+      Number.isFinite(block.endTimestamp) &&
+      Number.isFinite(conversationMinTs) &&
+      Number.isFinite(conversationMaxTs)
     ) {
-      block.active = false;
-      block.deactivatedReason = "missing-origin-compress-call";
-      writeDcpDebugLog(config, "block.auto_deactivated", {
-        blockId: `b${block.id}`,
-        reason: "missing-origin-compress-call",
-        topic: block.topic,
-        createdByToolCallId: block.createdByToolCallId,
-        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
-      });
-      continue;
-    }
+      // Block range is entirely before or entirely after the conversation
+      const blockEntirelyOutside =
+        block.endTimestamp < conversationMinTs ||
+        block.startTimestamp > conversationMaxTs;
 
-    const hasStableBoundaries = !!block.startMessageId && !!block.endMessageId;
-    if (!hasStableBoundaries) continue;
+      if (blockEntirelyOutside) {
+        // Before deactivating, check if boundary messages can still be
+        // found by their stable ID — timestamps can change across
+        // session reloads while the underlying message persists.
+        const startFound = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp) !== -1;
+        const endFound = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp) !== -1;
 
-    const startIdx = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp);
-    const endIdx = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp);
-    if (startIdx === -1 || endIdx === -1) {
-      block.active = false;
-      block.deactivatedReason = "missing-origin-message";
-      writeDcpDebugLog(config, "block.auto_deactivated", {
-        blockId: `b${block.id}`,
-        reason: "missing-origin-message",
-        topic: block.topic,
-        missingBoundary: startIdx === -1 ? "start" : "end",
-        startMessageId: block.startMessageId,
-        endMessageId: block.endMessageId,
-        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
-      });
+        if (!startFound && !endFound) {
+          block.active = false;
+          block.deactivatedReason = "outside-conversation-range";
+          writeDcpDebugLog(config, "block.auto_deactivated", {
+            blockId: `b${block.id}`,
+            reason: "outside-conversation-range",
+            topic: block.topic,
+            blockRange: [block.startTimestamp, block.endTimestamp],
+            conversationRange: [conversationMinTs, conversationMaxTs],
+            activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
+          });
+        }
+      }
     }
   }
 }

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.43",
+  "version": "0.1.45",
   "private": false,
   "type": "module",
   "bin": {

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.