@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/extension/schema-overrides.js

@@ -1,75 +0,0 @@
-import { Type } from "../shared/native-typebox.js";
-import { AcceptanceOverride } from "./acceptance-schema.js";
-export const requiredObject = (...required) => ({ type: "object", required });
-export const SkillOverride = Type.Unsafe({
-    anyOf: [
-        { type: "array", items: { type: "string", minLength: 1 } },
-        { type: "boolean" },
-        { type: "string" },
-    ],
-    description: "Skill name(s): string, comma-separated string, array, or false to disable",
-});
-export const OutputOverride = Type.Unsafe({
-    anyOf: [{ type: "string", minLength: 1 }, { type: "boolean" }],
-    description: "Output file path, or false to disable file output.",
-});
-export const OutputModeOverride = Type.Enum(["inline", "file-only"], {
-    type: "string",
-    description: "inline (default) or file-only; file-only requires output to be a path.",
-});
-export const ReadsOverride = Type.Unsafe({
-    anyOf: [{ type: "array", items: { type: "string", minLength: 1 } }, { type: "boolean" }],
-    description: "Files to read before running, or false to disable",
-});
-export const JsonSchemaObject = Type.Unsafe({
-    type: "object",
-    additionalProperties: true,
-    description: "JSON Schema (object root) for strict structured output.",
-});
-export const ModelOverride = Type.Optional(Type.String({
-    description: 'Profiles are defaults; warranted overrides are allowed subject to user instructions and provider authorization. Use model: "provider/model:high" to pin route/effort (no profile fallbacks; same-choice transport retries remain). Omit for profile fallbacks. No standalone thinking argument.',
-}));
-export const TaskItem = Type.Object({
-    agent: Type.String({ minLength: 1 }),
-    task: Type.String({ minLength: 1 }),
-    label: Type.Optional(Type.String({
-        minLength: 1,
-        description: "Short task label for the Agents strip and conversation.",
-    })),
-    cwd: Type.Optional(Type.String()),
-    count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times." })),
-    outputSchema: Type.Optional(JsonSchemaObject),
-    output: Type.Optional(OutputOverride),
-    outputMode: Type.Optional(OutputModeOverride),
-    reads: Type.Optional(ReadsOverride),
-    progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
-    model: ModelOverride,
-    skill: Type.Optional(SkillOverride),
-    acceptance: Type.Optional(AcceptanceOverride),
-}, { additionalProperties: false });
-export const HistoryQueryFields = {
-    cursor: Type.Optional(Type.String({
-        minLength: 1,
-        description: "Opaque page cursor returned by list/history/search; expires when the indexed snapshot changes.",
-    })),
-    sort: Type.Optional(Type.Enum(["attention", "newest", "oldest", "relevance"], {
-        type: "string",
-        description: "List: attention (default), newest, oldest. Search: relevance (default), newest.",
-    })),
-    state: Type.Optional(Type.Enum(["live", "completed", "failed", "blocked", "paused", "unknown"], {
-        type: "string",
-        description: "List only: execution-state filter, applied before paging.",
-    })),
-    text: Type.Optional(Type.String({
-        minLength: 1,
-        description: "List only: filter saved task/assignment text before paging.",
-    })),
-    query: Type.Optional(Type.String({
-        minLength: 1,
-        description: "Search visible saved text using 1–12 lexical words (all must match) or one double-quoted phrase. Operators, punctuation and prefixes are rejected. Thinking, images, tool arguments and hidden data are excluded.",
-    })),
-    before: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "History only: exclusive native-entry position returned by the earlier page; omit for the latest page.",
-    })),
-};

package/dist/extension/schemas.js

@@ -1,345 +0,0 @@
-/**
- * TypeBox schemas for subagent tool parameters
- */
-import { Type } from "../shared/native-typebox.js";
-import { SUBAGENT_ACTIONS } from "../shared/types.js";
-import { AcceptanceOverride } from "./acceptance-schema.js";
-import { ChainItemSchema } from "./chain-schema.js";
-import { AgentRunsValidationParams } from "./everyday-schemas.js";
-import { HistoryQueryFields, JsonSchemaObject, ModelOverride, OutputModeOverride, SkillOverride, TaskItem, requiredObject, } from "./schema-overrides.js";
-export { AcceptanceOverride, DelegateAcceptance } from "./acceptance-schema.js";
-export { ChainItemSchema } from "./chain-schema.js";
-export { DelegateParams, AgentRunsValidationParams, AgentRunsParams } from "./everyday-schemas.js";
-const MaxOutputOverride = Type.Object({
-    bytes: Type.Optional(Type.Integer({ minimum: 1, description: "Max output bytes before truncation." })),
-    lines: Type.Optional(Type.Integer({ minimum: 1, description: "Max output lines before truncation." })),
-}, {
-    additionalProperties: false,
-    description: "Final output truncation limits. Defaults: 200KB, 5000 lines.",
-});
-const ControlOverrides = Type.Object({
-    enabled: Type.Optional(Type.Boolean({
-        description: "Enable/disable subagent control attention tracking for this run",
-    })),
-    needsAttentionAfterMs: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "No-activity window (ms) before a run needs attention. Default 600000 (10 min).",
-    })),
-    failedToolAttemptsBeforeAttention: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "Consecutive mutating-tool failures before needs_attention (default: 3)",
-    })),
-    notifyOn: Type.Optional(Type.Array(Type.Enum(["needs_attention"], { type: "string" }), {
-        description: "Control event types that should notify the parent/orchestrator. Defaults to needs_attention.",
-    })),
-    notifyChannels: Type.Optional(Type.Array(Type.Enum(["event", "async", "intercom"], { type: "string" }), {
-        description: "Notification channels to use when available. Defaults to event, async, and intercom.",
-    })),
-}, { additionalProperties: false });
-export const SubagentParams = Type.Object({
-    agent: Type.Optional(Type.String({
-        minLength: 1,
-        description: "Agent name; on resume/answer, adopt the current profile including model, thinking and fallbacks; a separate model override wins. Otherwise keep saved settings.",
-    })),
-    task: Type.Optional(Type.String({
-        minLength: 1,
-        description: "Task (SINGLE mode, optional for self-contained agents)",
-    })),
-    label: TaskItem.properties.label,
-    // Management action (when present, tool operates in management mode)
-    action: Type.Optional(Type.Enum([...SUBAGENT_ACTIONS], {
-        type: "string",
-        description: "Management/control action. Omit for execution mode. nudge sends a live intercom nudge to a running child.",
-    })),
-    id: Type.Optional(Type.String({
-        description: "Run id or prefix for status/interrupt/extend/resume/nudge/questions/answer/review actions.",
-    })),
-    runId: Type.Optional(Type.String({
-        description: "Target run ID; prefer id. Defaults to the most recently active controllable run for interrupt/extend/nudge.",
-    })),
-    questionId: AgentRunsValidationParams.properties.questionId,
-    decision: Type.Optional(Type.Enum(["accepted", "needs_changes"], {
-        type: "string",
-        description: "Parent-only review decision; not sent to the child. Put actionable instructions in resume/nudge. Does not launch work or change runtime acceptance.",
-    })),
-    offset: Type.Optional(Type.Integer({ minimum: 0, description: "Status list/questions offset." })),
-    limit: AgentRunsValidationParams.properties.limit,
-    ...HistoryQueryFields,
-    full: Type.Optional(Type.Boolean({
-        description: "Exact status only: include the full task and saved launch configuration; default is concise.",
-    })),
-    dir: Type.Optional(Type.String({
-        description: "Async run directory for status/resume.",
-    })),
-    index: Type.Optional(Type.Integer({
-        minimum: 0,
-        description: "Zero-based child index for actions that target a specific child.",
-    })),
-    message: Type.Optional(Type.String({
-        description: "Follow-up for resume, nudge text, answer, or parent-only review note. Review notes are not sent to the child; put actionable instructions in resume/nudge. Use index for multi-child runs.",
-    })),
-    extendMs: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "Additional ms for extend; defaults to timeoutMs/maxRuntimeMs.",
-    })),
-    // Chain identifier for management (can't reuse 'chain' — that's the execution array)
-    chainName: Type.Optional(Type.String({
-        description: "Chain name for get/update/delete management actions",
-    })),
-    // Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
-    config: Type.Optional(Type.Unsafe({
-        anyOf: [{ type: "object", additionalProperties: true }, { type: "string" }],
-        description: "Agent or chain config for create/update (object or JSON string). Agent keys: name, package, description, scope ('user'|'project'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext, model, tools, allowSubagents, extensions, skills, thinking, output, reads, progress, maxSubagentDepth, maxExecutionTimeMs, maxTokens. Chain keys: name, package, description, scope, steps (array of {agent, task?, output?, outputMode?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain.",
-    })),
-    tasks: Type.Optional(Type.Array(TaskItem, {
-        minItems: 1,
-        description: "PARALLEL mode: concurrent [{agent, task, ...}] tasks.",
-    })),
-    concurrency: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "PARALLEL mode: max concurrent parallel tasks (default 4).",
-    })),
-    timeoutMs: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "Foreground wall-clock timeout (ms); on expiry children are soft-interrupted. When async is omitted, a timeout implies foreground execution; explicit async runs reject it. Short reviewer budgets are raised to a floor; planner/researcher budgets only from run-history data.",
-    })),
-    maxRuntimeMs: Type.Optional(Type.Integer({
-        minimum: 1,
-        description: "Alias for timeoutMs; same foreground-only policy.",
-    })),
-    maxOutput: Type.Optional(MaxOutputOverride),
-    worktree: Type.Optional(Type.Boolean({
-        description: "Isolated git worktrees per parallel task; requires clean git state; per-worktree diffs included.",
-    })),
-    chain: Type.Optional(Type.Array(ChainItemSchema, {
-        minItems: 1,
-        description: "CHAIN mode: sequential pipeline; each step's response becomes {previous} for the next.",
-    })),
-    context: Type.Optional(Type.Enum(["fresh", "fork"], {
-        type: "string",
-        description: "'fresh' or 'fork' (branch from parent session); overrides each agent's defaultContext. Fork is rejected for agents whose effective model uses the anthropic/ provider.",
-    })),
-    chainDir: Type.Optional(Type.String({
-        description: "Directory for chain artifacts (default: temp, auto-cleaned after 24h)",
-    })),
-    async: Type.Optional(Type.Boolean({
-        description: "Run in background. Stock top-level default: true; set false for foreground execution.",
-    })),
-    agentScope: Type.Optional(Type.Enum(["user", "project", "both"], {
-        type: "string",
-        description: "Agent discovery scope: 'user', 'project', or 'both' (default; project wins collisions)",
-    })),
-    cwd: Type.Optional(Type.String()),
-    artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
-    includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
-    progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for a single agent run" })),
-    share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
-    sessionDir: Type.Optional(Type.String({ description: "Directory for session logs (default: temp)" })),
-    // Clarification TUI
-    clarify: Type.Optional(Type.Boolean({
-        description: "Show TUI to preview/edit before execution; explicit true forces foreground.",
-    })),
-    control: Type.Optional(ControlOverrides),
-    // Solo agent overrides
-    output: Type.Optional(Type.Unsafe({
-        anyOf: [{ type: "string" }, { type: "boolean" }],
-        description: "Output file for single agent, or false to disable. Relative paths resolve against cwd.",
-    })),
-    outputMode: Type.Optional(OutputModeOverride),
-    skill: Type.Optional(SkillOverride),
-    model: ModelOverride,
-    outputSchema: Type.Optional(JsonSchemaObject),
-    acceptance: Type.Optional(AcceptanceOverride),
-}, {
-    additionalProperties: false,
-    allOf: [
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["answer"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                allOf: [
-                    requiredObject("questionId", "message"),
-                    { anyOf: [requiredObject("id"), requiredObject("runId")] },
-                ],
-            },
-        },
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["review"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                allOf: [
-                    requiredObject("decision"),
-                    { anyOf: [requiredObject("id"), requiredObject("runId")] },
-                ],
-            },
-        },
-        {
-            not: {
-                anyOf: [
-                    requiredObject("agent", "tasks"),
-                    requiredObject("agent", "chain"),
-                    requiredObject("tasks", "chain"),
-                    requiredObject("cursor", "offset"),
-                    requiredObject("cursor", "before"),
-                ],
-            },
-        },
-        {
-            if: requiredObject("decision"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { ...requiredObject("action"), properties: { action: { enum: ["review"] } } },
-        },
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["history"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { anyOf: [requiredObject("id"), requiredObject("runId")] },
-        },
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["search"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: requiredObject("query"),
-        },
-        {
-            if: requiredObject("offset"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                ...requiredObject("action"),
-                properties: { action: { enum: ["status", "questions"] } },
-            },
-        },
-        {
-            if: requiredObject("limit"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                ...requiredObject("action"),
-                properties: { action: { enum: ["status", "questions", "history", "search"] } },
-            },
-        },
-        {
-            if: requiredObject("cursor"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                ...requiredObject("action"),
-                properties: { action: { enum: ["status", "history", "search"] } },
-            },
-        },
-        {
-            if: requiredObject("sort"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                ...requiredObject("action"),
-                properties: { action: { enum: ["status", "search"] } },
-            },
-        },
-        {
-            if: {
-                allOf: [
-                    { ...requiredObject("action"), properties: { action: { enum: ["search"] } } },
-                    requiredObject("index"),
-                ],
-            },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { anyOf: [requiredObject("id"), requiredObject("runId")] },
-        },
-        {
-            if: { anyOf: [requiredObject("state"), requiredObject("text")] },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { ...requiredObject("action"), properties: { action: { enum: ["status"] } } },
-        },
-        {
-            if: requiredObject("query"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { ...requiredObject("action"), properties: { action: { enum: ["search"] } } },
-        },
-        {
-            if: requiredObject("before"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { ...requiredObject("action"), properties: { action: { enum: ["history"] } } },
-        },
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["status"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { properties: { sort: { enum: ["attention", "newest", "oldest"] } } },
-        },
-        {
-            if: { ...requiredObject("action"), properties: { action: { enum: ["search"] } } },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: { properties: { sort: { enum: ["relevance", "newest"] } } },
-        },
-        {
-            if: requiredObject("full"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                allOf: [
-                    { ...requiredObject("action"), properties: { action: { enum: ["status"] } } },
-                    { anyOf: [requiredObject("id"), requiredObject("runId"), requiredObject("dir")] },
-                ],
-            },
-        },
-        {
-            if: requiredObject("worktree"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: requiredObject("tasks"),
-        },
-        {
-            if: requiredObject("concurrency"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: requiredObject("tasks"),
-        },
-        {
-            if: requiredObject("chainDir"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: requiredObject("chain"),
-        },
-        {
-            if: {
-                anyOf: [
-                    requiredObject("output"),
-                    requiredObject("outputMode"),
-                    requiredObject("skill"),
-                    requiredObject("model"),
-                    requiredObject("outputSchema"),
-                    requiredObject("progress"),
-                ],
-            },
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                anyOf: [
-                    requiredObject("agent"),
-                    { ...requiredObject("action"), properties: { action: { enum: ["resume", "answer"] } } },
-                ],
-            },
-        },
-        {
-            if: requiredObject("acceptance"),
-            // JSON Schema's non-callable consequence keyword is not a Promise method.
-            // oxlint-disable-next-line unicorn/no-thenable
-            then: {
-                anyOf: [
-                    requiredObject("agent"),
-                    { ...requiredObject("action"), properties: { action: { enum: ["resume", "answer"] } } },
-                ],
-            },
-        },
-    ],
-});

package/dist/extension/tool-input.js

@@ -1,35 +0,0 @@
-import { Compile } from "../shared/native-typebox.js";
-import { isRecord } from "../shared/unknown.js";
-import { AgentRunsValidationParams } from "./schemas.js";
-const runArguments = Compile(AgentRunsValidationParams);
-function normalizeVerificationEnvironment(verify) {
-    if (!isRecord(verify) || !Array.isArray(verify.env)) {
-        return verify;
-    }
-    const entries = verify.env.map((entry) => {
-        if (!isRecord(entry) || typeof entry.name !== "string" || typeof entry.value !== "string") {
-            throw new Error("Verification environment entries require string names and values.");
-        }
-        return [entry.name, entry.value];
-    });
-    if (new Set(entries.map(([name]) => name)).size !== entries.length) {
-        throw new Error("Verification environment contains duplicate names.");
-    }
-    return { ...verify, env: Object.fromEntries(entries) };
-}
-export function normalizeEverydayParams(params, control = false) {
-    const acceptance = params.acceptance;
-    const normalized = isRecord(acceptance) && Array.isArray(acceptance.verify)
-        ? {
-            ...params,
-            acceptance: {
-                ...acceptance,
-                verify: acceptance.verify.map((verify) => normalizeVerificationEnvironment(verify)),
-            },
-        }
-        : params;
-    if (control && !runArguments.Check(normalized)) {
-        throw new Error(`Invalid agent_runs arguments: ${[...runArguments.Errors(normalized)].map((error) => error.message).join("; ")}`);
-    }
-    return normalized;
-}

package/dist/extension/tool-result.js

@@ -1,29 +0,0 @@
-import { isRecord } from "../shared/unknown.js";
-import { copyExecutionResult } from "./result-snapshot.js";
-import { finalizedChildUsage } from "../runs/shared/parent-usage.js";
-/** Only completed, directly owned waits carry accounting intent to the native result boundary. */
-export function adaptFinalizedToolResult(result, ctx, parentUsage, adapt) {
-    const attached = result.details.wait?.status === "completed" &&
-        result.details.run?.ownerSessionId === ctx.sessionManager.getSessionId()
-        ? parentUsage.attach(result, finalizedChildUsage(result.details.run.children, result.details.wait.index), ctx)
-        : result;
-    return adapt(attached);
-}
-export function registerToolResultAdapter(pi, toolNames) {
-    pi.on("tool_result", (event) => {
-        const details = event.details;
-        if (!toolNames.includes(event.toolName) || !isRecord(details) || details.isError !== true) {
-            return;
-        }
-        const { isError, ...originalDetails } = details;
-        return { isError, details: originalDetails };
-    });
-    // Native execute ignores returned isError; throwing discards content/details.
-    // Carry the flag to its native result hook, which restores the original details.
-    return (result) => {
-        const snapshot = copyExecutionResult(result);
-        return result.isError === true
-            ? { ...snapshot, details: { ...snapshot.details, isError: true } }
-            : snapshot;
-    };
-}

package/dist/history/answer-texts.js

@@ -1,57 +0,0 @@
-import { stripTerminalSequences } from "../shared/native-tui.js";
-import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
-import { exactTextDigest } from "./store.js";
-import { object, objects, string } from "./values.js";
-/** Exact matches never use previews. Oversized selected text has no fingerprint. */
-export class AnswerTexts {
-    fields = new Map();
-    length = 0;
-    unavailable = false;
-    write(keys, text) {
-        if (this.unavailable ||
-            keys.length !== 4 ||
-            keys[0] !== "message" ||
-            keys[1] !== "content" ||
-            !["text", "thinking"].includes(String(keys[3]))) {
-            return;
-        }
-        this.length += text.length;
-        if (this.length > 16 * 1024 * 1024 || Number(keys[2]) >= 4096) {
-            this.unavailable = true;
-            this.fields.clear();
-            return;
-        }
-        const index = Number(keys[2]);
-        this.fields.set(index, (this.fields.get(index) ?? "") + text);
-    }
-    partText(part, index) {
-        if (part.type === "text" || part.type === "thinking") {
-            return stripTerminalSequences(this.fields.get(index) ?? "");
-        }
-        return part.type === "image" ? `[Image: ${string(part.mimeType) ?? "image"}]` : "";
-    }
-    fingerprints(value, id) {
-        const message = object(value.message);
-        if (this.unavailable || value.type !== "message" || message.role !== "assistant") {
-            return [];
-        }
-        const content = objects(message.content);
-        const first = content.findIndex((part, index) => (part.type === "text" || part.type === "thinking") &&
-            (this.fields.get(index)?.length ?? 0) > 0);
-        if (first < 0 ||
-            !content.some((part, index) => part.type === "text" && (this.fields.get(index)?.length ?? 0) > 0)) {
-            return [];
-        }
-        const item = `${id}:${first}`;
-        const parts = content
-            .map((part, index) => this.partText(part, index))
-            .filter((text) => text.length > 0);
-        const texts = [
-            parts.join("\n"),
-            ...content.flatMap((part, index) => part.type === "text" ? [stripTerminalSequences(this.fields.get(index) ?? "")] : []),
-        ];
-        return [
-            ...new Set(texts.map((text) => stripAcceptanceReport(text).trim()).filter((text) => text.length > 0)),
-        ].map((text) => [exactTextDigest(text), item]);
-    }
-}

package/dist/history/canonical-result.js

@@ -1,114 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { JsonProjection, readJsonProjection } from "../shared/journal-reader.js";
-import { HistoryIndexError } from "./types.js";
-import { at, object, objects } from "./values.js";
-const budget = 16 * 1024 * 1024;
-function unchanged(file, fd, before) {
-    const after = fs.fstatSync(fd, { bigint: true });
-    const current = fs.statSync(file, { bigint: true });
-    if (before.size !== after.size ||
-        before.ctimeNs !== after.ctimeNs ||
-        before.dev !== current.dev ||
-        before.ino !== current.ino) {
-        throw new HistoryIndexError("SOURCE_CHANGED", "Selected output changed; retry details.");
-    }
-}
-export function readSavedOutput(file) {
-    const fd = fs.openSync(file, "r");
-    try {
-        const before = fs.fstatSync(fd, { bigint: true });
-        if (!before.isFile() || before.size > BigInt(budget)) {
-            throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected saved output exceeds the 16 MiB detail budget.");
-        }
-        const bytes = Buffer.alloc(Number(before.size));
-        for (let offset = 0; offset < bytes.length;) {
-            const count = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
-            if (count === 0) {
-                throw new HistoryIndexError("SOURCE_CHANGED", "Selected saved output was truncated.");
-            }
-            offset += count;
-        }
-        unchanged(file, fd, before);
-        return new TextDecoder("utf8", { fatal: true }).decode(bytes);
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function childPrefix(file, index) {
-    if (path.basename(file) !== "foreground.json") {
-        return path.basename(file) === "result.json" ? ["results", index] : ["result"];
-    }
-    const metadata = readJsonProjection(file, (keys) => keys.length === 0 ||
-        (keys[0] === "children" && (keys.length <= 2 || (keys.length === 3 && keys[2] === "index"))));
-    const position = objects(object(metadata).children).findIndex((child) => child.index === index);
-    return position < 0 ? undefined : ["children", position, "result"];
-}
-function isOutput(keys, prefix) {
-    return (keys.length === prefix.length + 1 &&
-        prefix.every((key, position) => key === keys[position]) &&
-        ["finalOutput", "output"].includes(String(keys.at(-1))));
-}
-function outputProjection(prefix) {
-    let length = 0;
-    return new JsonProjection((keys) => {
-        if (prefix[0] === "children" &&
-            keys.length === 3 &&
-            keys[0] === "children" &&
-            keys[1] === prefix[1] &&
-            keys[2] === "index") {
-            return true;
-        }
-        if (keys.length <= prefix.length) {
-            return keys.every((key, position) => key === prefix[position]);
-        }
-        return isOutput(keys, prefix) ? budget : false;
-    }, (keys, text) => {
-        if (isOutput(keys, prefix)) {
-            length += Buffer.byteLength(text);
-            if (length > budget) {
-                throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected canonical output exceeds the 16 MiB detail budget.");
-            }
-        }
-    });
-}
-function readProjection(fd, size, projection) {
-    const decoder = new TextDecoder("utf8", { fatal: true });
-    const bytes = Buffer.allocUnsafe(64 * 1024);
-    for (let offset = 0; offset < size;) {
-        const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, size - offset), offset);
-        if (count === 0) {
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical output was truncated.");
-        }
-        projection.write(decoder.decode(bytes.subarray(0, count), { stream: true }));
-        offset += count;
-    }
-    projection.write(decoder.decode());
-    return projection.finish();
-}
-/** Explicit legacy/compact owner detail: retain only this child's output, never transcript arrays. */
-export function readCanonicalOutput(file, index) {
-    const prefix = childPrefix(file, index);
-    if (!prefix) {
-        return;
-    }
-    const projection = outputProjection(prefix);
-    const fd = fs.openSync(file, "r");
-    try {
-        const before = fs.fstatSync(fd, { bigint: true });
-        const value = readProjection(fd, Number(before.size), projection);
-        if (prefix[0] === "children" && at(value, ["children", Number(prefix[1]), "index"]) !== index) {
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical child changed; retry details.");
-        }
-        unchanged(file, fd, before);
-        const result = object(at(value, prefix));
-        if (typeof result.finalOutput === "string") {
-            return result.finalOutput;
-        }
-        return typeof result.output === "string" ? result.output : undefined;
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}