@mystilleef/pi-subagent 0.7.0 → 0.8.0

package/README.md

@@ -151,7 +151,7 @@ executable automation.
 **Environment variables:**
 
 - `PI_SUBAGENT_DEPTH`: nested subagent depth guard. Nested calls stop at
-  depth `2`.
+  depth `3`.
 - `PI_SUBAGENT_MAX_OUTPUT_BYTES`: max returned output bytes. Default:
   `50000`.
 - `PI_SUBAGENT_MAX_OUTPUT_LINES`: max returned output lines. Default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mystilleef/pi-subagent",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Pi subagent for the SPAE Framework",
   "author": "Lateef Alabi-Oki <mystilleef@gmail.com>",
   "license": "MIT",
@@ -48,12 +48,11 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "lint": "biome check --error-on-warnings .",
-    "fix": "biome check --write --unsafe .",
+    "lint": "biome check --write --unsafe --error-on-warnings .",
     "migrate": "biome migrate --write",
     "coverage": "bun test --coverage",
     "check": "bun lint && bun typecheck",
-    "verify": "bun migrate && bun fix && bun typecheck && bun coverage",
+    "verify": "bun migrate && bun check && bun coverage",
     "pack:smoke": "bun scripts/pack-smoke.ts",
     "release": "sh -c 'npm version \"$1\" -m \"chore(release): %s\" && git push --follow-tags' --"
   },
@@ -66,13 +65,13 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.16",
-    "@earendil-works/pi-agent-core": "^0.78.0",
-    "@earendil-works/pi-ai": "^0.78.0",
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.0",
+    "@earendil-works/pi-agent-core": "^0.78.1",
+    "@earendil-works/pi-ai": "^0.78.1",
+    "@earendil-works/pi-coding-agent": "^0.78.1",
+    "@earendil-works/pi-tui": "^0.78.1",
     "@types/bun": "^1.3.14",
     "@types/node": "^25.9.1",
-    "typebox": "^1.1.39",
+    "typebox": "^1.2.1",
     "typescript": "^6.0.3"
   }
 }

package/src/agent/agent-cache.ts

@@ -9,12 +9,14 @@ import {
   discoverAgentsAsync,
   emptyScopeResult,
   getUserAgentsDir,
-  readMarkdownDirEntriesAsync,
+  readMarkdownDirWithStatusAsync,
 } from "./agents.js";
 
 interface AgentDiscoveryScopeSnapshot {
   markdownFiles: string[];
   fileHashes: Record<string, string | null>;
+  listingTrusted: boolean;
+  directory: string | null;
 }
 
 type AgentDiscoverySnapshots = Record<AgentSource, AgentDiscoveryScopeSnapshot>;
@@ -52,7 +54,12 @@ function getFreshCacheEntry(
 }
 
 function emptySnapshot(): AgentDiscoveryScopeSnapshot {
-  return { markdownFiles: [], fileHashes: {} };
+  return {
+    markdownFiles: [],
+    fileHashes: {},
+    listingTrusted: false,
+    directory: null,
+  };
 }
 
 function cloneScopeSnapshot(
@@ -62,6 +69,8 @@ function cloneScopeSnapshot(
   return {
     markdownFiles: [...snapshot.markdownFiles],
     fileHashes: { ...snapshot.fileHashes },
+    listingTrusted: snapshot.listingTrusted,
+    directory: snapshot.directory,
   };
 }
 
@@ -71,14 +80,17 @@ function equalStringSets(a: string[], b: string[]): boolean {
   return b.every((value) => set.has(value));
 }
 
-function snapshotsEqual(
-  left: AgentDiscoveryScopeSnapshot,
-  right: AgentDiscoveryScopeSnapshot,
+function snapshotHasRequiredMetadata(
+  snapshot: AgentDiscoveryScopeSnapshot,
 ): boolean {
-  if (!equalStringSets(left.markdownFiles, right.markdownFiles)) return false;
-  return left.markdownFiles.every(
-    (fileName) => left.fileHashes[fileName] === right.fileHashes[fileName],
-  );
+  if (typeof snapshot.listingTrusted !== "boolean") return false;
+  if (snapshot.directory !== null && typeof snapshot.directory !== "string")
+    return false;
+  if (
+    !equalStringSets(snapshot.markdownFiles, Object.keys(snapshot.fileHashes))
+  )
+    return false;
+  return true;
 }
 
 function scopeAgentsMatchListing(
@@ -118,16 +130,20 @@ async function hashMarkdownFileAsync(
 async function buildScopeSnapshotAsync(
   dir: string | null,
 ): Promise<AgentDiscoveryScopeSnapshot> {
-  if (!dir) return emptySnapshot();
-  const entries = await readMarkdownDirEntriesAsync(dir);
-  const markdownFiles = entries.map((entry) => entry.name);
+  const listing = await readMarkdownDirWithStatusAsync(dir);
+  const markdownFiles = listing.entries.map((entry) => entry.name);
   const hashPairs = await Promise.all(
     markdownFiles.map(
       async (fileName) =>
-        [fileName, await hashMarkdownFileAsync(dir, fileName)] as const,
+        [fileName, await hashMarkdownFileAsync(dir ?? "", fileName)] as const,
     ),
   );
-  return { markdownFiles, fileHashes: Object.fromEntries(hashPairs) };
+  return {
+    markdownFiles,
+    fileHashes: Object.fromEntries(hashPairs),
+    listingTrusted: listing.ok,
+    directory: dir ? path.resolve(dir) : null,
+  };
 }
 
 async function buildCacheSnapshotsAsync(
@@ -146,13 +162,22 @@ async function canTrustDerivedScopeAsync(
 ): Promise<boolean> {
   const dir =
     source === "user" ? getUserAgentsDir() : bothEntry.projectAgentsDir;
+  const resolvedDir = dir ? path.resolve(dir) : null;
   const scopeResult = bothEntry.scopes[source];
   const cachedSnapshot = bothEntry.snapshots?.[source];
   if (!cachedSnapshot) return false;
+  if (!snapshotHasRequiredMetadata(cachedSnapshot)) return false;
+  if (!cachedSnapshot.listingTrusted) return false;
+  if (cachedSnapshot.directory !== resolvedDir) return false;
   if (!scopeAgentsMatchListing(scopeResult, source, dir)) return false;
   if (!equalStringSets(scopeResult.markdownFiles, cachedSnapshot.markdownFiles))
     return false;
-  return snapshotsEqual(cachedSnapshot, await buildScopeSnapshotAsync(dir));
+  const listing = await readMarkdownDirWithStatusAsync(dir);
+  if (!listing.ok) return false;
+  return equalStringSets(
+    cachedSnapshot.markdownFiles,
+    listing.entries.map((entry) => entry.name),
+  );
 }
 
 function buildSourceRecord<T>(
@@ -220,11 +245,14 @@ async function primeScopedCacheEntriesAsync(
   ctx: CacheOperationContext,
   bothEntry: AgentDiscoveryCacheEntry,
 ): Promise<void> {
-  for (const source of AGENT_SOURCES) {
-    const scopedKey = cacheKey(ctx.cwd, source);
-    if (getFreshCacheEntry(ctx, scopedKey)) continue;
-    await deriveOrDiscoverScopedEntryAsync(ctx, source, bothEntry);
-  }
+  const missingSources = AGENT_SOURCES.filter(
+    (source) => !getFreshCacheEntry(ctx, cacheKey(ctx.cwd, source)),
+  );
+  await Promise.all(
+    missingSources.map((source) =>
+      deriveOrDiscoverScopedEntryAsync(ctx, source, bothEntry),
+    ),
+  );
 }
 
 export async function getCachedAgentDiscovery(

package/src/agent/agents.ts

@@ -143,7 +143,7 @@ async function loadAgentsFromDirAsync(
   dir: string,
   source: AgentSource,
 ): Promise<AgentDiscoveryScopeResult> {
-  const markdownEntries = await readMarkdownDirEntriesAsync(dir);
+  const markdownEntries = (await readMarkdownDirWithStatusAsync(dir)).entries;
   const markdownFiles = markdownEntries.map((entry) => entry.name);
   const parsedAgents = await Promise.all(
     markdownEntries.map((entry) =>
@@ -162,15 +162,20 @@ export function isMarkdownDirent(entry: Dirent): boolean {
   );
 }
 
-export async function readMarkdownDirEntriesAsync(
+export interface MarkdownDirListing {
+  entries: Dirent[];
+  ok: boolean;
+}
+
+export async function readMarkdownDirWithStatusAsync(
   dir: string | null,
-): Promise<Dirent[]> {
-  if (!dir) return [];
+): Promise<MarkdownDirListing> {
+  if (!dir) return { entries: [], ok: true };
   try {
     const entries = await fsPromises.readdir(dir, { withFileTypes: true });
-    return entries.filter(isMarkdownDirent);
+    return { entries: entries.filter(isMarkdownDirent), ok: true };
   } catch {
-    return [];
+    return { entries: [], ok: false };
   }
 }
 

package/src/child/process.ts

@@ -73,7 +73,7 @@ export function resolveThinkingLevel(
   return { level: clamped, warning: mkWarning(clamped) };
 }
 
-const MAX_SUBAGENT_DEPTH = 2;
+const MAX_SUBAGENT_DEPTH = 3;
 export const TOOL_RESULT_FAILED_MESSAGE = "Subagent tool result failed.";
 
 type RuntimeResult = SingleResult & { messages: Message[] };

package/src/shared/utils.ts

@@ -89,15 +89,54 @@ export function getPiInvocation(args: string[]): {
   return { command: "pi", args };
 }
 
+const SKILL_DISCOVERY_CACHE_TTL_MS = 300_000;
+
+type ResolvedSkillArgsCacheEntry = {
+  skillPaths: Map<string, string>;
+  ts: number;
+};
+
+const resolvedSkillArgsCache = new Map<string, ResolvedSkillArgsCacheEntry>();
+
+async function canonicalPath(filePath: string): Promise<string> {
+  try {
+    return await fs.promises.realpath(filePath);
+  } catch {
+    return path.resolve(filePath);
+  }
+}
+
+function buildSkillArgs(
+  requested: string[],
+  skillPaths: Map<string, string>,
+): string[] {
+  return requested.flatMap((name) => ["--skill", skillPaths.get(name) ?? name]);
+}
+
+export function resetResolvedAgentSkillArgsCache(): void {
+  resolvedSkillArgsCache.clear();
+}
+
 export async function resolveAgentSkillArgs(
   cwd: string,
   skillNames: string[],
 ): Promise<{ args: string[] } | { error: string }> {
   const requested = Array.from(new Set(skillNames));
   if (requested.length === 0) return { args: [] };
+  const cacheIdentitySkills = [...requested].sort();
+  const agentDir = getAgentDir();
+  const cacheKey = JSON.stringify({
+    cwd: await canonicalPath(cwd),
+    agentDir: await canonicalPath(agentDir),
+    skills: cacheIdentitySkills,
+  });
+  const cached = resolvedSkillArgsCache.get(cacheKey);
+  if (cached && Date.now() - cached.ts <= SKILL_DISCOVERY_CACHE_TTL_MS) {
+    return { args: buildSkillArgs(requested, cached.skillPaths) };
+  }
   const loader = new DefaultResourceLoader({
     cwd,
-    agentDir: getAgentDir(),
+    agentDir,
     noContextFiles: true,
     noPromptTemplates: true,
     noThemes: true,
@@ -124,12 +163,12 @@ export async function resolveAgentSkillArgs(
         .join(", ")}. Available skills: ${available}.`,
     };
   }
-  return {
-    args: requested.flatMap((name) => [
-      "--skill",
-      skillMap.get(name)?.filePath ?? name,
-    ]),
-  };
+  const skillPaths = new Map(
+    requested.map((name) => [name, skillMap.get(name)?.filePath ?? name]),
+  );
+  const args = buildSkillArgs(requested, skillPaths);
+  resolvedSkillArgsCache.set(cacheKey, { skillPaths, ts: Date.now() });
+  return { args };
 }
 
 export function getSubagentDepth(): number {