@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/shared/agent-context-policy.js

@@ -1,47 +1,47 @@
-import { getStepAgents, isDynamicParallelStep, isParallelStep } from "./settings.js";
+import { getStepAgents, isDynamicParallelStep, isParallelStep, } from "./settings.js";
 import { createForkContextResolver, resolveSubagentContext } from "./fork-context.js";
 import { wrapForkTask } from "./types.js";
 export function resolveAgentContext(explicitContext, agentName, agents) {
     if (explicitContext !== undefined) {
         return resolveSubagentContext(explicitContext);
     }
-    if (!agentName)
+    if (agentName === undefined || agentName === "") {
         return "fresh";
+    }
     const agent = agents.find((entry) => entry.name === agentName);
     return agent?.defaultContext === "fork" ? "fork" : "fresh";
 }
+function chainAgentTargets(step) {
+    if (isParallelStep(step)) {
+        return step.parallel.map((task) => ({ agent: task.agent, model: task.model }));
+    }
+    const task = isDynamicParallelStep(step) ? step.parallel : step;
+    return [{ agent: task.agent, model: task.model }];
+}
 function collectInvocationAgentTargets(params) {
-    if (params.tasks?.length) {
+    if (params.tasks !== undefined && params.tasks.length > 0) {
         return params.tasks.map((task) => ({ agent: task.agent, model: task.model }));
     }
-    if (params.chain?.length) {
-        const targets = [];
-        for (const step of params.chain) {
-            if (isParallelStep(step)) {
-                for (const task of step.parallel)
-                    targets.push({ agent: task.agent, model: task.model });
-            }
-            else if (isDynamicParallelStep(step)) {
-                targets.push({ agent: step.parallel.agent, model: step.parallel.model });
-            }
-            else {
-                targets.push({ agent: step.agent, model: step.model });
-            }
-        }
-        return targets;
+    if (params.chain !== undefined && params.chain.length > 0) {
+        return params.chain.flatMap(chainAgentTargets);
     }
-    return params.agent ? [{ agent: params.agent, model: params.model }] : [];
+    return params.agent !== undefined && params.agent !== ""
+        ? [{ agent: params.agent, model: params.model }]
+        : [];
 }
 export function validateForkContextModelPolicy(params, agents, resolveModel) {
     for (const target of collectInvocationAgentTargets(params)) {
         const agent = agents.find((entry) => entry.name === target.agent);
-        if (!agent || resolveAgentContext(params.context, target.agent, agents) !== "fork")
+        if (!agent || resolveAgentContext(params.context, target.agent, agents) !== "fork") {
             continue;
-        const anthropicModel = (target.model ? [target.model] : [agent.model, ...(agent.fallbackModels ?? [])])
+        }
+        const anthropicModel = (target.model !== undefined && target.model !== ""
+            ? [target.model]
+            : [agent.model, ...(agent.fallbackModels ?? [])])
             .filter((model) => Boolean(model?.trim()))
             .map((model) => resolveModel?.(model) ?? model)
             .find((model) => model.trim().toLowerCase().startsWith("anthropic/"));
-        if (anthropicModel) {
+        if (anthropicModel !== undefined && anthropicModel !== "") {
             return `Fork context cannot be used with anthropic/* models. Agent '${target.agent}' has effective model candidate '${anthropicModel}'. Use context: "fresh" or a non-Anthropic model; this restriction cannot be overridden.`;
         }
     }
@@ -54,28 +54,16 @@ export function invocationUsesForkContext(explicitContext, agentNames, agents) {
     return agentNames.some((name) => resolveAgentContext(undefined, name, agents) === "fork");
 }
 export function buildFlatAgentNameResolver(params) {
-    if (params.agent && !params.tasks?.length && !params.chain?.length) {
-        return () => params.agent;
+    if ((params.tasks?.length ?? 0) > 0 || (params.chain?.length ?? 0) > 0) {
+        const names = collectInvocationAgentTargets(params).map((target) => target.agent);
+        return (index) => names[index];
     }
-    if (params.tasks?.length) {
-        return (index) => params.tasks[index]?.agent;
-    }
-    if (params.chain?.length) {
-        const flatAgents = [];
-        for (const step of params.chain) {
-            if (isParallelStep(step)) {
-                for (const task of step.parallel)
-                    flatAgents.push(task.agent);
-                continue;
-            }
-            flatAgents.push(...getStepAgents(step));
-        }
-        return (index) => flatAgents[index];
-    }
-    return () => undefined;
+    return () => (params.agent === "" ? undefined : params.agent);
 }
 export function wrapTaskForAgentContext(task, explicitContext, agentName, agents) {
-    return resolveAgentContext(explicitContext, agentName, agents) === "fork" ? wrapForkTask(task) : task;
+    return resolveAgentContext(explicitContext, agentName, agents) === "fork"
+        ? wrapForkTask(task)
+        : task;
 }
 export function wrapChainTasksForAgentContext(chain, explicitContext, agents) {
     return chain.map((step, stepIndex) => {
@@ -108,10 +96,12 @@ export function wrapChainTasksForAgentContext(chain, explicitContext, agents) {
 export function createPerAgentForkContextResolver(sessionManager, resolveContextForIndex, options = {}) {
     let forkResolver;
     const sessionFileForContext = (context, index = 0) => {
-        if (context !== "fork")
+        if (context !== "fork") {
             return undefined;
-        if (!forkResolver)
-            forkResolver = createForkContextResolver(sessionManager, "fork");
+        }
+        if (!forkResolver) {
+            forkResolver = createForkContextResolver(sessionManager);
+        }
         return forkResolver.sessionFileForIndex(index);
     };
     return {

package/dist/shared/agent-dir.js

@@ -0,0 +1,14 @@
+import * as os from "node:os";
+import * as path from "node:path";
+export function getAgentDir() {
+    const configured = process.env.PI_CODING_AGENT_DIR;
+    if (configured === "~") {
+        return os.homedir();
+    }
+    if (configured?.startsWith("~/") === true) {
+        return path.join(os.homedir(), configured.slice(2));
+    }
+    return configured !== undefined && configured !== ""
+        ? configured
+        : path.join(os.homedir(), ".pi", "agent");
+}

package/dist/shared/artifacts.js

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { TEMP_ARTIFACTS_DIR } from "./types.js";
-import { getAgentDir } from "./utils.js";
+import { getAgentDir } from "./agent-dir.js";
 import { ensureSafeTempPath } from "./temp-root.js";
+import { hasErrorCode } from "./unknown.js";
 const CLEANUP_MARKER_FILE = ".last-cleanup";
 export const ARTIFACT_CLEANUP_DAYS = 7;
 export function getArtifactsDir(sessionFile) {
-    if (sessionFile) {
+    if (sessionFile !== null && sessionFile !== "") {
         const sessionDir = path.dirname(sessionFile);
         return path.join(sessionDir, "subagent-artifacts");
     }
@@ -26,35 +27,49 @@ export function getArtifactPaths(artifactsDir, runId, agent, index) {
 export function appendJsonl(filePath, line) {
     fs.appendFileSync(filePath, `${line}\n`);
 }
-export async function cleanupOldArtifacts(dir, maxAgeDays) {
-    ensureSafeTempPath(dir);
+async function claimCleanup(dir, now) {
     try {
         await fs.promises.access(dir);
     }
     catch {
-        return;
+        return false;
     }
     const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-    const now = Date.now();
     try {
         const stat = await fs.promises.lstat(markerPath);
-        if (!stat.isSymbolicLink() && now - stat.mtimeMs < 24 * 60 * 60 * 1000)
-            return;
+        if (!stat.isSymbolicLink() && now - stat.mtimeMs < 24 * 60 * 60 * 1000) {
+            return false;
+        }
         await fs.promises.unlink(markerPath);
     }
     catch (error) {
-        if (error.code !== "ENOENT")
-            return;
+        if (!hasErrorCode(error, "ENOENT")) {
+            return false;
+        }
     }
+    return true;
+}
+export async function cleanupOldArtifacts(dir, maxAgeDays) {
+    ensureSafeTempPath(dir);
+    const now = Date.now();
+    if (!(await claimCleanup(dir, now))) {
+        return;
+    }
+    const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
     const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
     const cutoff = now - maxAgeMs;
     for (const file of await fs.promises.readdir(dir)) {
-        if (file === CLEANUP_MARKER_FILE)
+        if (file === CLEANUP_MARKER_FILE) {
             continue;
+        }
         const filePath = path.join(dir, file);
         try {
+            // Process one filesystem entry at a time to keep cleanup's I/O bounded.
+            // oxlint-disable-next-line no-await-in-loop
             const stat = await fs.promises.lstat(filePath);
             if (stat.mtimeMs < cutoff) {
+                // Finish deleting this entry before inspecting the next artifact.
+                // oxlint-disable-next-line no-await-in-loop
                 await fs.promises.unlink(filePath);
             }
         }
@@ -67,8 +82,9 @@ export async function cleanupOldArtifacts(dir, maxAgeDays) {
         await fs.promises.writeFile(markerPath, String(now), { flag: "wx", mode: 0o600 });
     }
     catch (error) {
-        if (error.code !== "EEXIST")
+        if (!hasErrorCode(error, "EEXIST")) {
             throw error;
+        }
     }
 }
 export async function cleanupAllArtifactDirs(maxAgeDays) {
@@ -86,6 +102,8 @@ export async function cleanupAllArtifactDirs(maxAgeDays) {
     for (const dir of dirs) {
         const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
         try {
+            // Finish each session directory before starting another retention scan.
+            // oxlint-disable-next-line no-await-in-loop
             await cleanupOldArtifacts(artifactsDir, maxAgeDays);
         }
         catch {

package/dist/shared/atomic-json.js

@@ -4,7 +4,10 @@ export function writeAtomicJson(filePath, payload) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
     try {
-        fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), { encoding: "utf-8", mode: 0o600 });
+        fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
         fs.renameSync(tempPath, filePath);
     }
     finally {

package/dist/shared/chain-files.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CHAIN_RUNS_DIR } from "./types.js";
+import { ensureSafeTempPath, ensureTempRoot } from "./temp-root.js";
+const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
+export function createChainDir(runId, baseDir, cwd = process.cwd()) {
+    const customBase = baseDir !== undefined && baseDir.length > 0;
+    if (!customBase) {
+        ensureTempRoot();
+    }
+    const chainDir = path.join(customBase ? path.resolve(cwd, baseDir) : CHAIN_RUNS_DIR, runId);
+    if (!customBase) {
+        ensureSafeTempPath(chainDir);
+    }
+    fs.mkdirSync(chainDir, { recursive: true });
+    return chainDir;
+}
+export function removeChainDir(chainDir) {
+    try {
+        fs.rmSync(chainDir, { recursive: true });
+    }
+    catch {
+        // Cleanup is best effort; another run may already have removed the directory.
+    }
+}
+async function cleanupOldDirectory(dir, now) {
+    try {
+        const dirPath = path.join(CHAIN_RUNS_DIR, dir);
+        const stat = await fs.promises.lstat(dirPath);
+        if (stat.isDirectory() && now - stat.mtimeMs > CHAIN_DIR_MAX_AGE_MS) {
+            await fs.promises.rm(dirPath, { recursive: true });
+        }
+    }
+    catch {
+        // One unreadable directory must not prevent cleanup of the remaining runs.
+    }
+}
+export async function cleanupOldChainDirs() {
+    ensureSafeTempPath(CHAIN_RUNS_DIR);
+    const now = Date.now();
+    let dirs;
+    try {
+        dirs = await fs.promises.readdir(CHAIN_RUNS_DIR);
+    }
+    catch {
+        // An unreadable scoped temp root must not fail extension startup.
+        return;
+    }
+    for (const dir of dirs) {
+        // Preserve the existing one-directory resource bound throughout startup pruning.
+        // oxlint-disable-next-line no-await-in-loop
+        await cleanupOldDirectory(dir, now);
+    }
+}
+export function writeInitialProgressFile(progressDir) {
+    fs.mkdirSync(progressDir, { recursive: true });
+    try {
+        fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT, {
+            encoding: "utf-8",
+            flag: "wx",
+        });
+    }
+    catch (error) {
+        if (typeof error !== "object" ||
+            error === null ||
+            !("code" in error) ||
+            error.code !== "EEXIST") {
+            throw error;
+        }
+    }
+}

package/dist/shared/concurrency.js

@@ -0,0 +1,18 @@
+/** A bounded worker pool. Results retain input order even when workers finish out of order. */
+export async function mapConcurrent(items, limit, fn) {
+    const integralLimit = Math.floor(limit);
+    const safeLimit = Math.max(1, Number.isNaN(integralLimit) || integralLimit === 0 ? 1 : integralLimit);
+    const results = [];
+    results.length = items.length;
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next++;
+            // Each worker awaits its own task before claiming another, bounding active work.
+            // oxlint-disable-next-line no-await-in-loop
+            results[index] = await fn(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, () => worker()));
+    return results;
+}

package/dist/shared/content-preview.js

@@ -0,0 +1,115 @@
+import { isRecord, isUnknownArray } from "./unknown.js";
+function truncate(value, length) {
+    return value.length > length ? `${value.slice(0, length - 3)}...` : value;
+}
+function scalar(value) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return undefined;
+}
+function array(value) {
+    if (!isUnknownArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const first = scalar(value[0]);
+    if (first === undefined || first === "") {
+        return undefined;
+    }
+    return `${first}${value.length > 1 ? ` (+${value.length - 1} more)` : ""}`;
+}
+function mcpPreview(args) {
+    if (typeof args.tool === "string" && args.tool !== "") {
+        const server = typeof args.server === "string" && args.server !== "" ? `${args.server}/` : "";
+        const toolArgs = typeof args.args === "string" && args.args !== "" ? ` ${args.args.slice(0, 40)}` : "";
+        return `${server}${args.tool}${toolArgs}`;
+    }
+    return undefined;
+}
+function primaryPreview(args) {
+    const mcp = mcpPreview(args);
+    if (mcp !== undefined) {
+        return mcp;
+    }
+    const queries = array(args.queries);
+    if (queries !== undefined) {
+        return truncate(queries, 60);
+    }
+    if (typeof args.query === "string" && args.query.trim().length > 0) {
+        return truncate(args.query, 60);
+    }
+    if (typeof args.workflow === "string" && args.workflow.trim().length > 0) {
+        return `workflow=${truncate(args.workflow, 48)}`;
+    }
+    return undefined;
+}
+function secondaryPreview(args) {
+    if (typeof args.url === "string" && args.url.trim().length > 0) {
+        return truncate(args.url, 60);
+    }
+    const urls = array(args.urls);
+    if (urls !== undefined) {
+        return truncate(urls, 60);
+    }
+    if (typeof args.prompt === "string" && args.prompt.trim().length > 0) {
+        return truncate(args.prompt, 60);
+    }
+    for (const key of [
+        "command",
+        "path",
+        "file_path",
+        "pattern",
+        "query",
+        "url",
+        "task",
+        "describe",
+        "search",
+    ]) {
+        const value = args[key];
+        if (typeof value === "string" && value !== "") {
+            return truncate(value, 60);
+        }
+    }
+    return undefined;
+}
+/** Ordered tool-specific previews, then the first printable unknown argument. */
+export function extractToolArgsPreview(args) {
+    const selected = primaryPreview(args) ?? secondaryPreview(args);
+    if (selected !== undefined) {
+        return selected;
+    }
+    for (const [key, value] of Object.entries(args)) {
+        const preview = array(value);
+        if (preview !== undefined) {
+            return `${key}=${truncate(preview, 50)}`;
+        }
+        if (typeof value === "string" && value.length > 0) {
+            return `${key}=${truncate(value, 50)}`;
+        }
+    }
+    return "";
+}
+function partText(part) {
+    if (!isRecord(part)) {
+        return "";
+    }
+    if (part.type === "tool_result") {
+        return extractTextFromContent(part.content);
+    }
+    return typeof part.text === "string" ? part.text : "";
+}
+/** External content is accepted only as strings or known text/content fields. */
+export function extractTextFromContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return isUnknownArray(content)
+        ? content
+            .map(partText)
+            .filter((text) => text !== "")
+            .join("\n")
+        : "";
+}

package/dist/shared/cooperative.js

@@ -1,17 +1,20 @@
 import { setImmediate as yieldToInput } from "node:timers/promises";
 export function runSynchronously(steps) {
     let step = steps.next();
-    while (!step.done)
+    while (step.done !== true) {
         step = steps.next();
+    }
     return step.value;
 }
 /** Batched recovery and delivery leave room for input between records. */
 export async function runCooperatively(steps) {
     let step = steps.next();
-    for (let count = 0; !step.done; step = steps.next()) {
+    for (let count = 0; step.done !== true; step = steps.next()) {
         // ponytail: one recovery record remains atomic; move a demonstrated
         // single-record stall off-thread rather than increasing this batch size.
         if (++count === 32) {
+            // Yield between ordered atomic recovery records; concurrency would reorder delivery.
+            // oxlint-disable-next-line no-await-in-loop
             await yieldToInput();
             count = 0;
         }

package/dist/shared/execution-cwd.js

@@ -1,13 +1,21 @@
 import { hasExecutionCwdOwner } from "../runs/shared/child-execution-cwd.js";
+function validateDirectoryReply(result) {
+    if (result?.error !== undefined && result.error !== "") {
+        throw new Error(result.error);
+    }
+    if (result && (result.cwd === undefined || result.cwd === "")) {
+        throw new Error("Working-directory owner did not return an execution directory.");
+    }
+}
 /** Capture the active directory owner once per invocation, before asynchronous preparation. */
 export function resolveExecutionCwd(pi, ctx) {
     const request = { sessionManager: ctx.sessionManager };
     pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
-    if (request.result?.error)
-        throw new Error(request.result.error);
-    if (request.result && !request.result.cwd)
-        throw new Error("Working-directory owner did not return an execution directory.");
-    if (!request.result && pi.getAllTools && pi.getCommands && hasExecutionCwdOwner({ getAllTools: pi.getAllTools, getCommands: pi.getCommands })) {
+    validateDirectoryReply(request.result);
+    if (!request.result &&
+        pi.getAllTools &&
+        pi.getCommands &&
+        hasExecutionCwdOwner({ getAllTools: pi.getAllTools, getCommands: pi.getCommands })) {
         throw new Error("The loaded directory extension did not resolve the execution directory. Update pi-change-working-dir before delegating work.");
     }
     return request.result?.cwd ?? ctx.cwd;

package/dist/shared/file-coalescer.js

@@ -2,8 +2,9 @@ export function createFileCoalescer(handler, defaultDelayMs) {
     const pending = new Map();
     return {
         schedule(file, delayMs = defaultDelayMs) {
-            if (pending.has(file))
+            if (pending.has(file)) {
                 return false;
+            }
             const timer = setTimeout(() => {
                 pending.delete(file);
                 handler(file);

package/dist/shared/fork-context.js

@@ -1,21 +1,17 @@
 import * as fs from "node:fs";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { requestChildExecutionCwd } from "../runs/shared/child-execution-cwd.js";
+import { errorMessage } from "./unknown.js";
 export function resolveSubagentContext(value) {
     return value === "fork" ? "fork" : "fresh";
 }
-export function createForkContextResolver(sessionManager, requestedContext) {
-    if (resolveSubagentContext(requestedContext) !== "fork") {
-        return {
-            sessionFileForIndex: () => undefined,
-        };
-    }
+export function createForkContextResolver(sessionManager) {
     const parentSessionFile = sessionManager.getSessionFile();
-    if (!parentSessionFile) {
+    if (parentSessionFile === undefined || parentSessionFile === "") {
         throw new Error("Forked subagent context requires a persisted parent session.");
     }
     const leafId = sessionManager.getLeafId();
-    if (!leafId) {
+    if (leafId === null || leafId === "") {
         throw new Error("Forked subagent context requires a current leaf to fork from.");
     }
     const sessionDir = sessionManager.getSessionDir();
@@ -23,14 +19,15 @@ export function createForkContextResolver(sessionManager, requestedContext) {
     return {
         sessionFileForIndex(index = 0) {
             const cached = cachedSessionFiles.get(index);
-            if (cached)
+            if (cached !== undefined && cached !== "") {
                 return cached;
+            }
             try {
                 if (!fs.existsSync(parentSessionFile)) {
                     throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
                 }
                 const sessionFile = SessionManager.open(parentSessionFile, sessionDir).createBranchedSession(leafId);
-                if (!sessionFile) {
+                if (sessionFile === undefined || sessionFile === "") {
                     throw new Error("Session manager did not return a forked session file.");
                 }
                 if (!fs.existsSync(sessionFile)) {
@@ -41,8 +38,9 @@ export function createForkContextResolver(sessionManager, requestedContext) {
                 return sessionFile;
             }
             catch (error) {
-                const cause = error instanceof Error ? error : new Error(String(error));
-                throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
+                throw new Error(`Failed to create forked subagent session: ${errorMessage(error)}`, {
+                    cause: error,
+                });
             }
         },
     };