@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.5

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;
 }
 
 /**
@@ -42,31 +45,14 @@ async function listAvailableOutputs(artifactsDir: string): Promise<string[]> {
  */
 export class AgentProtocolHandler implements ProtocolHandler {
 	readonly scheme = "agent";
-
-	constructor(private readonly options: AgentProtocolOptions) {}
+	readonly immutable = true;
 
 	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 !== "";
@@ -76,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);
@@ -106,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 {
@@ -118,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";
@@ -129,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,86 +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";
-
-	constructor(private readonly options: ArtifactProtocolOptions) {}
+	readonly immutable = true;
 
 	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,
 		};
 	}
 }