@oh-my-pi/pi-coding-agent 14.9.3 → 14.9.7

package/src/export/html/template.js

@@ -456,6 +456,10 @@
               const content = truncate(normalize(extractContent(msg.content)));
               return labelHtml + `<span class="tree-role-user">user:</span> ${escapeHtml(content)}`;
             }
+            if (msg.role === 'developer') {
+              const content = truncate(normalize(extractContent(msg.content)));
+              return labelHtml + `<span class="tree-role-developer">developer:</span> ${escapeHtml(content)}`;
+            }
             if (msg.role === 'assistant') {
               const textContent = truncate(normalize(extractContent(msg.content)));
               if (textContent) {
@@ -1258,12 +1262,14 @@
         return html;
       }
 
-      // Parse `*** Begin <LANG>` cell headers (canonical) and the legacy
-      // `===== <info> =====` headers used by older transcripts. Cells emitted
-      // before the format cutover still need to render in HTML exports.
+      // Parse `*** Cell <attrs>` headers (canonical), plus legacy
+      // `*** Begin <LANG>` headers and `===== <info> =====` bars used in
+      // older transcripts. Cells emitted before each format cutover still
+      // need to render in HTML exports.
       function parseEvalCells(input) {
         const text = String(input);
-        if (/^[*]{2,}\s*Begin\b/im.test(text)) return parseEvalCellsNew(text);
+        if (/^[*]{2,}\s*Cell\b/im.test(text)) return parseEvalCellsCell(text);
+        if (/^[*]{2,}\s*Begin\b/im.test(text)) return parseEvalCellsBegin(text);
         return parseEvalCellsLegacy(text);
       }
 
@@ -1275,7 +1281,93 @@
         return null;
       }
 
-      function parseEvalCellsNew(text) {
+      // Tokenize a `*** Cell` header attribute list, preserving quoted
+      // segments. Mirrors `tokenizeCellAttrs` in src/eval/parse.ts.
+      function tokenizeCellAttrsHtml(input) {
+        const tokens = [];
+        let i = 0;
+        while (i < input.length) {
+          while (i < input.length && /\s/.test(input[i])) i++;
+          if (i >= input.length) break;
+          let tok = '';
+          while (i < input.length && !/\s/.test(input[i])) {
+            const ch = input[i];
+            if (ch === '"' || ch === "'") {
+              tok += ch; i++;
+              while (i < input.length && input[i] !== ch) { tok += input[i]; i++; }
+              if (i < input.length) { tok += input[i]; i++; }
+            } else { tok += ch; i++; }
+          }
+          tokens.push(tok);
+        }
+        return tokens;
+      }
+
+      function parseEvalCellsCell(text) {
+        const STARS = '\\*{2,}';
+        const CELL = new RegExp('^' + STARS + '\\s*Cell\\b\\s*(.*)$', 'i');
+        const END = new RegExp('^' + STARS + '\\s*End\\b.*$', 'i');
+        const ATTR = /^([a-zA-Z][\w-]*)(?::(?:"([^"]*)"|'([^']*)'|(.*)))?$/;
+        const DUR = /^\d+(?:ms|s|m)?$/;
+        const ID_KEYS = ['id', 'title', 'name', 'cell', 'file', 'label'];
+        const T_KEYS = ['t', 'timeout', 'duration', 'time'];
+        const RST_KEYS = ['rst', 'reset'];
+        const lines = text.split('\n');
+        if (lines.length && lines[lines.length - 1] === '') lines.pop();
+        const cells = [];
+        let i = 0;
+        while (i < lines.length && lines[i].trim() === '') i++;
+        while (i < lines.length) {
+          const m = CELL.exec(lines[i]);
+          if (!m) { i++; continue; }
+          const tokens = tokenizeCellAttrsHtml(m[1] || '');
+          let lang = null;
+          let title = '';
+          const attrs = [];
+          let bareReset = false;
+          const titleParts = [];
+          for (const tok of tokens) {
+            const lower = tok.toLowerCase();
+            if (RST_KEYS.indexOf(lower) >= 0) { bareReset = true; continue; }
+            const am = ATTR.exec(tok);
+            if (am && tok.indexOf(':') >= 0) {
+              const key = am[1].toLowerCase();
+              const value = am[2] !== undefined ? am[2] : am[3] !== undefined ? am[3] : (am[4] || '');
+              const lc = evalLangAlias(key);
+              if (lc) {
+                if (!lang) lang = lc;
+                if (!title && value) title = value;
+                continue;
+              }
+              if (ID_KEYS.indexOf(key) >= 0) { if (!title) title = value; continue; }
+              if (T_KEYS.indexOf(key) >= 0) { attrs.push('t=' + value); continue; }
+              if (RST_KEYS.indexOf(key) >= 0) { attrs.push('rst'); continue; }
+              continue;
+            }
+            const lc = evalLangAlias(tok);
+            if (lc && !lang) { lang = lc; continue; }
+            if (DUR.test(tok)) { attrs.push('t=' + tok); continue; }
+            titleParts.push(tok);
+          }
+          if (!title && titleParts.length) title = titleParts.join(' ');
+          if (bareReset) attrs.push('rst');
+          lang = lang || 'py';
+          i++;
+          const codeLines = [];
+          while (i < lines.length) {
+            if (END.test(lines[i])) { i++; break; }
+            if (CELL.test(lines[i])) break;
+            codeLines.push(lines[i]);
+            i++;
+          }
+          while (codeLines.length && codeLines[codeLines.length - 1].trim() === '') codeLines.pop();
+          cells.push({ lang, title, attrs, code: codeLines.join('\n') });
+          while (i < lines.length && lines[i].trim() === '') i++;
+        }
+        return cells;
+      }
+
+      function parseEvalCellsBegin(text) {
         const STARS = '\\*{2,}';
         const BEGIN = new RegExp('^' + STARS + '\\s*Begin\\b\\s*(\\S+)?\\s*$', 'i');
         const END = new RegExp('^' + STARS + '\\s*End\\b.*$', 'i');
@@ -1648,6 +1740,18 @@
             return html;
           }
 
+          if (msg.role === 'developer') {
+            let html = `<div class="user-message developer-message" id="${entryId}">${copyBtnHtml}${tsHtml}`;
+            const content = msg.content;
+            const text = typeof content === 'string' ? content :
+              content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+            if (text.trim()) {
+              html += `<div class="markdown-content">${safeMarkedParse(text)}</div>`;
+            }
+            html += '</div>';
+            return html;
+          }
+
           if (msg.role === 'assistant') {
             let html = `<div class="assistant-message" id="${entryId}">${copyBtnHtml}${tsHtml}`;
 
@@ -1750,7 +1854,7 @@
       // ============================================================
 
       function computeStats(entryList) {
-        let userMessages = 0, assistantMessages = 0, toolResults = 0;
+        let userMessages = 0, developerMessages = 0, assistantMessages = 0, toolResults = 0;
         let customMessages = 0, compactions = 0, branchSummaries = 0, toolCalls = 0;
         const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
         const cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -1760,6 +1864,7 @@
           if (entry.type === 'message') {
             const msg = entry.message;
             if (msg.role === 'user') userMessages++;
+            if (msg.role === 'developer') developerMessages++;
             if (msg.role === 'assistant') {
               assistantMessages++;
               if (msg.model) models.add(msg.provider ? `${msg.provider}/${msg.model}` : msg.model);
@@ -1787,7 +1892,7 @@
           }
         }
 
-        return { userMessages, assistantMessages, toolResults, customMessages, compactions, branchSummaries, toolCalls, tokens, cost, models: Array.from(models) };
+        return { userMessages, developerMessages, assistantMessages, toolResults, customMessages, compactions, branchSummaries, toolCalls, tokens, cost, models: Array.from(models) };
       }
 
       const globalStats = computeStats(entries);
@@ -1803,6 +1908,7 @@
 
         const msgParts = [];
         if (globalStats.userMessages) msgParts.push(`${globalStats.userMessages} user`);
+        if (globalStats.developerMessages) msgParts.push(`${globalStats.developerMessages} developer`);
         if (globalStats.assistantMessages) msgParts.push(`${globalStats.assistantMessages} assistant`);
         if (globalStats.toolResults) msgParts.push(`${globalStats.toolResults} tool results`);
         if (globalStats.customMessages) msgParts.push(`${globalStats.customMessages} custom`);

package/src/extensibility/plugins/loader.ts

@@ -117,6 +117,31 @@ export async function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]>
 // Path Resolution
 // =============================================================================
 
+const MANIFEST_ENTRY_INDEX_NAMES = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+
+/**
+ * Resolve a plugin manifest entry to a concrete loadable file path. Returns the
+ * file path itself when the entry points at a file, the matching index file when
+ * the entry points at a directory containing index.{ts,js,mjs,cjs}, and null
+ * when no entry exists at the joined path.
+ */
+function resolveManifestEntryFile(joined: string): string | null {
+	let stats: fs.Stats;
+	try {
+		stats = fs.statSync(joined);
+	} catch {
+		return null;
+	}
+	if (stats.isDirectory()) {
+		for (const name of MANIFEST_ENTRY_INDEX_NAMES) {
+			const candidate = path.join(joined, name);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+		return null;
+	}
+	return joined;
+}
+
 /**
  * Generic path resolver for plugin manifest entries (tools, hooks, commands, extensions).
  * Handles both single-string and string[] base entries, plus feature-specific entries.
@@ -130,8 +155,8 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
 	if (base) {
 		const entries = Array.isArray(base) ? base : [base];
 		for (const entry of entries) {
-			const resolved = path.join(plugin.path, entry);
-			if (fs.existsSync(resolved)) {
+			const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
+			if (resolved) {
 				paths.push(resolved);
 			}
 		}
@@ -146,8 +171,8 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
 
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = path.join(plugin.path, entry);
-					if (fs.existsSync(resolved)) {
+					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
+					if (resolved) {
 						paths.push(resolved);
 					}
 				}
@@ -160,8 +185,8 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
 
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = path.join(plugin.path, entry);
-					if (fs.existsSync(resolved)) {
+					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
+					if (resolved) {
 						paths.push(resolved);
 					}
 				}

package/src/extensibility/skills.ts

@@ -28,6 +28,26 @@ export interface LoadSkillsResult {
 	warnings: SkillWarning[];
 }
 
+let activeSkills: readonly Skill[] = [];
+
+/**
+ * Process-global snapshot of skills the active session loaded.
+ * Read by internal URL protocol handlers (skill://).
+ */
+export function getActiveSkills(): readonly Skill[] {
+	return activeSkills;
+}
+
+/** Replace the active skill snapshot. Called once per top-level session. */
+export function setActiveSkills(value: readonly Skill[]): void {
+	activeSkills = value;
+}
+
+/** Reset the active skill snapshot. Test-only. */
+export function resetActiveSkillsForTests(): void {
+	activeSkills = [];
+}
+
 export interface LoadSkillsFromDirOptions {
 	/** Directory to scan for skills */
 	dir: string;

package/src/internal-urls/agent-protocol.ts

@@ -1,7 +1,10 @@
 /**
  * Protocol handler for agent:// URLs.
  *
- * Resolves agent output IDs to artifact files in the session directory.
+ * Resolves agent output IDs against the artifacts directories of every active
+ * session. Parents and subagents share outputs via this registry: a subagent
+ * can read its parent's output IDs because both sessions are registered in
+ * the shared context.
  *
  * URL forms:
  * - agent://<id> - Full output content
@@ -11,27 +14,27 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
+import { AgentRegistry } from "../registry/agent-registry";
 import { applyQuery, pathToQuery } from "./json-query";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-export interface AgentProtocolOptions {
-	/**
-	 * Returns the artifacts directory path, or null if no session.
-	 * Artifacts directory is the session file path without .jsonl extension.
-	 */
-	getArtifactsDir: () => string | null;
-}
-
 /**
- * List available output IDs in artifacts directory.
+ * Snapshot of artifacts dirs for every registered session, deduped.
+ *
+ * Prefers `sessionManager.getArtifactsDir()` because subagents adopt the
+ * parent's manager and report the parent's dir there; dedup then collapses
+ * the whole agent tree to one entry. Falls back to the raw session file
+ * when no live session reference is attached.
  */
-async function listAvailableOutputs(artifactsDir: string): Promise<string[]> {
-	try {
-		const files = await fs.readdir(artifactsDir);
-		return files.filter(f => f.endsWith(".md")).map(f => f.replace(".md", ""));
-	} catch {
-		return [];
+function artifactsDirsFromRegistry(): string[] {
+	const dirs: string[] = [];
+	for (const ref of AgentRegistry.global().list()) {
+		const dir =
+			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
+		if (!dir) continue;
+		if (!dirs.includes(dir)) dirs.push(dir);
 	}
+	return dirs;
 }
 
 /**
@@ -44,30 +47,12 @@ export class AgentProtocolHandler implements ProtocolHandler {
 	readonly scheme = "agent";
 	readonly immutable = true;
 
-	constructor(private readonly options: AgentProtocolOptions) {}
-
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const artifactsDir = this.options.getArtifactsDir();
-		if (!artifactsDir) {
-			throw new Error("No session - agent outputs unavailable");
-		}
-
-		try {
-			await fs.stat(artifactsDir);
-		} catch (err) {
-			if (isEnoent(err)) {
-				throw new Error("No artifacts directory found");
-			}
-			throw err;
-		}
-
-		// Extract output ID from host
 		const outputId = url.rawHost || url.hostname;
 		if (!outputId) {
 			throw new Error("agent:// URL requires an output ID: agent://<id>");
 		}
 
-		// Check for conflicting extraction methods
 		const urlPath = url.pathname;
 		const queryParam = url.searchParams.get("q");
 		const hasPathExtraction = urlPath && urlPath !== "/" && urlPath !== "";
@@ -77,28 +62,57 @@ export class AgentProtocolHandler implements ProtocolHandler {
 			throw new Error("agent:// URL cannot combine path extraction with ?q=");
 		}
 
-		// Load the output file
-		const outputPath = path.join(artifactsDir, `${outputId}.md`);
-		try {
-			await fs.stat(outputPath);
-		} catch (err) {
-			if (isEnoent(err)) {
-				const available = await listAvailableOutputs(artifactsDir);
-				const availableStr = available.length > 0 ? available.join(", ") : "none";
-				throw new Error(`Not found: ${outputId}\nAvailable: ${availableStr}`);
+		const dirs = artifactsDirsFromRegistry();
+
+		if (dirs.length === 0) {
+			throw new Error("No session - agent outputs unavailable");
+		}
+
+		let foundPath: string | undefined;
+		let anyDirExists = false;
+		const availableIds = new Set<string>();
+
+		for (const dir of dirs) {
+			try {
+				await fs.stat(dir);
+				anyDirExists = true;
+			} catch (err) {
+				if (isEnoent(err)) continue;
+				throw err;
+			}
+			const candidate = path.join(dir, `${outputId}.md`);
+			try {
+				await fs.stat(candidate);
+				foundPath = candidate;
+				break;
+			} catch (err) {
+				if (!isEnoent(err)) throw err;
+				try {
+					const files = await fs.readdir(dir);
+					for (const f of files) {
+						if (f.endsWith(".md")) availableIds.add(f.replace(/\.md$/, ""));
+					}
+				} catch {
+					// Listing failures are non-fatal; continue searching.
+				}
 			}
-			throw err;
 		}
 
-		const rawContent = await Bun.file(outputPath).text();
-		const notes: string[] = [];
+		if (!anyDirExists) {
+			throw new Error("No artifacts directory found");
+		}
 
-		// Handle extraction
+		if (!foundPath) {
+			const availableStr = availableIds.size > 0 ? [...availableIds].join(", ") : "none";
+			throw new Error(`Not found: ${outputId}\nAvailable: ${availableStr}`);
+		}
+
+		const rawContent = await Bun.file(foundPath).text();
+		const notes: string[] = [];
 		let content = rawContent;
 		let contentType: InternalResource["contentType"] = "text/markdown";
 
 		if (hasPathExtraction || hasQueryExtraction) {
-			// Parse JSON
 			let jsonValue: unknown;
 			try {
 				jsonValue = JSON.parse(rawContent);
@@ -107,9 +121,7 @@ export class AgentProtocolHandler implements ProtocolHandler {
 				throw new Error(`Output ${outputId} is not valid JSON: ${message}`);
 			}
 
-			// Convert path to query if needed
 			const query = hasPathExtraction ? pathToQuery(urlPath) : queryParam!;
-
 			if (query) {
 				const extracted = applyQuery(jsonValue, query);
 				try {
@@ -119,7 +131,6 @@ export class AgentProtocolHandler implements ProtocolHandler {
 				}
 				notes.push(`Extracted: ${query}`);
 			} else {
-				// Empty path/query means return full JSON
 				content = JSON.stringify(jsonValue, null, 2);
 			}
 			contentType = "application/json";
@@ -130,7 +141,7 @@ export class AgentProtocolHandler implements ProtocolHandler {
 			content,
 			contentType,
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: outputPath,
+			sourcePath: foundPath,
 			notes,
 		};
 	}

package/src/internal-urls/artifact-protocol.ts

@@ -1,8 +1,8 @@
 /**
  * Protocol handler for artifact:// URLs.
  *
- * Resolves artifact IDs to files in the session artifacts directory.
- * Unlike agent://, artifacts are raw text with no JSON extraction.
+ * Resolves artifact IDs against the artifacts directories of every active
+ * session. Unlike agent://, artifacts are raw text with no JSON extraction.
  *
  * URL form:
  * - artifact://<id> - Full artifact content
@@ -12,87 +12,87 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
+import { AgentRegistry } from "../registry/agent-registry";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-export interface ArtifactProtocolOptions {
-	/**
-	 * Returns the artifacts directory path, or null if no session.
-	 */
-	getArtifactsDir: () => string | null;
-}
-
 /**
- * List available artifact IDs in the directory.
+ * Snapshot of artifacts dirs across all registered sessions, deduped.
+ *
+ * Subagents adopt their parent's `ArtifactManager`, so their
+ * `sessionManager.getArtifactsDir()` returns the parent's dir; dedup
+ * collapses parent + N subagents to a single entry.
  */
-async function listAvailableArtifacts(artifactsDir: string): Promise<string[]> {
-	try {
-		const files = await fs.readdir(artifactsDir);
-		return files
-			.filter(f => /^\d+\./.test(f))
-			.map(f => f.split(".")[0])
-			.sort((a, b) => Number(a) - Number(b));
-	} catch {
-		return [];
+function artifactsDirsFromRegistry(): string[] {
+	const dirs: string[] = [];
+	for (const ref of AgentRegistry.global().list()) {
+		const dir =
+			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
+		if (!dir) continue;
+		if (!dirs.includes(dir)) dirs.push(dir);
 	}
+	return dirs;
 }
 
-/**
- * Handler for artifact:// URLs.
- *
- * Resolves numeric artifact IDs to their text content.
- * Artifacts are created by tools when output is truncated.
- */
 export class ArtifactProtocolHandler implements ProtocolHandler {
 	readonly scheme = "artifact";
 	readonly immutable = true;
 
-	constructor(private readonly options: ArtifactProtocolOptions) {}
-
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const artifactsDir = this.options.getArtifactsDir();
-		if (!artifactsDir) {
-			throw new Error("No session - artifacts unavailable");
-		}
-
-		// Extract artifact ID from host
 		const id = url.rawHost || url.hostname;
 		if (!id) {
 			throw new Error("artifact:// URL requires a numeric ID: artifact://0");
 		}
-
-		// Validate ID is numeric
 		if (!/^\d+$/.test(id)) {
 			throw new Error(`artifact:// ID must be numeric, got: ${id}`);
 		}
 
-		// Check directory exists and find file matching ID prefix
-		let files: string[];
-		try {
-			files = await fs.readdir(artifactsDir);
-		} catch (err) {
-			if (isEnoent(err)) {
-				throw new Error("No artifacts directory found");
+		const dirs = artifactsDirsFromRegistry();
+
+		if (dirs.length === 0) {
+			throw new Error("No session - artifacts unavailable");
+		}
+
+		let foundPath: string | undefined;
+		let anyDirExists = false;
+		const availableIds = new Set<string>();
+
+		for (const dir of dirs) {
+			let files: string[];
+			try {
+				files = await fs.readdir(dir);
+				anyDirExists = true;
+			} catch (err) {
+				if (isEnoent(err)) continue;
+				throw err;
+			}
+			const match = files.find(f => f.startsWith(`${id}.`));
+			if (match) {
+				foundPath = path.join(dir, match);
+				break;
+			}
+			for (const f of files) {
+				const m = f.match(/^(\d+)\./);
+				if (m) availableIds.add(m[1]);
 			}
-			throw err;
 		}
 
-		const match = files.find(f => f.startsWith(`${id}.`));
+		if (!anyDirExists) {
+			throw new Error("No artifacts directory found");
+		}
 
-		if (!match) {
-			const available = await listAvailableArtifacts(artifactsDir);
-			const availableStr = available.length > 0 ? available.join(", ") : "none";
+		if (!foundPath) {
+			const sorted = [...availableIds].sort((a, b) => Number(a) - Number(b));
+			const availableStr = sorted.length > 0 ? sorted.join(", ") : "none";
 			throw new Error(`Artifact ${id} not found. Available: ${availableStr}`);
 		}
 
-		const filePath = path.join(artifactsDir, match);
-		const content = await Bun.file(filePath).text();
-
+		const content = await Bun.file(foundPath).text();
 		return {
 			url: url.href,
 			content,
 			contentType: "text/plain",
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: filePath,
+			sourcePath: foundPath,
 		};
 	}
 }