@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/pi-intercom/ui/session-list.js

@@ -1,157 +0,0 @@
-import { Box, Container, SelectList, Text, sliceByColumn, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
-import { actionHints } from "../../tui/action-hints.js";
-import { formatSessionTarget } from "../session-targets.js";
-function sessionTitle(session, allSessions, suffix) {
-    return `${(session.name ?? "").length > 0 ? (session.name ?? "") : "Unnamed session"} (${formatSessionTarget(session, allSessions)})${suffix !== undefined && suffix.length > 0 ? ` [${suffix}]` : ""}`;
-}
-function sessionDescription(session) {
-    const resources = session.topics
-        ?.filter((topic) => (topic.resource ?? "").length > 0 && topic.ownership === "held")
-        .map((topic) => `Using ${topic.resource ?? ""}`)
-        .join(" · ") ?? "";
-    return `${resources.length > 0 ? resources : `Native session cwd: ${session.cwd}`} • ${session.model}`;
-}
-export class SessionListOverlay extends Container {
-    completed = false;
-    selectList;
-    allSessions;
-    tui;
-    theme;
-    options;
-    hiddenSessionCount;
-    constructor(tui, theme, options) {
-        super();
-        this.tui = tui;
-        this.theme = theme;
-        this.options = options;
-        const { sessions, currentSession } = options;
-        this.hiddenSessionCount = options.hiddenSessionCount ?? 0;
-        this.allSessions = options.allSessions ?? [currentSession, ...sessions];
-        const items = sessions.map((session) => ({
-            value: session.id,
-            label: sessionTitle(session, this.allSessions, session.cwd === currentSession.cwd ? "same native session cwd" : undefined),
-            description: sessionDescription(session),
-        }));
-        this.selectList = new SelectList(items, 8, {
-            selectedPrefix: (text) => theme.fg("accent", text),
-            selectedText: (text) => theme.fg("accent", text),
-            description: (text) => theme.fg("dim", text),
-            scrollInfo: (text) => theme.fg("dim", text),
-            noMatch: (text) => theme.fg("dim", text),
-        });
-        this.selectList.onSelect = (item) => this.finish(sessions.find((session) => session.id === item.value));
-        this.selectList.onCancel = () => this.finish();
-    }
-    finish(result) {
-        if (this.completed) {
-            return;
-        }
-        this.completed = true;
-        this.options.done(result);
-    }
-    dispose() {
-        this.completed = true;
-    }
-    handleMouse(event) {
-        const width = Math.min(event.width, 88);
-        if (this.completed || event.x >= width) {
-            return;
-        }
-        return super.handleMouse({ ...event, width });
-    }
-    handleInput(data) {
-        if (this.completed) {
-            return;
-        }
-        if (this.options.sessions.length === 0) {
-            if (this.options.keybindings.matches(data, "tui.select.cancel")) {
-                this.finish();
-            }
-        }
-        else {
-            this.selectList.handleInput(data);
-        }
-        this.tui.requestRender();
-    }
-    emptyLines(row) {
-        const messages = this.hiddenSessionCount > 0
-            ? [
-                " No other sessions in this project",
-                ` ${this.hiddenSessionCount} in other project${this.hiddenSessionCount === 1 ? "" : "s"} hidden`,
-                " Run /intercom all to show every connected session",
-            ]
-            : [
-                " No other intercom-connected sessions",
-                " Start another session with: pi --name worker",
-                ' Then run intercom({ action: "list" }) again',
-            ];
-        return messages.map((message) => row(this.theme.fg("dim", message)));
-    }
-    controls() {
-        const message = [this.options.keybindings.getKeys("tui.select.confirm").join("/"), "Message"]
-            .filter(Boolean)
-            .join(": ");
-        const close = [this.options.keybindings.getKeys("tui.select.cancel").join("/"), "Close"]
-            .filter(Boolean)
-            .join(": ");
-        return actionHints([
-            " ",
-            ...(this.options.sessions.length > 0
-                ? [
-                    {
-                        text: message,
-                        run: () => {
-                            const item = this.selectList.getSelectedItem();
-                            if (item) {
-                                this.selectList.onSelect?.(item);
-                            }
-                        },
-                    },
-                    " • ",
-                ]
-                : []),
-            { text: close, run: () => this.finish() },
-        ], (text) => this.theme.fg("dim", text), "");
-    }
-    render(width) {
-        this.clear();
-        if (width < 3) {
-            return [truncateToWidth("Intercom", width)];
-        }
-        const innerWidth = Math.min(width, 88);
-        const contentWidth = Math.max(1, innerWidth - 2);
-        const border = (text) => this.theme.fg("accent", text);
-        const row = (text = "") => {
-            const clipped = truncateToWidth(text, contentWidth, "", true);
-            return `${border("│")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))}${border("│")}`;
-        };
-        const framed = (component) => {
-            const box = new Box(1, 0, (line) => row(sliceByColumn(line, 1, contentWidth)));
-            box.addChild(component);
-            return box;
-        };
-        const lines = [
-            border(`╭${"─".repeat(contentWidth)}╮`),
-            row(this.theme.bold(" Current Session")),
-            border(`├${"─".repeat(contentWidth)}┤`),
-            row(`  ${this.theme.fg("dim", sessionTitle(this.options.currentSession, this.allSessions, "self"))}`),
-            row(`  ${this.theme.fg("dim", `Native session cwd: ${this.options.currentSession.cwd} • ${this.options.currentSession.model}`)}`),
-            border(`├${"─".repeat(contentWidth)}┤`),
-            row(this.theme.bold(" Other Sessions")),
-        ];
-        this.addChild(new Text(lines.join("\n"), 0, 0));
-        if (this.options.sessions.length === 0) {
-            this.addChild(new Text(this.emptyLines(row).join("\n"), 0, 0));
-        }
-        else {
-            this.addChild(framed(this.selectList));
-            if (this.hiddenSessionCount > 0) {
-                this.addChild(new Text(row(this.theme.fg("dim", ` ${this.hiddenSessionCount} other-project session${this.hiddenSessionCount === 1 ? "" : "s"} hidden · /intercom all`)), 0, 0));
-            }
-        }
-        this.addChild(new Text(border(`├${"─".repeat(contentWidth)}┤`), 0, 0));
-        this.addChild(framed(this.controls()));
-        this.addChild(new Text(border(`╰${"─".repeat(contentWidth)}╯`), 0, 0));
-        return super.render(innerWidth);
-    }
-}

package/dist/pi-intercom/ui/tool-renderers.js

@@ -1,110 +0,0 @@
-import { keyText } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { previewText } from "../message-format.js";
-import { firstTextContent } from "../tool-results.js";
-import { isRecord, isUnknownArray } from "../validation.js";
-function failed(context, details) {
-    return context.isError === true || details?.error === true || details?.accepted === false;
-}
-function contactColor(reason) {
-    if (reason === "need_decision") {
-        return "warning";
-    }
-    return reason === "progress_update" ? "muted" : "accent";
-}
-export function renderContactCall(args, theme) {
-    const record = isRecord(args) ? args : {};
-    const reason = typeof record.reason === "string" ? record.reason : "contact";
-    const preview = previewText(record.message, 96);
-    const interview = isRecord(record.interview) ? record.interview : undefined;
-    let text = theme.fg("toolTitle", theme.bold("contact_supervisor ")) +
-        theme.fg(contactColor(reason), reason);
-    if (typeof interview?.title === "string" && interview.title.trim() !== "") {
-        text += ` ${theme.fg("accent", interview.title.trim())}`;
-    }
-    if (preview !== undefined && preview !== "") {
-        text += `\n  ${theme.fg("dim", preview)}`;
-    }
-    return new Text(text, 0, 0);
-}
-export function renderContactResult(result, options, theme, context) {
-    if (options.isPartial) {
-        return new Text(theme.fg("warning", "Waiting for supervisor..."), 0, 0);
-    }
-    const details = isRecord(result.details) ? result.details : undefined;
-    const failure = failed(context, details);
-    const warning = typeof details?.structuredReplyParseError === "string";
-    let prefix = theme.fg("success", "✓ ");
-    if (failure) {
-        prefix = theme.fg("error", "✗ ");
-    }
-    else if (warning) {
-        prefix = theme.fg("warning", "⚠ ");
-    }
-    let text = prefix + theme.fg(failure ? "error" : "text", firstTextContent(result));
-    if (typeof details?.structuredReplyParseError === "string") {
-        text += `\n${theme.fg("warning", `Structured reply parse issue: ${details.structuredReplyParseError}`)}`;
-    }
-    return new Text(text, 0, 0);
-}
-function actionColor(action) {
-    if (action === "ask") {
-        return "warning";
-    }
-    return action === "reply" ? "success" : "accent";
-}
-export function renderIntercomCall(args, theme) {
-    const record = isRecord(args) ? args : {};
-    const action = typeof record.action === "string" ? record.action : "intercom";
-    const target = typeof record.to === "string" ? record.to.trim() : "";
-    const preview = previewText(record.message, 96);
-    const count = isUnknownArray(record.attachments) ? record.attachments.length : 0;
-    let text = theme.fg("toolTitle", theme.bold("intercom ")) + theme.fg(actionColor(action), action);
-    if (target !== "") {
-        text += ` ${theme.fg("muted", "→")} ${theme.fg("accent", target)}`;
-    }
-    if (count > 0) {
-        text += ` ${theme.fg("dim", `(${count} attachment${count === 1 ? "" : "s"})`)}`;
-    }
-    if (preview !== undefined && preview !== "") {
-        text += `\n  ${theme.fg("dim", preview)}`;
-    }
-    return new Text(text, 0, 0);
-}
-function listSummary(details, theme) {
-    const count = details?.sessionCount;
-    const summary = typeof count === "number" ? `${count} session${count === 1 ? "" : "s"}` : "Sessions listed";
-    const key = keyText("app.tools.expand");
-    return new Text(`${theme.fg("success", "✓ ")}${theme.fg("text", summary)}${key !== "" ? ` ${theme.fg("dim", `(${key} to expand)`)}` : ""}`, 0, 0);
-}
-function messageSuffix(details, expanded, theme) {
-    const id = details?.messageId;
-    return typeof id === "string" && id !== "" && !expanded
-        ? theme.fg("dim", ` (${id.slice(0, 8)})`)
-        : "";
-}
-function reasonSuffix(details, expanded, theme) {
-    const reason = details?.reason;
-    return typeof reason === "string" && reason !== "" && expanded
-        ? `\n${theme.fg("dim", `Reason: ${reason}`)}`
-        : "";
-}
-function renderedText(result, failure, theme) {
-    return (theme.fg(failure ? "error" : "success", failure ? "✗ " : "✓ ") +
-        theme.fg(failure ? "error" : "text", firstTextContent(result)));
-}
-export function renderIntercomResult(result, options, theme, context) {
-    if (options.isPartial) {
-        return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
-    }
-    const details = isRecord(result.details) ? result.details : undefined;
-    const failure = failed(context, details);
-    const action = isRecord(context.args) ? context.args.action : undefined;
-    if (!failure && action === "list" && options.expanded !== true) {
-        return listSummary(details, theme);
-    }
-    const text = renderedText(result, failure, theme) +
-        messageSuffix(details, options.expanded === true, theme) +
-        reasonSuffix(details, options.expanded === true, theme);
-    return new Text(text, 0, 0);
-}

package/dist/pi-intercom/ui/topic-view.js

@@ -1,88 +0,0 @@
-import { Container, ScrollView, Text, matchesKey, } from "@earendil-works/pi-tui";
-import { actionHints } from "../../tui/action-hints.js";
-function scrollDelta(data, viewport) {
-    if (matchesKey(data, "pageUp")) {
-        return -viewport;
-    }
-    if (matchesKey(data, "pageDown")) {
-        return viewport;
-    }
-    if (matchesKey(data, "up")) {
-        return -1;
-    }
-    if (matchesKey(data, "down")) {
-        return 1;
-    }
-    return 0;
-}
-export function createTopicView(options) {
-    const { tui, done, inspect, attach } = options;
-    const text = new Text("", 0, 0);
-    const scroll = new ScrollView(text, { follow: "none", scrollbar: "hidden" });
-    const render = () => {
-        tui.requestRender();
-    };
-    attach(render);
-    let closed = false;
-    const act = (delta) => {
-        if (closed) {
-            return;
-        }
-        if (delta === undefined) {
-            done();
-        }
-        else {
-            scroll.scrollBy(delta);
-        }
-        tui.requestRender();
-    };
-    const view = new Container();
-    view.addChild({
-        invalidate() {
-            scroll.invalidate();
-        },
-        render: (width) => {
-            text.setText(inspect());
-            const lines = scroll.render(width);
-            const height = Math.max(1, tui.terminal.rows - 2);
-            scroll.updateLayout(lines.length, height, render);
-            return lines.slice(scroll.scrollTop, scroll.scrollTop + height);
-        },
-    });
-    view.addChild(actionHints([
-        { text: "↑", run: () => act(-1) },
-        "/",
-        { text: "↓", run: () => act(1) },
-        " ",
-        { text: "PgUp", run: () => act(-scroll.viewportHeight) },
-        "/",
-        { text: "PgDn Read", run: () => act(scroll.viewportHeight) },
-        " · ",
-        { text: "Esc Back", run: () => act() },
-    ], (hint) => hint, "..."));
-    return {
-        invalidate() {
-            view.invalidate();
-        },
-        dispose: () => {
-            closed = true;
-            attach(null);
-        },
-        render: (width) => view.render(width),
-        handleInput(data) {
-            if (matchesKey(data, "escape")) {
-                act();
-            }
-            else {
-                act(scrollDelta(data, scroll.viewportHeight));
-            }
-        },
-        handleMouse(event) {
-            if (event.type === "wheel") {
-                act(event.wheelDelta ?? 0);
-                return { handled: true };
-            }
-            return view.handleMouse(event);
-        },
-    };
-}

package/dist/runs/background/async-chain-plan.js

@@ -1,265 +0,0 @@
-import * as path from "node:path";
-import { resolveChildMaxSubagentDepth, } from "../../shared/types.js";
-import { buildChainInstructions, isParallelStep, isDynamicParallelStep, resolveParallelBehaviors, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile, } from "../../shared/settings.js";
-import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback, } from "../../agents/skills.js";
-import { resolveChildCwd } from "../../shared/utils.js";
-import { findDuplicateOutputPath, injectSingleOutputInstruction, resolveSingleOutputPath, validateFileOnlyOutputMode, } from "../shared/single-output.js";
-import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.js";
-import { resolveEffectiveAcceptance } from "../shared/acceptance.js";
-import { createStructuredOutputRuntime } from "../shared/structured-output.js";
-import { agentRuntimeFields, usesAgentDefaultOutput, materializeAsyncDefaultOutput, withSavedLaunch, resolveLaunchModel, UnavailableSubagentSkillError, UNAVAILABLE_SUBAGENT_SKILL_ERROR, AsyncStartValidationError, } from "./async-plan.js";
-import { launchErrorMessage } from "./async-launch.js";
-function stepOverrides(step) {
-    const skills = normalizeSkillInput(step.skill);
-    return {
-        ...(step.output !== undefined ? { output: step.output } : {}),
-        ...(step.outputMode !== undefined ? { outputMode: step.outputMode } : {}),
-        ...(step.reads !== undefined ? { reads: step.reads } : {}),
-        ...(step.progress !== undefined ? { progress: step.progress } : {}),
-        ...(skills !== undefined ? { skills } : {}),
-    };
-}
-/** Owns output numbering, progress admission and continuation-session reservation during chain planning. */
-export class AsyncChainPlanner {
-    id;
-    params;
-    workspace;
-    progressInstructionCreated = false;
-    outputIndex = 0;
-    sessionIndex = 0;
-    constructor(id, params, workspace) {
-        this.id = id;
-        this.params = params;
-        this.workspace = workspace;
-    }
-    build() {
-        return this.params.chain.map((step, index) => {
-            if (isParallelStep(step)) {
-                return this.parallelGroup(step, index);
-            }
-            if (isDynamicParallelStep(step)) {
-                return this.dynamicGroup(step, index);
-            }
-            return this.sequential({ ...step, task: this.sequentialTemplate(index) }, { sessionFile: this.nextSessionFile() });
-        });
-    }
-    agent(name) {
-        const agent = this.params.agents.find((candidate) => candidate.name === name);
-        if (!agent) {
-            throw new AsyncStartValidationError(`Unknown agent: ${name}`);
-        }
-        return agent;
-    }
-    sequentialTemplate(index) {
-        const template = this.workspace.templates.at(index);
-        if (typeof template !== "string") {
-            throw new AsyncStartValidationError(`Missing task template for step ${index + 1}.`);
-        }
-        return template;
-    }
-    systemPrompt(agent, behavior, cwd) {
-        const names = behavior.skills === false ? [] : behavior.skills;
-        const { resolved, missing } = resolveSkillsWithFallback(names, cwd, this.params.ctx.cwd, {
-            projectTrusted: this.params.ctx.projectTrusted ?? true,
-        });
-        if (missing.includes("pi-subagents")) {
-            throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-        }
-        let prompt = agent.systemPrompt.trim();
-        if (resolved.length > 0) {
-            const injection = buildSkillInjection(resolved);
-            prompt = prompt.length > 0 ? `${prompt}\n\n${injection}` : injection;
-        }
-        return { prompt, skills: resolved.map((skill) => skill.name) };
-    }
-    taskInstructions(step, behavior, input) {
-        const read = buildChainInstructions({ ...behavior, output: false, progress: false }, input.cwd, false);
-        const firstProgress = behavior.progress &&
-            !input.progressPrecreated &&
-            (this.workspace.resultMode !== "chain" || !this.progressInstructionCreated);
-        if (behavior.progress && this.workspace.resultMode === "chain") {
-            this.progressInstructionCreated = true;
-        }
-        const progress = buildChainInstructions({ ...behavior, output: false, reads: false }, input.cwd, firstProgress);
-        const outputPath = resolveSingleOutputPath(input.output, this.params.ctx.cwd, input.cwd);
-        const error = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Async step (${step.agent})`);
-        if (error !== undefined && error.length > 0) {
-            throw new AsyncStartValidationError(error);
-        }
-        return {
-            task: injectSingleOutputInstruction(`${read.prefix}${step.task ?? "{previous}"}${progress.suffix}`, outputPath),
-            outputPath,
-        };
-    }
-    sequential(step, options) {
-        const agent = this.agent(step.agent);
-        const outputIndex = this.outputIndex++;
-        const cwd = resolveChildCwd(this.workspace.runnerCwd, step.cwd);
-        const instructionCwd = options.behaviorCwd ??
-            (this.workspace.resultMode === "chain" ? this.workspace.chainDir : cwd);
-        const behavior = this.behaviorForStep(agent, step, options.behavior);
-        const launchAgent = behavior.skills === false ? { ...agent, inheritSkills: false } : agent;
-        const usesDefault = usesAgentDefaultOutput(step.output) || step.outputFromAgentDefault === true;
-        const output = usesDefault && this.workspace.resultMode !== "chain"
-            ? materializeAsyncDefaultOutput({
-                output: behavior.output,
-                artifactsDir: this.params.artifactsDir,
-                asyncDir: this.workspace.asyncDir,
-                runId: this.id,
-                agent: step.agent,
-                index: outputIndex,
-            })
-            : behavior.output;
-        const skills = this.systemPrompt(agent, behavior, cwd);
-        const instructions = this.taskInstructions(step, behavior, {
-            cwd: instructionCwd,
-            output,
-            progressPrecreated: options.progressPrecreated === true,
-        });
-        return withSavedLaunch({
-            ...agentRuntimeFields(agent),
-            agent: step.agent,
-            task: instructions.task,
-            phase: step.phase,
-            label: step.label,
-            outputName: step.as,
-            structured: step.outputSchema !== undefined,
-            cwd,
-            ...resolveLaunchModel(agent, step.model, {
-                availableModels: this.params.availableModels,
-                preferredProvider: this.params.ctx.currentModelProvider,
-            }),
-            systemPrompt: skills.prompt,
-            inheritSkills: launchAgent.inheritSkills,
-            skills: [...skills.skills],
-            outputPath: instructions.outputPath,
-            output: behavior.output,
-            outputMode: behavior.outputMode,
-            ...(this.defaultOutputMarker(agent, instructions.outputPath, usesDefault)
-                ? { outputPathFromAgentDefault: true }
-                : {}),
-            sessionFile: options.sessionFile,
-            maxSubagentDepth: resolveChildMaxSubagentDepth(this.params.maxSubagentDepth, agent.maxSubagentDepth),
-            effectiveAcceptance: resolveEffectiveAcceptance({ explicit: step.acceptance }),
-            ...(step.outputSchema
-                ? {
-                    structuredOutputSchema: step.outputSchema,
-                    structuredOutput: createStructuredOutputRuntime(step.outputSchema, path.join(this.workspace.asyncDir, "structured-output")),
-                }
-                : {}),
-        }, launchAgent, this.params);
-    }
-    defaultOutputMarker(agent, outputPath, usesDefault) {
-        return (usesDefault &&
-            outputPath !== undefined &&
-            outputPath.length > 0 &&
-            typeof agent.output === "string" &&
-            !path.isAbsolute(agent.output));
-    }
-    behaviorForStep(agent, step, override) {
-        return suppressProgressForReadOnlyTask(override ?? resolveStepBehavior(agent, stepOverrides(step), this.params.chainSkills ?? []), step.task, this.workspace.originalTask);
-    }
-    parallelGroup(group, stepIndex) {
-        const templates = this.workspace.templates.at(stepIndex);
-        if (templates === undefined || typeof templates === "string") {
-            throw new AsyncStartValidationError(`Missing parallel task templates for step ${stepIndex + 1}.`);
-        }
-        const behaviors = this.workspace.resultMode === "chain"
-            ? resolveParallelBehaviors(group.parallel, this.params.agents, stepIndex, this.params.chainSkills ?? [])
-            : group.parallel.map((task) => resolveStepBehavior(this.agent(task.agent), stepOverrides(task), this.params.chainSkills ?? []));
-        const resolved = behaviors.map((behavior, index) => suppressProgressForReadOnlyTask(behavior, group.parallel[index]?.task, this.workspace.originalTask));
-        const progressPrecreated = this.workspace.resultMode === "chain" && resolved.some((behavior) => behavior.progress);
-        if (progressPrecreated) {
-            if (group.worktree !== true) {
-                writeInitialProgressFile(this.workspace.chainDir);
-            }
-            this.progressInstructionCreated = true;
-        }
-        const parallel = group.parallel.map((task, taskIndex) => this.parallelTask(group, task, {
-            stepIndex,
-            taskIndex,
-            template: templates.at(taskIndex),
-            behavior: resolved.at(taskIndex),
-            progressPrecreated,
-        }));
-        const error = findDuplicateOutputPath(parallel);
-        if (error !== undefined && error.length > 0) {
-            throw new AsyncStartValidationError(error);
-        }
-        return {
-            parallel,
-            cwd: resolveChildCwd(this.workspace.runnerCwd, group.cwd),
-            concurrency: group.concurrency,
-            failFast: group.failFast,
-            worktree: group.worktree,
-        };
-    }
-    parallelTask(group, task, input) {
-        const cwd = resolveChildCwd(this.workspace.runnerCwd, group.cwd);
-        let behaviorCwd;
-        if (group.worktree === true && this.workspace.resultMode !== "chain") {
-            try {
-                behaviorCwd = resolveExpectedWorktreeAgentCwd(cwd, `${this.id}-s${input.stepIndex}`, input.taskIndex);
-            }
-            catch {
-                /* Setup will report unusable worktrees; instructions fall back to the launch cwd. */
-            }
-        }
-        const precreated = this.initializeTaskProgress(group, task, input);
-        return this.sequential({ ...task, task: input.template, cwd: resolveChildCwd(cwd, task.cwd) }, {
-            sessionFile: this.nextSessionFile(),
-            behaviorCwd,
-            progressPrecreated: precreated,
-            behavior: input.behavior,
-        });
-    }
-    initializeTaskProgress(group, task, input) {
-        const precreated = input.progressPrecreated ||
-            (this.workspace.resultMode !== "chain" &&
-                input.behavior?.progress === true &&
-                group.worktree !== true);
-        if (precreated && !input.progressPrecreated) {
-            const progressCwd = resolveChildCwd(resolveChildCwd(this.workspace.runnerCwd, group.cwd), task.cwd);
-            try {
-                writeInitialProgressFile(progressCwd);
-            }
-            catch (error) {
-                throw new AsyncStartValidationError(`Failed to initialize progress in '${progressCwd}': ${launchErrorMessage(error)}`, { cause: error });
-            }
-        }
-        return precreated;
-    }
-    dynamicGroup(group, stepIndex) {
-        const agent = this.agent(group.parallel.agent);
-        const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agent, stepOverrides(group.parallel), this.params.chainSkills ?? []), group.parallel.task, this.workspace.originalTask);
-        if (behavior.progress) {
-            writeInitialProgressFile(this.workspace.chainDir);
-            this.progressInstructionCreated = true;
-        }
-        const count = group.expand.maxItems ?? this.params.dynamicFanoutMaxItems ?? 0;
-        return {
-            expand: group.expand,
-            parallel: this.sequential({ ...group.parallel, task: this.sequentialTemplate(stepIndex) }, { progressPrecreated: behavior.progress, behavior }),
-            collect: group.collect,
-            concurrency: group.concurrency,
-            failFast: group.failFast,
-            phase: group.phase,
-            label: group.label,
-            sessionFiles: this.takeDynamicSessions(count),
-        };
-    }
-    nextSessionFile() {
-        const file = this.params.sessionFilesByFlatIndex?.[this.sessionIndex];
-        this.sessionIndex++;
-        return file;
-    }
-    takeDynamicSessions(count) {
-        const files = this.params.sessionFilesByFlatIndex;
-        if (files === undefined || count <= 0) {
-            return;
-        }
-        const selected = files.slice(this.sessionIndex, this.sessionIndex + count);
-        this.sessionIndex += count;
-        return selected;
-    }
-}