@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/runs/foreground/question-control.js

@@ -1,193 +0,0 @@
-import * as path from "node:path";
-import { errorMessage } from "../../shared/unknown.js";
-import { formatRunAction } from "../../shared/status-format.js";
-import { cancelSupervisorQuestion, claimQuestionRevival, formatSupervisorQuestions, listSupervisorQuestions, questionProcessAlive, questionRecoveryHint, readQuestionState, recordQuestionDelivery, releaseQuestionRevival, saveQuestionAnswer, supervisorQuestionPage, } from "../shared/supervisor-questions.js";
-import { liveLaunchOverrideNotice } from "./foreground-control.js";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
-import { reviveSavedSubagent } from "./saved-revival.js";
-function questionResult(questions, text) {
-    return {
-        content: [{ type: "text", text }],
-        details: { mode: "management", results: [], ...supervisorQuestionPage(questions) },
-    };
-}
-function resultMatches(result, pattern) {
-    return result.content.some((item) => item.type === "text" && pattern.test(item.text));
-}
-function questionRunId(params) {
-    const dirId = params.dir !== undefined && params.dir.length > 0 ? path.basename(params.dir) : undefined;
-    return params.id ?? params.runId ?? dirId;
-}
-function pendingQuestion(question) {
-    return question.state === "awaiting_input" || question.state === "answer_pending";
-}
-export function projectSupervisorQuestions(result, params, ownerSessionId, childSafe = false) {
-    const questionOnly = result.isError === true && resultMatches(result, /Async run not found|Status file not found/);
-    if (result.isError === true && !questionOnly) {
-        return result;
-    }
-    const questions = listSupervisorQuestions(ownerSessionId, questionRunId(params)).filter(pendingQuestion);
-    if (questions.length === 0) {
-        return result;
-    }
-    const page = supervisorQuestionPage(questions);
-    return {
-        ...result,
-        ...(questionOnly ? { isError: false } : {}),
-        content: [
-            {
-                type: "text",
-                text: [
-                    `Supervisor input (not execution completion):\n${formatSupervisorQuestions(page.questions, childSafe)}`,
-                    ...(page.questionList.nextOffset !== undefined
-                        ? [
-                            `More questions: ${formatRunAction("questions", questionRunId(params), { offset: page.questionList.nextOffset, limit: page.questionList.limit }, childSafe)}`,
-                        ]
-                        : []),
-                    ...(questionOnly
-                        ? []
-                        : result.content.map((item) => (item.type === "text" ? item.text : ""))),
-                ].join("\n\n"),
-            },
-        ],
-        details: { ...result.details, ...page },
-    };
-}
-function supervisorControlRunId(result, params) {
-    return result.details.managementControl?.runId ?? params.id ?? params.runId;
-}
-export function cancelSupervisorInput(result, params, ownerSessionId, events) {
-    const rejected = result.isError === true &&
-        !resultMatches(result, /No interrupt-capable run|No running async run|has no (active|running) child at index \d+/);
-    if (rejected) {
-        return result;
-    }
-    const id = supervisorControlRunId(result, params);
-    if (id === undefined || id.length === 0) {
-        return result;
-    }
-    const questions = listSupervisorQuestions(ownerSessionId, id).filter((question) => (params.index === undefined || params.index === question.index) && pendingQuestion(question));
-    if (questions.length === 0) {
-        return result;
-    }
-    for (const question of questions) {
-        cancelSupervisorQuestion(question);
-        events?.emit("subagent:supervisor-question-resolved", { questionId: question.questionId });
-    }
-    const cancelled = questions.map((question) => readQuestionState(question));
-    return result.isError === true
-        ? questionResult(cancelled, `Cancelled ${questions.length} pending supervisor question(s). Any live waiter will abort its agent; cancellation is requested, not proof of process exit.`)
-        : { ...result, details: { ...result.details, ...supervisorQuestionPage(cancelled) } };
-}
-function selectQuestion(input) {
-    const { params } = input;
-    if (params.dir !== undefined) {
-        throw new Error("questions/answer use a run id, not dir.");
-    }
-    if (params.index !== undefined && (!Number.isSafeInteger(params.index) || params.index < 0)) {
-        throw new Error("index must be a non-negative integer.");
-    }
-    return listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), params.id ?? params.runId).filter((question) => (params.index === undefined || question.index === params.index) &&
-        (params.action !== "questions" ||
-            params.questionId === undefined ||
-            question.questionId === params.questionId));
-}
-function questionPageResult(questions, params, childSafe) {
-    const page = supervisorQuestionPage(questions, params);
-    const text = [
-        formatSupervisorQuestions(page.questions, childSafe),
-        `Questions: ${page.questions.length} shown, ${page.questionList.total} total (offset ${page.questionList.offset}).`,
-        ...(page.questionList.nextOffset !== undefined
-            ? [
-                `More questions: ${formatRunAction("questions", params.id ?? params.runId, {
-                    offset: page.questionList.nextOffset,
-                    limit: page.questionList.limit,
-                    ...(params.index !== undefined ? { index: params.index } : {}),
-                    ...(params.questionId !== undefined ? { questionId: params.questionId } : {}),
-                }, childSafe)}`,
-            ]
-            : []),
-    ].join("\n\n");
-    return {
-        content: [{ type: "text", text }],
-        details: { mode: "management", results: [], ...page },
-    };
-}
-/** Save the durable answer before either notifying the live waiter or claiming revival. */
-export function controlSupervisorQuestion(input) {
-    try {
-        const questions = selectQuestion(input);
-        const { params } = input;
-        if (params.action === "questions") {
-            return questionPageResult(questions, params, nestedResolutionScopeForExecutor(input.deps) !== undefined);
-        }
-        const id = params.id ?? params.runId;
-        if (id === undefined ||
-            id.length === 0 ||
-            params.questionId === undefined ||
-            params.questionId.length === 0) {
-            throw new Error("action='answer' requires id and questionId.");
-        }
-        const question = questions.find((entry) => entry.questionId === params.questionId);
-        if (!question) {
-            throw new Error("Question not found in this session's runs. Resume the owning supervisor session to answer it.");
-        }
-        const answer = saveQuestionAnswer(question, params.message ?? "", undefined, params.messageOrigin);
-        input.deps.pi.events.emit("subagent:supervisor-question-resolved", {
-            questionId: question.questionId,
-        });
-        return deliverQuestionAnswer(input, question, answer);
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: errorMessage(error) }],
-            isError: true,
-            details: { mode: "management", results: [] },
-        };
-    }
-}
-function deliverQuestionAnswer(input, question, answer) {
-    if (!question.delivery && questionProcessAlive(question)) {
-        return questionResult([readQuestionState(question)], [
-            `Answer saved for question ${question.questionId}. The live child will read it from the durable waiter; delivery is pending, not execution completion.`,
-            liveLaunchOverrideNotice(input.params),
-        ]
-            .filter((notice) => notice !== undefined && notice.length > 0)
-            .join("\n"));
-    }
-    const delivery = readQuestionState(question).delivery;
-    if (delivery) {
-        return questionResult([readQuestionState(question)], `Question ${question.questionId} was already answered; no new work started. Delivery: ${delivery.kind}, run: ${delivery.runId}.`);
-    }
-    return reviveQuestionAnswer(input, question, answer);
-}
-/** Claim before launch; publish delivery only after a successful handoff. */
-function reviveQuestionAnswer(input, question, answer) {
-    const claim = claimQuestionRevival(question);
-    if (!claim.claimed) {
-        return questionResult([readQuestionState(question)], `Answer retained for question ${question.questionId}; continuation ${claim.runId} was already requested. No duplicate process started. Inspect that run first. ${questionRecoveryHint(question, nestedResolutionScopeForExecutor(input.deps) !== undefined)}`);
-    }
-    // A throw can follow process handoff. Retain the claim on an ambiguous failure
-    // so a retry cannot launch a duplicate; only an explicit failed receipt releases it.
-    const result = reviveSavedSubagent({
-        ...input,
-        params: {
-            ...input.params,
-            message: `${answer.origin === "human" ? "Direct user answer (human origin)" : "Supervisor answer"} to question ${question.questionId}:\n\n${answer.message}\n\nOriginal question:\n${question.message}`,
-        },
-    }, { ...question, source: "question" }, claim.runId);
-    if (result.isError === true) {
-        releaseQuestionRevival(question);
-    }
-    else {
-        recordQuestionDelivery(question, {
-            kind: "revive",
-            runId: claim.runId,
-            deliveredAt: Date.now(),
-        });
-    }
-    return {
-        ...result,
-        details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) },
-    };
-}

package/dist/runs/foreground/resume-target.js

@@ -1,221 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { resolveAsyncResumeTarget } from "../background/async-resume.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { resolveNestedAsyncDir } from "../shared/nested-events.js";
-import { readStatus } from "../../shared/utils.js";
-import { resolveRememberedForegroundRun } from "./foreground-memory.js";
-function foregroundTarget(params, state) {
-    const requested = (params.id ?? params.runId)?.trim();
-    const run = resolveRememberedForegroundRun(requested, state);
-    if (!run) {
-        return;
-    }
-    if (run.children.length > 1 && params.index === undefined) {
-        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`);
-    }
-    const index = params.index ?? 0;
-    if (!Number.isInteger(index)) {
-        throw new Error(`Foreground run '${run.runId}' index must be an integer.`);
-    }
-    const child = index >= 0 ? run.children.at(index) : undefined;
-    if (!child) {
-        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
-    }
-    const sessionFile = foregroundSessionFile(run.runId, index, child);
-    return {
-        kind: "revive",
-        source: "foreground",
-        runId: run.runId,
-        state: "complete",
-        agent: child.agent,
-        index,
-        intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index),
-        cwd: run.cwd,
-        sessionFile,
-        effectiveAcceptance: child.effectiveAcceptance,
-    };
-}
-function foregroundSessionFile(runId, index, child) {
-    if (child.status === "detached") {
-        throw new Error(`Foreground run '${runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`);
-    }
-    const file = child.sessionFile;
-    if (file === undefined || file.length === 0) {
-        throw new Error(`Foreground run '${runId}' child ${index} does not have a persisted session file to resume from.`);
-    }
-    if (path.extname(file) !== ".jsonl") {
-        throw new Error(`Foreground run '${runId}' child ${index} session file must be a .jsonl file: ${file}`);
-    }
-    const resolved = path.resolve(file);
-    if (!fs.existsSync(resolved)) {
-        throw new Error(`Foreground run '${runId}' child ${index} session file does not exist: ${file}`);
-    }
-    return resolved;
-}
-function asyncCandidate(params) {
-    try {
-        const target = resolveAsyncResumeTarget(params);
-        return {
-            target: target.kind === "live"
-                ? { ...target, kind: "live", source: "async" }
-                : { ...target, kind: "revive", source: "async" },
-        };
-    }
-    catch (error) {
-        return {
-            error,
-            rethrow: () => {
-                throw error;
-            },
-        };
-    }
-}
-function foregroundCandidate(params, state) {
-    try {
-        return { target: foregroundTarget(params, state) };
-    }
-    catch (error) {
-        return {
-            error,
-            rethrow: () => {
-                throw error;
-            },
-        };
-    }
-}
-function exactError(error, source, requested) {
-    if (!(error instanceof Error) || requested.length === 0) {
-        return false;
-    }
-    const escaped = requested.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`\\b${source} run '${escaped}'`, "i").test(error.message);
-}
-function ambiguity(error) {
-    return error instanceof Error && /Ambiguous .*run id prefix/.test(error.message);
-}
-function preferCandidate(target, failure, requested, source) {
-    if (failure &&
-        (exactError(failure.error, source, requested) ||
-            (ambiguity(failure.error) && target.runId !== requested))) {
-        failure.rethrow();
-    }
-    return target;
-}
-function chooseBoth(foreground, asynchronous, requested) {
-    if (foreground.runId === requested && asynchronous.runId !== requested) {
-        return foreground;
-    }
-    if (asynchronous.runId === requested && foreground.runId !== requested) {
-        return asynchronous;
-    }
-    throw new Error(`Resume id '${requested}' is ambiguous between foreground run '${foreground.runId}' and async run '${asynchronous.runId}'. Provide a full run id.`);
-}
-function selectResumeCandidate(foreground, asynchronous, requested) {
-    const fg = "target" in foreground ? foreground.target : undefined;
-    const async = "target" in asynchronous ? asynchronous.target : undefined;
-    if (fg && async) {
-        return chooseBoth(fg, async, requested);
-    }
-    if (fg) {
-        return preferCandidate(fg, "error" in asynchronous ? asynchronous : undefined, requested, "async");
-    }
-    if (async) {
-        return preferCandidate(async, "error" in foreground ? foreground : undefined, requested, "foreground");
-    }
-    return rethrowMissingCandidates(foreground, asynchronous);
-}
-function rethrowMissingCandidates(foreground, asynchronous) {
-    if ("error" in foreground && Boolean(foreground.error)) {
-        foreground.rethrow();
-    }
-    if ("error" in asynchronous && Boolean(asynchronous.error)) {
-        asynchronous.rethrow();
-    }
-    throw new Error("Run not found. Provide id or runId.");
-}
-export function resolveResumeTarget(params, state) {
-    const requested = (params.id ?? params.runId)?.trim() ?? "";
-    return selectResumeCandidate(foregroundCandidate(params, state), asyncCandidate(params), requested);
-}
-function nestedSessionFile(run) {
-    return run.sessionFile ?? (run.steps?.length === 1 ? run.steps[0]?.sessionFile : undefined);
-}
-function pathWithin(base, candidate) {
-    const root = path.resolve(base), file = path.resolve(candidate);
-    return file === root || file.startsWith(`${root}${path.sep}`);
-}
-function trustedSessionFile(run, roots) {
-    const file = nestedSessionFile(run);
-    if (file === undefined || file.length === 0) {
-        throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
-    }
-    if (path.extname(file) !== ".jsonl") {
-        throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${file}`);
-    }
-    if (!path.isAbsolute(file)) {
-        throw new Error(`Nested run '${run.id}' session file must be absolute: ${file}`);
-    }
-    const resolved = path.resolve(file);
-    if (!fs.existsSync(resolved)) {
-        throw new Error(`Nested run '${run.id}' session file does not exist: ${file}`);
-    }
-    const stat = fs.lstatSync(resolved);
-    if (!stat.isFile() || stat.isSymbolicLink()) {
-        throw new Error(`Nested run '${run.id}' session file is not a regular file: ${file}`);
-    }
-    const real = fs.realpathSync(resolved);
-    const trusted = roots.filter((root) => fs.existsSync(root)).map((root) => fs.realpathSync(root));
-    if (!trusted.some((root) => pathWithin(root, real))) {
-        throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${file}`);
-    }
-    if (!real.split(path.sep).includes(run.id)) {
-        throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${file}`);
-    }
-    return real;
-}
-function nestedState(run) {
-    if (run.state === "complete" ||
-        run.state === "failed" ||
-        run.state === "blocked" ||
-        run.state === "paused") {
-        return run.state;
-    }
-    return "failed";
-}
-function nestedAgent(run) {
-    const agent = run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : undefined);
-    if (agent === undefined || agent.length === 0) {
-        throw new Error(`Could not determine child agent for nested run '${run.id}'.`);
-    }
-    return agent;
-}
-function nestedRuntimeDetails(dir) {
-    if (dir === undefined || dir.length === 0) {
-        return {};
-    }
-    return {
-        cwd: path.dirname(dir),
-        effectiveAcceptance: readStatus(dir)?.steps?.[0]?.acceptance?.effectiveAcceptance,
-    };
-}
-export function resolveNestedResumeTarget(target, trustedRoots) {
-    const run = target.match.run;
-    if (run.state === "running" || run.state === "queued") {
-        throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
-    }
-    const agent = nestedAgent(run);
-    const dir = resolveNestedAsyncDir(target.match.rootRunId, run);
-    const runtime = nestedRuntimeDetails(dir);
-    return {
-        kind: "revive",
-        source: "nested",
-        runId: run.id,
-        state: nestedState(run),
-        agent,
-        index: 0,
-        intercomTarget: resolveSubagentIntercomTarget(run.id, agent, 0),
-        sessionFile: trustedSessionFile(run, trustedRoots),
-        ...runtime,
-    };
-}

package/dist/runs/foreground/revival-launch-policy.js

@@ -1,58 +0,0 @@
-import { acceptanceInputFromResolved } from "../shared/acceptance.js";
-import { resolveControlConfig } from "../shared/subagent-control.js";
-import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.js";
-import { resolveCurrentMaxSubagentDepth, } from "../../shared/types.js";
-function resources(input) {
-    return {
-        maxOutput: input.params.maxOutput ?? input.saved?.maxOutput,
-        shareEnabled: input.params.share ?? input.saved?.share ?? false,
-    };
-}
-function artifacts(input) {
-    const disabled = input.params.artifacts === false ||
-        (input.params.artifacts === undefined && input.saved?.artifacts === false);
-    return {
-        artifactsDir: disabled ? undefined : (input.saved?.artifactsDir ?? input.tempArtifactsDir),
-    };
-}
-function outputTarget(input) {
-    const filename = input.generatedOutputFilename;
-    const output = filename !== undefined && filename.length > 0
-        ? true
-        : (input.saved?.output ?? input.contract.output);
-    return { output: input.params.output ?? output, generatedOutputFilename: filename };
-}
-function outputFormat(input) {
-    return {
-        outputMode: input.params.outputMode ?? input.saved?.outputMode ?? input.contract.outputMode,
-        outputSchema: input.params.outputSchema ?? input.saved?.outputSchema ?? input.contract.outputSchema,
-    };
-}
-function acceptance(input) {
-    return {
-        acceptance: input.params.acceptance ??
-            acceptanceInputFromResolved(input.contract.effectiveAcceptance ?? input.saved?.effectiveAcceptance),
-    };
-}
-function control(input) {
-    return {
-        controlConfig: resolveControlConfig(input.saved?.controlConfig ?? input.config.control, input.params.control),
-        projectTrust: input.saved?.projectTrust ??
-            resolveConfiguredChildProjectTrustPolicy(input.config.projectTrust),
-        maxSubagentDepth: input.saved?.maxSubagentDepth ??
-            resolveCurrentMaxSubagentDepth(input.config.maxSubagentDepth),
-        worktreeSetupHook: input.config.worktreeSetupHook,
-        worktreeSetupHookTimeoutMs: input.config.worktreeSetupHookTimeoutMs,
-    };
-}
-/** Explicit overrides win over the frozen launch; legacy contract output/acceptance remain recoverable. */
-export function resolveRevivalLaunchPolicy(input) {
-    return {
-        ...artifacts(input),
-        ...resources(input),
-        ...outputTarget(input),
-        ...outputFormat(input),
-        ...acceptance(input),
-        ...control(input),
-    };
-}