@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/shared/post-exit-stdio-guard.js

@@ -0,0 +1,197 @@
+import { execFileSync } from "node:child_process";
+import { readLinuxProcess } from "../pi-intercom/broker/pid.js";
+/** Capture the detached group leader's birth identity; Pi may replace its command-line title. */
+export function readChildProcessIdentity(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return undefined;
+    if (process.platform === "linux")
+        return readLinuxProcess(pid)?.identity;
+    try {
+        const identity = execFileSync("ps", ["-p", String(pid), "-o", "lstart=", "-o", "pgid="], {
+            encoding: "utf8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"],
+            env: { ...process.env, LC_ALL: "C" },
+        }).trim().replace(/\s+/g, " ");
+        return Number(identity.split(" ").at(-1)) === pid ? identity : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function trySignalChild(child, signal) {
+    try {
+        return child.kill(signal);
+    }
+    catch {
+        return false;
+    }
+}
+export function isChildTreeAlive(child) {
+    if (child.pid) {
+        try {
+            process.kill(-child.pid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EPERM")
+                return true;
+        }
+    }
+    try {
+        return child.kill(0);
+    }
+    catch {
+        return false;
+    }
+}
+/** Signal the detached child's process group, falling back if it is not a group leader. */
+export function trySignalChildTree(child, signal) {
+    if (child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return true;
+        }
+        catch {
+            // Fall back when the child is not a process-group leader.
+        }
+    }
+    return trySignalChild(child, signal);
+}
+/** One lifetime for the owned process group, including descendants holding its pipes open. */
+export function attachChildProcessLifecycle(child) {
+    let closed = false;
+    let exited = false;
+    let stopping = false;
+    let settledCleanup = false;
+    let agentProcessExit;
+    let drainTimer;
+    let escalationTimer;
+    const clearDrain = () => {
+        clearTimeout(drainTimer);
+        drainTimer = undefined;
+    };
+    const clearTimers = () => {
+        clearDrain();
+        clearTimeout(escalationTimer);
+        escalationTimer = undefined;
+    };
+    const signalTree = () => {
+        // Pi print mode uses SIGTERM to dispose its own detached tool processes.
+        const sent = trySignalChildTree(child, "SIGTERM");
+        escalationTimer = setTimeout(() => {
+            if (isChildTreeAlive(child))
+                trySignalChildTree(child, "SIGKILL");
+        }, 3000);
+        escalationTimer.unref();
+        return sent;
+    };
+    const terminate = () => {
+        // Cancellation overrides a pending or already-started successful settlement cleanup.
+        settledCleanup = false;
+        clearDrain();
+        if (closed || stopping)
+            return;
+        stopping = true;
+        signalTree();
+    };
+    const clearStdioGuard = attachPostExitStdioGuard(child, { idleMs: 2000, hardMs: 8000 });
+    child.on("exit", (code, signal) => {
+        exited = true;
+        agentProcessExit = { pid: child.pid, code, signal, at: Date.now() };
+        clearTimers();
+        // The leader may exit before resistant descendants release inherited stdio.
+        trySignalChildTree(child, "SIGKILL");
+    });
+    const dispose = () => {
+        closed = true;
+        clearTimers();
+        clearStdioGuard();
+    };
+    child.on("close", dispose);
+    child.on("error", dispose);
+    return {
+        terminate,
+        get stopping() { return stopping; },
+        get agentProcessExit() { return agentProcessExit; },
+        get settledCleanup() { return settledCleanup; },
+        observeEvent(type) {
+            if (closed || exited || stopping)
+                return;
+            if (type === "agent_settled") {
+                if (drainTimer)
+                    return;
+                drainTimer = setTimeout(() => {
+                    drainTimer = undefined;
+                    stopping = true;
+                    settledCleanup = signalTree();
+                }, 1000);
+                drainTimer.unref();
+            }
+            else if (type === "agent_start" || type === "turn_start" || type?.startsWith("message_") || type?.startsWith("tool_execution_")) {
+                clearDrain();
+            }
+        },
+    };
+}
+export function attachPostExitStdioGuard(child, options) {
+    const { idleMs, hardMs } = options;
+    let exited = false;
+    let stdoutEnded = false;
+    let stderrEnded = false;
+    let idleTimer;
+    let hardTimer;
+    const destroyUnendedStdio = () => {
+        if (!stdoutEnded) {
+            try {
+                child.stdout?.destroy();
+            }
+            catch { }
+        }
+        if (!stderrEnded) {
+            try {
+                child.stderr?.destroy();
+            }
+            catch { }
+        }
+    };
+    const clearTimers = () => {
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = undefined;
+        }
+        if (hardTimer) {
+            clearTimeout(hardTimer);
+            hardTimer = undefined;
+        }
+    };
+    const armIdleTimer = () => {
+        if (!exited)
+            return;
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(destroyUnendedStdio, idleMs);
+        idleTimer.unref?.();
+    };
+    child.stdout?.on("data", armIdleTimer);
+    child.stderr?.on("data", armIdleTimer);
+    child.stdout?.on("end", () => {
+        stdoutEnded = true;
+        if (stdoutEnded && stderrEnded)
+            clearTimers();
+    });
+    child.stderr?.on("end", () => {
+        stderrEnded = true;
+        if (stdoutEnded && stderrEnded)
+            clearTimers();
+    });
+    child.on("exit", () => {
+        exited = true;
+        armIdleTimer();
+        if (hardTimer)
+            return;
+        hardTimer = setTimeout(destroyUnendedStdio, hardMs);
+        hardTimer.unref?.();
+    });
+    child.on("close", clearTimers);
+    child.on("error", clearTimers);
+    return clearTimers;
+}

package/dist/shared/prompt-sections.js

@@ -0,0 +1,8 @@
+export function setPromptSection(options, name, content) {
+    options.sections[name] = content;
+    // Pi projects an earlier exact override instead of sections. Preserve its content;
+    // this compatibility path replaces the leading prompt and cannot preserve its cache prefix.
+    if (options.forceSystemPrompt !== undefined) {
+        options.forceSystemPrompt += `\n\n<${name}>\n${content}\n</${name}>`;
+    }
+}

package/dist/shared/session-entries.js

@@ -0,0 +1,52 @@
+/** Follow append-only parent links; rescan when entries were replaced or appended off the active branch. */
+export class SessionEntryCursor {
+    manager;
+    sessionId;
+    file;
+    known = new Map();
+    anchor;
+    reset() {
+        this.manager = undefined;
+        this.known.clear();
+        this.anchor = undefined;
+    }
+    read(manager) {
+        const sessionId = manager.getSessionId(), file = manager.getSessionFile?.(), count = manager.getEntryCount?.();
+        let reset = this.manager !== manager || this.sessionId !== sessionId || this.file !== file
+            || count !== undefined && count < this.known.size
+            || Boolean(this.anchor && manager.getEntry && manager.getEntry(this.anchor.id) !== this.known.get(this.anchor.id));
+        let entries;
+        if (!reset && count !== undefined && manager.getEntry && manager.getLeafId) {
+            const appended = [], visited = new Set();
+            let id = manager.getLeafId();
+            while (id && !this.known.has(id) && !visited.has(id)) {
+                visited.add(id);
+                const entry = manager.getEntry(id);
+                if (!entry)
+                    break;
+                appended.push(entry);
+                id = entry.parentId;
+            }
+            if (count === this.known.size + appended.length && (!id || this.known.has(id)))
+                entries = appended.reverse();
+        }
+        if (!entries) {
+            const all = manager.getEntries();
+            entries = all.filter((entry) => !this.known.has(entry.id));
+            if (all.length !== this.known.size + entries.length
+                || all.some((entry) => this.known.has(entry.id) && this.known.get(entry.id) !== entry))
+                reset = true;
+            if (reset) {
+                this.known.clear();
+                entries = all;
+            }
+        }
+        for (const entry of entries)
+            this.known.set(entry.id, entry);
+        this.anchor = entries.at(-1) ?? (reset ? undefined : this.anchor);
+        this.manager = manager;
+        this.sessionId = sessionId;
+        this.file = file;
+        return { entries, reset };
+    }
+}

package/dist/shared/session-identity.js

@@ -0,0 +1,14 @@
+// Only delegation supplies this identity; Pi's ordinary fork/clone ancestry does not.
+export function resolveRootSessionId(sessionManager, env = process.env) {
+    const rootId = env.PI_SUBAGENT_CHILD === "1" ? env.PI_SUBAGENT_ROOT_SESSION_ID : undefined;
+    const sessionId = rootId || sessionManager.getSessionId();
+    if (!sessionId)
+        throw new Error("Root session identity is unavailable.");
+    return sessionId;
+}
+export function resolveCurrentSessionId(sessionManager) {
+    const sessionId = sessionManager.getSessionId();
+    if (!sessionId)
+        throw new Error("Current session identity is unavailable.");
+    return sessionId;
+}

package/dist/shared/settings.js

@@ -0,0 +1,254 @@
+/**
+ * Chain behavior, template resolution, and directory management
+ */
+import * as fs from "node:fs";
+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 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);
+}
+/** 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);
+    }
+    if (isDynamicParallelStep(step)) {
+        return [step.parallel.agent];
+    }
+    return [step.agent];
+}
+export function collectInvocationAgentNames(params) {
+    const names = [];
+    if (params.agent)
+        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 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
+        }
+    }
+}
+/**
+ * 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) => {
+        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}";
+            });
+        }
+        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])];
+        }
+    }
+    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 };
+}
+export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
+    if (!task)
+        return originalTask;
+    return originalTask ? task.replaceAll("{task}", () => originalTask) : task;
+}
+export function taskDisallowsFileUpdates(task) {
+    if (!task)
+        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;
+}
+// =============================================================================
+// 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;
+    }
+}
+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(", ")}]`);
+    }
+    // OUTPUT - prepend so agent knows where to write
+    if (behavior.output) {
+        const outputPath = resolveChainPath(behavior.output, chainDir);
+        prefixParts.push(`[Write to: ${outputPath}]`);
+    }
+    // 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}`);
+        }
+    }
+    const prefix = prefixParts.length > 0
+        ? prefixParts.join("\n") + "\n\n"
+        : "";
+    const suffix = suffixParts.length > 0
+        ? "\n\n---\n" + suffixParts.join("\n")
+        : "";
+    return { prefix, suffix };
+}
+// =============================================================================
+// 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) {
+            throw new Error(`Unknown agent: ${task.agent}`);
+        }
+        const behavior = resolveStepBehavior(config, {
+            output: task.output,
+            outputMode: task.outputMode,
+            reads: task.reads,
+            progress: task.progress,
+            skills: normalizeSkillInput(task.skill),
+            model: task.model,
+        }, chainSkills);
+        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;
+}
+export { aggregateParallelOutputs } from "../runs/shared/parallel-utils.js";

package/dist/shared/status-format.js

@@ -0,0 +1,111 @@
+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.`
+        : "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 call = `${legacyChild || action === "extend" ? "subagent" : "agent_runs"}({ ${args} })`;
+    return action === "extend" && !legacyChild ? `load_subagent({}), then ${call}` : call;
+}
+export function buildManagementControl(input) {
+    const capabilities = ["status"];
+    if (input.state === "live") {
+        if (input.canNudge)
+            capabilities.push("nudge");
+        if (input.canResume)
+            capabilities.push("resume");
+        if (input.canInterrupt)
+            capabilities.push("interrupt");
+    }
+    else if (input.canResume)
+        capabilities.push("resume");
+    if (input.state === "live" && input.canExtend)
+        capabilities.push("extend");
+    if (input.canReview)
+        capabilities.push("review");
+    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 } : {}),
+        })),
+        ...(input.unavailableActions ? { unavailableActions: input.unavailableActions } : {}),
+        ...(input.revivedFromRunId ? { revivedFromRunId: input.revivedFromRunId, pendingReplyContextValid: false } : {}),
+    };
+}
+function formatActivityAge(ms) {
+    if (ms < 1000)
+        return "now";
+    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")
+            return "needs attention";
+        return undefined;
+    }
+    const age = formatActivityAge(Math.max(0, now - lastActivityAt));
+    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"))
+        return "running";
+    if (steps.some((step) => step.status === "failed"))
+        return "failed";
+    if (steps.some((step) => step.status === "blocked"))
+        return "blocked";
+    if (steps.some((step) => step.status === "paused"))
+        return "paused";
+    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`;
+}
+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 indent = input.indent ?? "";
+    return [
+        `${indent}Intercom: ${healthText} (${input.target})`,
+        `${indent}Nudge (preferred live coordination): ${formatRunAction("nudge", input.runId, fields, input.childSafe)}`,
+        `${indent}Ask (blocking wait only; parent must remain alive): intercom({ action: "ask", to: "${input.target}", delivery: "steer", message: "What are you blocked on?" })`,
+    ];
+}
+export function formatParallelOutcome(steps, total, options = {}) {
+    const running = steps.filter((step) => step.status === "running").length;
+    const succeeded = steps.filter((step) => isCompletedStepStatus(step.status)).length;
+    const failed = steps.filter((step) => step.status === "failed").length;
+    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)
+        parts.unshift(formatAgentRunningLabel(running));
+    if (failed > 0)
+        parts.push(`${failed} failed`);
+    if (paused > 0)
+        parts.push(`${paused} paused`);
+    if (blocked > 0)
+        parts.push(`${blocked} need human action`);
+    return parts.join(" · ");
+}