@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/runs/shared/mutating-tool-guard.js

@@ -1,3 +1,4 @@
+import { isRecord } from "../../shared/unknown.js";
 const MUTATING_BASH_PATTERNS = [
     /(^|[;&|()\s])rm\s+/,
     /(^|[;&|()\s])mv\s+/,
@@ -13,88 +14,105 @@ const MUTATING_BASH_PATTERNS = [
     /\bwrite_text\s*\(/,
     /\bopen\s*\([^)]*,\s*["'][wa]/,
 ];
-export function resolveCurrentPath(toolName, args) {
-    if (!toolName || !args)
-        return undefined;
-    const direct = ["path", "file", "filename", "target", "cwd"];
-    for (const key of direct) {
+function directPath(args) {
+    for (const key of ["path", "file", "filename", "target", "cwd"]) {
         const value = args[key];
-        if (typeof value === "string" && value.trim())
+        if (typeof value === "string" && value.trim() !== "") {
             return value.trim();
+        }
+    }
+    return;
+}
+export function resolveCurrentPath(toolName, args) {
+    if (toolName === undefined || toolName === "" || !args) {
+        return;
     }
-    if (toolName === "bash") {
-        const command = typeof args.command === "string" ? args.command : undefined;
-        if (!command)
-            return undefined;
-        const redirect = command.match(/(?:>>?|tee\s+)\s*([^&>\s][^\s;&|]*)/);
-        if (redirect?.[1])
+    const direct = directPath(args);
+    if (direct !== undefined) {
+        return direct;
+    }
+    if (toolName === "bash" && typeof args.command === "string") {
+        const redirect = args.command.match(/(?:>>?|tee\s+)\s*([^&>\s][^\s;&|]*)/);
+        if (redirect?.[1] !== undefined && redirect[1] !== "") {
             return redirect[1];
+        }
+    }
+    return;
+}
+function redirectionTarget(command, offset) {
+    if (command[offset - 1] === "-") {
+        return false;
     }
-    return undefined;
+    let cursor = offset + (command[offset + 1] === ">" ? 2 : 1);
+    while (cursor < command.length && /\s/.test(command[cursor])) {
+        cursor++;
+    }
+    return cursor < command.length && !["&", "|", ";", "(", ")"].includes(command[cursor]);
 }
 function hasUnquotedFileRedirection(command) {
-    let inSingle = false;
-    let inDouble = false;
+    let quote;
     for (let i = 0; i < command.length; i++) {
         const char = command[i];
-        if (char === "'" && !inDouble) {
-            inSingle = !inSingle;
+        if (char === "'" || char === '"') {
+            if (quote === char) {
+                quote = undefined;
+            }
+            else if (quote === undefined) {
+                quote = char;
+            }
             continue;
         }
-        if (char === '"' && !inSingle) {
-            inDouble = !inDouble;
-            continue;
+        if (quote === undefined && char === ">" && redirectionTarget(command, i)) {
+            return true;
         }
-        if (inSingle || inDouble)
-            continue;
-        if (char !== ">")
-            continue;
-        if (command[i - 1] === "-")
-            continue;
-        const isDouble = command[i + 1] === ">";
-        let cursor = i + (isDouble ? 2 : 1);
-        while (cursor < command.length && /\s/.test(command[cursor]))
-            cursor++;
-        if (cursor >= command.length)
-            continue;
-        const targetStart = command[cursor];
-        if (targetStart === "&" || targetStart === "|" || targetStart === ";")
-            continue;
-        if (targetStart === "(" || targetStart === ")")
-            continue;
-        return true;
     }
     return false;
 }
 export function isMutatingBashCommand(command) {
-    return hasUnquotedFileRedirection(command) || MUTATING_BASH_PATTERNS.some((pattern) => pattern.test(command));
+    return (hasUnquotedFileRedirection(command) ||
+        MUTATING_BASH_PATTERNS.some((pattern) => pattern.test(command)));
 }
 export function isMutatingTool(toolName, args) {
-    if (!toolName || args?.preview === true)
+    if (toolName === undefined || toolName === "" || args?.preview === true) {
         return false;
-    if (["edit", "write", "apply_edits", "apply_patch", "replace_text", "write_files"].includes(toolName))
+    }
+    if (["edit", "write", "apply_edits", "apply_patch", "replace_text", "write_files"].includes(toolName)) {
         return true;
-    if (toolName !== "bash")
+    }
+    if (toolName !== "bash") {
         return false;
+    }
     const command = typeof args?.command === "string" ? args.command : "";
-    if (!command.trim())
+    if (command.trim() === "") {
         return false;
+    }
     return isMutatingBashCommand(command);
 }
+function committedMutation(tool, input) {
+    if (isRecord(input?.details)) {
+        if (input.details.preview === true) {
+            return false;
+        }
+        if (Array.isArray(input.details.modifiedFiles)) {
+            return input.details.modifiedFiles.some((file) => typeof file === "string" && file.trim().length > 0);
+        }
+    }
+    return input?.isError !== true && !["apply_patch", "replace_text", "write_files"].includes(tool);
+}
 export function createMutationCompletionTracker() {
     const pending = [];
     const take = (input) => {
-        const id = typeof input?.toolCallId === "string" ? input.toolCallId : undefined;
-        if (id) {
-            const index = pending.findIndex((tool) => tool.id === id);
-            if (index >= 0)
+        if (typeof input?.toolCallId === "string" && input.toolCallId !== "") {
+            const index = pending.findIndex((tool) => tool.id === input.toolCallId);
+            if (index >= 0) {
                 return pending.splice(index, 1)[0];
+            }
         }
-        const name = typeof input?.toolName === "string" ? input.toolName : undefined;
-        if (name) {
-            const index = pending.findIndex((tool) => tool.tool === name);
-            if (index >= 0)
+        if (typeof input?.toolName === "string" && input.toolName !== "") {
+            const index = pending.findIndex((tool) => tool.tool === input.toolName);
+            if (index >= 0) {
                 return pending.splice(index, 1)[0];
+            }
         }
         return pending.shift();
     };
@@ -113,58 +131,80 @@ export function createMutationCompletionTracker() {
         },
         recordToolResult(input) {
             const entry = take(input);
-            if (!entry)
-                return undefined;
+            if (!entry) {
+                return;
+            }
             const errored = input?.isError === true;
-            const details = input?.details && typeof input.details === "object" ? input.details : undefined;
-            const committed = Array.isArray(details?.modifiedFiles)
-                ? details.modifiedFiles.some((file) => typeof file === "string" && file.trim().length > 0)
-                : !errored && !["apply_patch", "replace_text", "write_files"].includes(entry.tool);
-            return { ...entry, errored, completedMutation: entry.mutates && details?.preview !== true && committed };
+            return {
+                ...entry,
+                errored,
+                completedMutation: entry.mutates && committedMutation(entry.tool, input),
+            };
         },
     };
 }
+/** Owns the failure window and path streak; callers record events rather than mutate it. */
+class MutatingFailures {
+    failures = 0;
+    lastAt;
+    recent = [];
+    path;
+    repeated = 0;
+    get consecutiveFailures() {
+        return this.failures;
+    }
+    get lastFailureAt() {
+        return this.lastAt;
+    }
+    get recentFailures() {
+        return this.recent;
+    }
+    get lastMutatingPath() {
+        return this.path;
+    }
+    get repeatedPathFailures() {
+        return this.repeated;
+    }
+    reset = () => {
+        this.failures = 0;
+        this.lastAt = undefined;
+        this.recent.length = 0;
+        this.path = undefined;
+        this.repeated = 0;
+    };
+    record = (input, windowMs) => {
+        if (this.lastAt === undefined || input.ts - this.lastAt > windowMs) {
+            this.reset();
+        }
+        this.lastAt = input.ts;
+        this.failures += 1;
+        if (input.path !== undefined && input.path !== "") {
+            this.repeated = this.path === input.path ? this.repeated + 1 : 1;
+            this.path = input.path;
+        }
+        this.recent.push(input);
+        if (this.recent.length > 3) {
+            this.recent.shift();
+        }
+    };
+}
 export function resetMutatingFailureState(state) {
-    state.consecutiveFailures = 0;
-    state.lastFailureAt = undefined;
-    state.recentFailures = [];
-    state.lastMutatingPath = undefined;
-    state.repeatedPathFailures = 0;
+    state.reset();
 }
 export function createMutatingFailureState() {
-    return {
-        consecutiveFailures: 0,
-        recentFailures: [],
-        repeatedPathFailures: 0,
-    };
+    return new MutatingFailures();
 }
 export function recordMutatingFailure(state, input, windowMs) {
-    if (state.lastFailureAt === undefined || input.ts - state.lastFailureAt > windowMs) {
-        state.consecutiveFailures = 0;
-        state.recentFailures = [];
-        state.repeatedPathFailures = 0;
-        state.lastMutatingPath = undefined;
-    }
-    state.lastFailureAt = input.ts;
-    state.consecutiveFailures += 1;
-    if (input.path && state.lastMutatingPath === input.path) {
-        state.repeatedPathFailures += 1;
-    }
-    else if (input.path) {
-        state.lastMutatingPath = input.path;
-        state.repeatedPathFailures = 1;
-    }
-    state.recentFailures.push(input);
-    if (state.recentFailures.length > 3)
-        state.recentFailures.shift();
+    state.record(input, windowMs);
 }
 export function shouldEscalateMutatingFailures(state, threshold) {
     return state.consecutiveFailures >= threshold || state.repeatedPathFailures >= threshold;
 }
 export function summarizeRecentMutatingFailures(state) {
-    if (state.recentFailures.length === 0)
+    if (state.recentFailures.length === 0) {
         return undefined;
+    }
     return state.recentFailures
-        .map((entry) => `${entry.tool}${entry.path ? `(${entry.path})` : ""}: ${entry.error}`)
+        .map((entry) => `${entry.tool}${(entry.path ?? "") !== "" ? `(${entry.path ?? ""})` : ""}: ${entry.error}`)
         .join(" | ");
 }

package/dist/runs/shared/native-finalization-types.js

@@ -0,0 +1 @@
+export const FINALIZATION_EVENT = "subagent.finalization";

package/dist/runs/shared/native-finalization.js

@@ -2,100 +2,179 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Type } from "../../shared/native-typebox.js";
 import { setPromptSection } from "../../shared/prompt-sections.js";
 import { detectSubagentError, getFinalOutput } from "../../shared/utils.js";
 import { acceptanceFailureMessage, acceptanceSelfReviewConfig, createFinalizationReportRuntime, evaluateAcceptance, formatAcceptanceFinalizationPrompt, readFinalizationReport, resolveFinalizationOutput, stripAcceptanceReport, } from "./acceptance.js";
 import { captureSingleOutputSnapshot, resolveSingleOutput } from "./single-output.js";
-import { readStructuredOutput, validateStructuredOutputValue } from "./structured-output.js";
+import { readStructuredOutput } from "./structured-output.js";
 import { compactObservedMessage } from "./child-observations.js";
+import { registerChildStructuredTool } from "./child-structured-tool.js";
+import { parseNativeFinalizationConfig } from "../background/run-schemas.js";
+import { FINALIZATION_EVENT, } from "./native-finalization-types.js";
+import { nonempty } from "./child-presence.js";
+export { FINALIZATION_EVENT, } from "./native-finalization-types.js";
 const CONFIG_ENV = "PI_SUBAGENT_FINALIZATION_CONFIG";
-export const FINALIZATION_EVENT = "subagent.finalization";
 export function createNativeFinalization(acceptance, publicOutput, outputPath) {
-    return { nonce: randomUUID(), acceptance, reportRuntime: createFinalizationReportRuntime(publicOutput?.schema), publicOutput,
-        outputPath, outputSnapshot: captureSingleOutputSnapshot(outputPath) };
+    return {
+        nonce: randomUUID(),
+        acceptance,
+        reportRuntime: createFinalizationReportRuntime(publicOutput?.schema),
+        publicOutput,
+        outputPath,
+        outputSnapshot: captureSingleOutputSnapshot(outputPath),
+    };
 }
 export function nativeFinalizationLaunch(config) {
     const configPath = path.join(path.dirname(config.reportRuntime.schemaPath), "finalization.json");
     fs.writeFileSync(configPath, JSON.stringify(config), { mode: 0o600 });
-    return { extension: fileURLToPath(new URL(`native-finalization${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url)), env: { [CONFIG_ENV]: configPath } };
+    return {
+        extension: fileURLToPath(new URL(`native-finalization${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url)),
+        env: { [CONFIG_ENV]: configPath },
+    };
 }
-/** Self-review includes structural and workspace checks; configured verification stays owner-run. */
-export default function registerNativeFinalization(pi) {
-    const configPath = process.env[CONFIG_ENV];
-    if (!configPath)
-        return;
-    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-    const { acceptance, reportRuntime } = config;
-    const selfReview = acceptanceSelfReviewConfig(acceptance);
-    const messages = [];
-    let messageOffset = 0;
-    let turn = 0;
-    let initialOutput = "";
-    let latestOutput = "";
-    let initialLedger;
-    let resolvedOutput = { fullOutput: "" };
-    const registerOutput = (runtime) => pi.registerTool({
-        name: "structured_output", label: "Structured Output", description: "Submit the complete output matching the current schema.",
-        parameters: Type.Object({ value: Type.Unsafe(runtime.schema) }, { additionalProperties: false }),
-        constrainedSampling: { type: "json_schema", strict: "prefer" },
-        execute: async (_id, args) => {
-            const validation = validateStructuredOutputValue(runtime.schema, args.value);
-            if (validation.status === "invalid")
-                throw new Error(validation.message);
-            fs.writeFileSync(runtime.outputPath, JSON.stringify(args.value), { mode: 0o600 });
-            return { content: [{ type: "text", text: "Structured output captured." }], details: {}, terminate: true };
-        },
-    });
-    if (config.publicOutput) {
-        registerOutput(config.publicOutput);
-        pi.on("before_agent_start", (event) => setPromptSection(event.systemPromptOptions, "subagent_output", "Your final action must call structured_output with JSON matching the current schema. Prose alone does not complete this output contract."));
+/** Owns self-review turns; command verification remains exclusively owner-run. */
+class NativeReview {
+    config;
+    messages = [];
+    messageOffset = 0;
+    turn = 0;
+    initialOutput = "";
+    latestOutput = "";
+    initialLedger;
+    resolvedOutput = { fullOutput: "" };
+    constructor(config) {
+        this.config = config;
+    }
+    observe(message) {
+        if (["assistant", "user", "toolResult"].includes(message.role)) {
+            const output = getFinalOutput([message]);
+            if (output.length > 0) {
+                this.latestOutput = output;
+            }
+            this.messages.push(compactObservedMessage(message));
+        }
     }
-    pi.on("message_end", (event) => {
-        if (["assistant", "user", "toolResult"].includes(event.message.role)) {
-            latestOutput = getFinalOutput([event.message]) || latestOutput;
-            messages.push(compactObservedMessage(event.message));
+    submission() {
+        const submission = this.turn === 0
+            ? { output: this.latestOutput }
+            : readFinalizationReport(this.messages, this.config.reportRuntime, {
+                messageOffset: this.messageOffset,
+            });
+        if (this.turn === 0) {
+            this.initialOutput = submission.output;
+            const hiddenError = detectSubagentError(this.messages);
+            if (hiddenError.hasError) {
+                submission.error = hiddenError.details ?? `${hiddenError.errorType ?? "Subagent"} failed`;
+            }
+            if (this.config.publicOutput) {
+                submission.error ??= readStructuredOutput(this.config.publicOutput).error;
+            }
+        }
+        return submission;
+    }
+    saveOutput(submission) {
+        if (nonempty(submission.error) || nonempty(submission.reportSubmissionError)) {
+            return;
+        }
+        const output = this.turn === 0
+            ? stripAcceptanceReport(submission.output)
+            : resolveFinalizationOutput(submission.output, this.resolvedOutput.fullOutput);
+        this.resolvedOutput = resolveSingleOutput(this.config.outputPath, output, this.turn === 0 ? this.config.outputSnapshot : this.resolvedOutput.writtenSnapshot);
+        return nonempty(this.resolvedOutput.saveError)
+            ? `Failed to save output file '${this.config.outputPath ?? ""}': ${this.resolvedOutput.saveError}`
+            : undefined;
+    }
+    nextPrompt(submission, ledger) {
+        if (nonempty(submission.error) ||
+            ledger.status === "blocked" ||
+            this.turn >= this.config.acceptance.finalization.maxTurns) {
+            return;
         }
-    });
-    pi.on("agent_before_settle", async (event, ctx) => {
-        if (event.outcome !== "completed")
+        if (!this.initialLedger) {
+            throw new Error("Native self-review initial acceptance ledger is missing");
+        }
+        if (this.turn !== 0 &&
+            !nonempty(submission.reportSubmissionError) &&
+            ledger.status !== "rejected") {
             return;
-        const submission = turn === 0
-            ? { output: latestOutput }
-            : readFinalizationReport(messages, reportRuntime, { messageOffset });
-        if (turn === 0) {
-            initialOutput = submission.output;
-            const hiddenError = detectSubagentError(messages);
-            if (hiddenError.hasError)
-                submission.error = hiddenError.details ?? `${hiddenError.errorType} failed`;
-            if (config.publicOutput)
-                submission.error ??= readStructuredOutput(config.publicOutput).error;
         }
-        const ledger = await evaluateAcceptance({ acceptance: selfReview, governing: acceptance, cwd: ctx.cwd,
-            output: submission.reportSubmissionError ? "" : submission.output, report: submission.reportSubmissionError ? undefined : submission.report });
-        initialLedger ??= ledger;
-        if (!submission.error && !submission.reportSubmissionError) {
-            const output = turn === 0 ? stripAcceptanceReport(submission.output) : resolveFinalizationOutput(submission.output, resolvedOutput.fullOutput);
-            resolvedOutput = resolveSingleOutput(config.outputPath, output, turn === 0 ? config.outputSnapshot : resolvedOutput.writtenSnapshot);
-            if (resolvedOutput.saveError)
-                submission.error = `Failed to save output file '${config.outputPath}': ${resolvedOutput.saveError}`;
+        return formatAcceptanceFinalizationPrompt({
+            acceptance: this.config.acceptance,
+            initialOutput: this.initialOutput,
+            initialLedger: this.initialLedger,
+            turn: this.turn + 1,
+            maxTurns: this.config.acceptance.finalization.maxTurns,
+            previousFailure: submission.reportSubmissionError ?? acceptanceFailureMessage(ledger),
+            nativeReport: true,
+            outputSchema: this.config.publicOutput?.schema,
+        });
+    }
+    async settle(event, ctx, pi) {
+        if (event.outcome !== "completed") {
+            return;
         }
-        const continueReview = !submission.error && ledger.status !== "blocked" && turn < acceptance.finalization.maxTurns
-            && (turn === 0 || Boolean(submission.reportSubmissionError) || ledger.status === "rejected");
-        const nextPrompt = continueReview ? formatAcceptanceFinalizationPrompt({ acceptance, initialOutput, initialLedger,
-            turn: turn + 1, maxTurns: acceptance.finalization.maxTurns,
-            previousFailure: submission.reportSubmissionError ?? acceptanceFailureMessage(ledger), nativeReport: true, outputSchema: config.publicOutput?.schema }) : undefined;
-        const marker = { type: FINALIZATION_EVENT, nonce: config.nonce, turn, lastEntryId: ctx.sessionManager.getLeafId() ?? undefined, messageCount: messages.length, at: Date.now(), submission, acceptance: ledger, resolvedOutput, nextPrompt };
-        fs.appendFileSync(path.join(path.dirname(reportRuntime.schemaPath), "boundaries.jsonl"), `${JSON.stringify(marker)}\n`, { mode: 0o600 });
-        if (!nextPrompt)
+        const submission = this.submission();
+        const ledger = await evaluateAcceptance({
+            acceptance: acceptanceSelfReviewConfig(this.config.acceptance),
+            governing: this.config.acceptance,
+            cwd: ctx.cwd,
+            output: nonempty(submission.reportSubmissionError) ? "" : submission.output,
+            report: nonempty(submission.reportSubmissionError) ? undefined : submission.report,
+        });
+        this.initialLedger ??= ledger;
+        const saveError = this.saveOutput(submission);
+        submission.error ??= saveError;
+        const nextPrompt = this.nextPrompt(submission, ledger);
+        const marker = {
+            type: FINALIZATION_EVENT,
+            nonce: this.config.nonce,
+            turn: this.turn,
+            lastEntryId: ctx.sessionManager.getLeafId() ?? undefined,
+            messageCount: this.messages.length,
+            at: Date.now(),
+            submission,
+            acceptance: ledger,
+            resolvedOutput: this.resolvedOutput,
+            nextPrompt,
+        };
+        fs.appendFileSync(path.join(path.dirname(this.config.reportRuntime.schemaPath), "boundaries.jsonl"), `${JSON.stringify(marker)}\n`, { mode: 0o600 });
+        if (!nonempty(nextPrompt)) {
             return;
-        if (turn === 0) {
-            // Native registration refreshes the active schema after the public payload is captured.
-            registerOutput(reportRuntime);
+        }
+        if (this.turn === 0) {
+            registerChildStructuredTool(pi, this.config.reportRuntime);
             pi.setActiveTools([...new Set([...pi.getActiveTools(), "structured_output"])]);
         }
-        turn++;
-        messageOffset = messages.length;
-        return { entries: [...event.entries, { type: "custom_message", customType: "subagent-self-review", content: nextPrompt, display: false }], continue: true };
-    });
+        this.turn++;
+        this.messageOffset = this.messages.length;
+        return {
+            entries: [
+                ...event.entries,
+                {
+                    type: "custom_message",
+                    customType: "subagent-self-review",
+                    content: nextPrompt,
+                    display: false,
+                },
+            ],
+            continue: true,
+        };
+    }
+}
+export default function registerNativeFinalization(pi) {
+    const configPath = process.env[CONFIG_ENV];
+    if (!nonempty(configPath)) {
+        return;
+    }
+    const value = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const config = parseNativeFinalizationConfig(value);
+    const review = new NativeReview(config);
+    if (config.publicOutput) {
+        registerChildStructuredTool(pi, config.publicOutput);
+        pi.on("before_agent_start", (event) => {
+            setPromptSection(event.systemPromptOptions, "subagent_output", "Your final action must call structured_output with JSON matching the current schema. Prose alone does not complete this output contract.");
+        });
+    }
+    pi.on("message_end", (event) => review.observe(event.message));
+    pi.on("agent_before_settle", (event, ctx) => review.settle(event, ctx, pi));
 }