@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/shared/settings.js

@@ -1,29 +1,17 @@
-/**
- * Chain behavior, template resolution, and directory management
- */
-import * as fs from "node:fs";
+/** Chain step traversal, behavior resolution, and instruction composition. */
 import * as path from "node:path";
 import { normalizeSkillInput } from "../agents/skills.js";
-import { CHAIN_RUNS_DIR } from "./types.js";
-import { ensureSafeTempPath, ensureTempRoot } from "./temp-root.js";
-const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
-const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
-function normalizeOutputOverride(output) {
-    return output === "false" ? false : output;
-}
-// =============================================================================
-// Type Guards
-// =============================================================================
+export { createChainDir, removeChainDir, cleanupOldChainDirs, writeInitialProgressFile, } from "./chain-files.js";
+export { resolveTaskTextForFileUpdatePolicy, taskDisallowsFileUpdates, suppressProgressForReadOnlyTask, } from "./task-file-policy.js";
 export function isParallelStep(step) {
     return "parallel" in step && Array.isArray(step.parallel);
 }
 export function isDynamicParallelStep(step) {
-    return "expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel);
+    return ("expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel));
 }
-/** Get all agent names in a step (single for sequential, multiple for parallel) */
 export function getStepAgents(step) {
     if (isParallelStep(step)) {
-        return step.parallel.map((t) => t.agent);
+        return step.parallel.map((task) => task.agent);
     }
     if (isDynamicParallelStep(step)) {
         return [step.parallel.agent];
@@ -32,209 +20,84 @@ export function getStepAgents(step) {
 }
 export function collectInvocationAgentNames(params) {
     const names = [];
-    if (params.agent)
+    if (params.agent !== undefined && params.agent.length > 0) {
         names.push(params.agent);
-    for (const task of params.tasks ?? [])
-        names.push(task.agent);
-    for (const step of params.chain ?? [])
-        names.push(...getStepAgents(step));
-    return names;
-}
-// =============================================================================
-// Chain Directory Management
-// =============================================================================
-export function createChainDir(runId, baseDir, cwd = process.cwd()) {
-    if (!baseDir)
-        ensureTempRoot();
-    const chainDir = path.join(baseDir ? path.resolve(cwd, baseDir) : CHAIN_RUNS_DIR, runId);
-    if (!baseDir)
-        ensureSafeTempPath(chainDir);
-    fs.mkdirSync(chainDir, { recursive: true });
-    return chainDir;
-}
-export function removeChainDir(chainDir) {
-    try {
-        fs.rmSync(chainDir, { recursive: true });
-    }
-    catch {
-        // Chain cleanup is best-effort. Runs can already have cleaned their temp dir.
     }
-}
-export async function cleanupOldChainDirs() {
-    ensureSafeTempPath(CHAIN_RUNS_DIR);
-    const now = Date.now();
-    let dirs;
-    try {
-        dirs = await fs.promises.readdir(CHAIN_RUNS_DIR);
-    }
-    catch {
-        // Startup cleanup is best-effort. If the scoped temp root is unreadable,
-        // skip cleanup instead of failing extension startup.
-        return;
+    for (const task of params.tasks ?? []) {
+        names.push(task.agent);
     }
-    for (const dir of dirs) {
-        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 {
-            // Skip directories that can't be processed; continue with others
-        }
+    for (const step of params.chain ?? []) {
+        names.push(...getStepAgents(step));
     }
+    return names;
 }
-/**
- * Resolve templates for a chain with parallel step support.
- * Returns string for sequential steps, string[] for parallel steps.
- */
 export function resolveChainTemplates(steps) {
-    return steps.map((step, i) => {
+    return steps.map((step, index) => {
         if (isParallelStep(step)) {
-            // Parallel step: resolve each task's template
-            return step.parallel.map((task) => {
-                if (task.task)
-                    return task.task;
-                // Default for parallel tasks is {previous}
-                return "{previous}";
-            });
+            return step.parallel.map((task) => task.task !== undefined && task.task.length > 0 ? task.task : "{previous}");
         }
         if (isDynamicParallelStep(step)) {
             return step.parallel.task ?? "{previous}";
         }
-        // Sequential step: existing logic
-        const seq = step;
-        if (seq.task)
-            return seq.task;
-        // Default: first step uses {task}, others use {previous}
-        return i === 0 ? "{task}" : "{previous}";
-    });
-}
-// =============================================================================
-// Behavior Resolution
-// =============================================================================
-/**
- * Resolve effective chain behavior per step.
- * Priority: step override > agent frontmatter > false (disabled)
- */
-export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
-    // Output: step override > frontmatter > false (no output)
-    const stepOutput = normalizeOutputOverride(stepOverrides.output);
-    const output = stepOutput !== undefined
-        ? stepOutput
-        : normalizeOutputOverride(agentConfig.output) ?? false;
-    // Reads: step override > frontmatter defaultReads > false (no reads)
-    const reads = stepOverrides.reads !== undefined
-        ? stepOverrides.reads
-        : agentConfig.defaultReads ?? false;
-    // Progress: step override > frontmatter defaultProgress > false
-    const progress = stepOverrides.progress !== undefined
-        ? stepOverrides.progress
-        : agentConfig.defaultProgress ?? false;
-    let skills;
-    if (chainSkills === false || stepOverrides.skills === false) {
-        skills = false;
-    }
-    else if (stepOverrides.skills !== undefined) {
-        skills = [...stepOverrides.skills];
-        if (chainSkills && chainSkills.length > 0) {
-            skills = [...new Set([...skills, ...chainSkills])];
+        if (step.task !== undefined && step.task.length > 0) {
+            return step.task;
         }
-    }
-    else {
-        skills = agentConfig.skills ? [...agentConfig.skills] : [];
-        if (chainSkills && chainSkills.length > 0) {
-            skills = [...new Set([...skills, ...chainSkills])];
-        }
-    }
-    const outputMode = stepOverrides.outputMode ?? "inline";
-    const model = stepOverrides.model ?? agentConfig.model;
-    return { output, outputMode, reads, progress, skills, model };
+        return index === 0 ? "{task}" : "{previous}";
+    });
 }
-export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
-    if (!task)
-        return originalTask;
-    return originalTask ? task.replaceAll("{task}", () => originalTask) : task;
+function normalizeOutputOverride(output) {
+    return output === "false" ? false : output;
 }
-export function taskDisallowsFileUpdates(task) {
-    if (!task)
+function resolveStepSkills(agentSkills, overrideSkills, chainSkills) {
+    if (chainSkills === false || overrideSkills === false) {
         return false;
-    return /\breview[- ]only\b/i.test(task)
-        || /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task)
-        || /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task)
-        || /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task)
-        || /\bleave\s+files?\s+unchanged\b/i.test(task);
+    }
+    const skills = [...(overrideSkills ?? agentSkills ?? [])];
+    return chainSkills !== undefined && chainSkills.length > 0
+        ? [...new Set([...skills, ...chainSkills])]
+        : skills;
 }
-export function suppressProgressForReadOnlyTask(behavior, task, originalTask) {
-    const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
-    return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
+/** Per-field precedence: step override, agent defaults, then disabled/unset. */
+export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
+    return {
+        output: normalizeOutputOverride(stepOverrides.output) ??
+            normalizeOutputOverride(agentConfig.output) ??
+            false,
+        outputMode: stepOverrides.outputMode ?? "inline",
+        reads: stepOverrides.reads ?? agentConfig.defaultReads ?? false,
+        progress: stepOverrides.progress ?? agentConfig.defaultProgress ?? false,
+        skills: resolveStepSkills(agentConfig.skills, stepOverrides.skills, chainSkills),
+        model: stepOverrides.model ?? agentConfig.model,
+    };
 }
-// =============================================================================
-// Chain Instruction Injection
-// =============================================================================
-/**
- * Resolve a file path: absolute paths pass through, relative paths get chainDir prepended.
- */
 function resolveChainPath(filePath, chainDir) {
     return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
 }
-/**
- * Build chain instructions from resolved behavior.
- * These are appended to the task to tell the agent what to read/write.
- */
-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 (error.code !== "EEXIST")
-            throw error;
-    }
-}
+/** Prepend read/output paths so task prose cannot accidentally override the chosen destination. */
 export function buildChainInstructions(behavior, chainDir, isFirstProgressAgent) {
     const prefixParts = [];
     const suffixParts = [];
-    // READS - prepend to override any hardcoded filenames in task text
-    if (behavior.reads && behavior.reads.length > 0) {
-        const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
-        prefixParts.push(`[Read from: ${files.join(", ")}]`);
+    if (behavior.reads !== false && behavior.reads.length > 0) {
+        prefixParts.push(`[Read from: ${behavior.reads.map((file) => resolveChainPath(file, chainDir)).join(", ")}]`);
     }
-    // OUTPUT - prepend so agent knows where to write
-    if (behavior.output) {
-        const outputPath = resolveChainPath(behavior.output, chainDir);
-        prefixParts.push(`[Write to: ${outputPath}]`);
+    if (behavior.output !== false && behavior.output.length > 0) {
+        prefixParts.push(`[Write to: ${resolveChainPath(behavior.output, chainDir)}]`);
     }
-    // Progress instructions in suffix (less critical)
     if (behavior.progress) {
         const progressPath = path.join(chainDir, "progress.md");
-        if (isFirstProgressAgent) {
-            suffixParts.push(`Create and maintain progress at: ${progressPath}`);
-        }
-        else {
-            suffixParts.push(`Update progress at: ${progressPath}`);
-        }
+        suffixParts.push(isFirstProgressAgent
+            ? `Create and maintain progress at: ${progressPath}`
+            : `Update progress at: ${progressPath}`);
     }
-    const prefix = prefixParts.length > 0
-        ? prefixParts.join("\n") + "\n\n"
-        : "";
-    const suffix = suffixParts.length > 0
-        ? "\n\n---\n" + suffixParts.join("\n")
-        : "";
-    return { prefix, suffix };
+    return {
+        prefix: prefixParts.length > 0 ? `${prefixParts.join("\n")}\n\n` : "",
+        suffix: suffixParts.length > 0 ? `\n\n---\n${suffixParts.join("\n")}` : "",
+    };
 }
-// =============================================================================
-// Parallel Step Support
-// =============================================================================
-/**
- * Resolve behaviors for all tasks in a parallel step.
- * Creates namespaced output paths to avoid collisions.
- */
 export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSkills) {
     return tasks.map((task, taskIndex) => {
-        const config = agentConfigs.find((a) => a.name === task.agent);
-        if (!config) {
+        const config = agentConfigs.find((agent) => agent.name === task.agent);
+        if (config === undefined) {
             throw new Error(`Unknown agent: ${task.agent}`);
         }
         const behavior = resolveStepBehavior(config, {
@@ -245,10 +108,17 @@ export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSk
             skills: normalizeSkillInput(task.skill),
             model: task.model,
         }, chainSkills);
-        return { ...behavior, output: namespaceParallelOutput(behavior.output, task.agent, stepIndex, taskIndex) };
+        return {
+            ...behavior,
+            output: namespaceParallelOutput(behavior.output, task.agent, stepIndex, taskIndex),
+        };
     });
 }
 export function namespaceParallelOutput(output, agent, stepIndex, taskIndex) {
-    return output ? path.isAbsolute(output) ? output : path.join(`parallel-${stepIndex}`, `${taskIndex}-${agent}`, output) : false;
+    if (output === undefined || output === false || output.length === 0) {
+        return false;
+    }
+    return path.isAbsolute(output)
+        ? output
+        : path.join(`parallel-${stepIndex}`, `${taskIndex}-${agent}`, output);
 }
-export { aggregateParallelOutputs } from "../runs/shared/parallel-utils.js";

package/dist/shared/status-format.js

@@ -1,90 +1,146 @@
 import { loadConfig } from "../extension/config.js";
 export function formatAgentProcessExit(exit) {
-    return exit ? `Agent process exited (${exit.signal ? `signal ${exit.signal}` : `code ${exit.code ?? "unrecorded"}`}). Command and descendant exit are not implied.`
+    return exit
+        ? `Agent process exited (${exit.signal !== null ? `signal ${exit.signal}` : `code ${exit.code ?? "unrecorded"}`}). Command and descendant exit are not implied.`
         : "Agent process exit not recorded. Command exit is unconfirmed.";
 }
 export function formatRunAction(action, id, fields = {}, childSafe = false) {
     const legacyChild = childSafe && loadConfig().compactChildTools === false;
-    const parentAction = { status: "inspect", resume: "continue", interrupt: "stop" };
-    const name = legacyChild ? action : parentAction[action] ?? action;
-    const args = Object.entries({ action: name, ...(id !== undefined ? { id } : {}), ...fields }).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+    const name = legacyChild ? action : parentActionName(action);
+    const args = Object.entries({ action: name, ...(id !== undefined ? { id } : {}), ...fields })
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(", ");
     const call = `${legacyChild || action === "extend" ? "subagent" : "agent_runs"}({ ${args} })`;
     return action === "extend" && !legacyChild ? `load_subagent({}), then ${call}` : call;
 }
-export function buildManagementControl(input) {
+function parentActionName(action) {
+    switch (action) {
+        case "status":
+            return "inspect";
+        case "resume":
+            return "continue";
+        case "interrupt":
+            return "stop";
+        case "answer":
+        case "extend":
+        case "nudge":
+        case "questions":
+        case "review":
+            return action;
+    }
+}
+function managementCapabilities(input) {
     const capabilities = ["status"];
     if (input.state === "live") {
-        if (input.canNudge)
+        if (input.canNudge === true) {
             capabilities.push("nudge");
-        if (input.canResume)
+        }
+        if (input.canResume === true) {
             capabilities.push("resume");
-        if (input.canInterrupt)
+        }
+        if (input.canInterrupt === true) {
             capabilities.push("interrupt");
+        }
     }
-    else if (input.canResume)
+    else if (input.canResume === true) {
         capabilities.push("resume");
-    if (input.state === "live" && input.canExtend)
+    }
+    if (input.state === "live" && input.canExtend === true) {
         capabilities.push("extend");
-    if (input.canReview)
+    }
+    if (input.canReview === true) {
         capabilities.push("review");
+    }
+    return capabilities;
+}
+function managementNextAction(action, input) {
+    return {
+        action,
+        runId: input.runId,
+        ...(input.index !== undefined && (action === "nudge" || action === "resume")
+            ? { index: input.index }
+            : {}),
+        ...(input.intercomTarget !== undefined &&
+            input.intercomTarget !== "" &&
+            (action === "nudge" || action === "resume")
+            ? { intercomTarget: input.intercomTarget }
+            : {}),
+    };
+}
+export function buildManagementControl(input) {
+    const capabilities = managementCapabilities(input);
     return {
         state: input.state,
         runId: input.runId,
         capabilities,
-        nextActions: capabilities.map((action) => ({
-            action,
-            runId: input.runId,
-            ...(input.index !== undefined && (action === "nudge" || action === "resume") ? { index: input.index } : {}),
-            ...(input.intercomTarget && (action === "nudge" || action === "resume") ? { intercomTarget: input.intercomTarget } : {}),
-        })),
+        nextActions: capabilities.map((action) => managementNextAction(action, input)),
         ...(input.unavailableActions ? { unavailableActions: input.unavailableActions } : {}),
-        ...(input.revivedFromRunId ? { revivedFromRunId: input.revivedFromRunId, pendingReplyContextValid: false } : {}),
+        ...(input.revivedFromRunId !== undefined && input.revivedFromRunId !== ""
+            ? { revivedFromRunId: input.revivedFromRunId, pendingReplyContextValid: false }
+            : {}),
     };
 }
 function formatActivityAge(ms) {
-    if (ms < 1000)
+    if (ms < 1000) {
         return "now";
-    if (ms < 60000)
+    }
+    if (ms < 60000) {
         return `${Math.floor(ms / 1000)}s`;
+    }
     return `${Math.floor(ms / 60000)}m`;
 }
 export function formatActivityLabel(lastActivityAt, activityState, now = Date.now()) {
     if (lastActivityAt === undefined) {
-        if (activityState === "needs_attention")
+        if (activityState === "needs_attention") {
             return "needs attention";
+        }
         return undefined;
     }
     const age = formatActivityAge(Math.max(0, now - lastActivityAt));
-    if (activityState === "needs_attention")
+    if (activityState === "needs_attention") {
         return `no activity for ${age}`;
+    }
     return age === "now" ? "active now" : `active ${age} ago`;
 }
 function isCompletedStepStatus(status) {
     return status === "complete" || status === "completed";
 }
 export function aggregateStepStatus(steps) {
-    if (steps.some((step) => step.status === "running"))
+    if (steps.some((step) => step.status === "running")) {
         return "running";
-    if (steps.some((step) => step.status === "failed"))
+    }
+    if (steps.some((step) => step.status === "failed")) {
         return "failed";
-    if (steps.some((step) => step.status === "blocked"))
+    }
+    if (steps.some((step) => step.status === "blocked")) {
         return "blocked";
-    if (steps.some((step) => step.status === "paused"))
+    }
+    if (steps.some((step) => step.status === "paused")) {
         return "paused";
-    if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status)))
+    }
+    if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status))) {
         return "complete";
+    }
     return "pending";
 }
 export function formatAgentRunningLabel(count) {
     return count === 1 ? "1 agent running" : `${count} agents running`;
 }
+function intercomHealth(health) {
+    if (!health) {
+        return "unknown";
+    }
+    if (health.status !== "registered") {
+        return health.status.replace(/_/g, " ");
+    }
+    return `registered${health.sessionStatus !== undefined && health.sessionStatus !== "" ? `, ${health.sessionStatus}` : ""}${health.acceptsAsks !== undefined ? `, accepts_asks:${health.acceptsAsks}` : ""}${health.pendingAsks !== undefined ? `, pending_asks:${health.pendingAsks}` : ""}`;
+}
 export function formatLiveIntercomActionLines(input) {
-    const fields = { ...(input.index !== undefined ? { index: input.index } : {}), message: "What are you blocked on?" };
-    const healthText = !input.health
-        ? "unknown"
-        : input.health.status === "registered"
-            ? `registered${input.health.sessionStatus ? `, ${input.health.sessionStatus}` : ""}${input.health.acceptsAsks !== undefined ? `, accepts_asks:${input.health.acceptsAsks}` : ""}${input.health.pendingAsks !== undefined ? `, pending_asks:${input.health.pendingAsks}` : ""}`
-            : input.health.status.replace(/_/g, " ");
+    const fields = {
+        ...(input.index !== undefined ? { index: input.index } : {}),
+        message: "What are you blocked on?",
+    };
+    const healthText = intercomHealth(input.health);
     const indent = input.indent ?? "";
     return [
         `${indent}Intercom: ${healthText} (${input.target})`,
@@ -99,13 +155,17 @@ export function formatParallelOutcome(steps, total, options = {}) {
     const paused = steps.filter((step) => step.status === "paused").length;
     const blocked = steps.filter((step) => step.status === "blocked").length;
     const parts = [`${succeeded}/${total} succeeded`];
-    if (options.showRunning !== false && running > 0)
+    if (options.showRunning !== false && running > 0) {
         parts.unshift(formatAgentRunningLabel(running));
-    if (failed > 0)
+    }
+    if (failed > 0) {
         parts.push(`${failed} failed`);
-    if (paused > 0)
+    }
+    if (paused > 0) {
         parts.push(`${paused} paused`);
-    if (blocked > 0)
+    }
+    if (blocked > 0) {
         parts.push(`${blocked} need human action`);
+    }
     return parts.join(" · ");
 }

package/dist/shared/task-file-policy.js

@@ -0,0 +1,24 @@
+export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
+    if (task === undefined || task.length === 0) {
+        return originalTask;
+    }
+    return originalTask !== undefined && originalTask.length > 0
+        ? task.replaceAll("{task}", () => originalTask)
+        : task;
+}
+export function taskDisallowsFileUpdates(task) {
+    if (task === undefined || task.length === 0) {
+        return false;
+    }
+    return (/\breview[- ]only\b/i.test(task) ||
+        /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task) ||
+        /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task) ||
+        /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task) ||
+        /\bleave\s+files?\s+unchanged\b/i.test(task));
+}
+export function suppressProgressForReadOnlyTask(behavior, task, originalTask) {
+    const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
+    return behavior.progress && taskDisallowsFileUpdates(policyTask)
+        ? { ...behavior, progress: false }
+        : behavior;
+}