@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/shared/native-journal.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
-import { scanJournal } from "./journal-frames.js";
+import { JournalFrames } from "./journal-frames.js";
 import { nativeProjection } from "./journal-projections.js";
-import { isRecord, recordAt } from "./unknown.js";
+import { isRecord } from "./unknown.js";
 function preview(record, parent, legacy) {
     const entry = record.value;
     if (typeof entry.type !== "string") {
@@ -18,45 +18,40 @@ function preview(record, parent, legacy) {
     };
     return { value, start: record.start, end: record.end };
 }
-function configurationModel(value) {
-    const message = recordAt(value, "message");
-    const provider = value.type === "model_change" ? value.provider : message?.provider;
-    const model = value.type === "model_change" ? value.modelId : message?.model;
-    return typeof provider === "string" && typeof model === "string"
-        ? `${provider}/${model}`
-        : undefined;
-}
 export class NativeJournal {
     records = [];
     byId = new Map();
     stamp;
     end;
     file;
-    constructor(file, policy = "inspect", requireNewline = policy === "live") {
+    identity;
+    offset = 0;
+    frames;
+    constructor(file, policy = "inspect", requireNewline = policy === "live", options = {}) {
         this.file = file;
-        const fd = fs.openSync(file, "r");
+        let parent = null;
+        this.frames = new JournalFrames(options.select ?? nativeProjection, (raw) => {
+            const record = preview(raw, parent, this.records[0]?.value.version === 1);
+            if (!record) {
+                if (policy !== "inspect") {
+                    throw new SyntaxError(`Native record at byte ${raw.start} requires a type`);
+                }
+                return;
+            }
+            if (record.value.type !== "session") {
+                parent = record.value.id;
+            }
+            this.records.push(record);
+            this.byId.set(record.value.id, record);
+        }, { policy, requireNewline });
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | (policy === "live" ? fs.constants.O_NOFOLLOW : 0));
         try {
             const stat = fs.fstatSync(fd, { bigint: true });
             this.stamp = journalStamp(stat);
+            this.identity = `${stat.dev}:${stat.ino}`;
             this.end = Number(stat.size);
-            let parent = null;
-            scanJournal(fd, nativeProjection, (raw) => {
-                const record = preview(raw, parent, this.records[0]?.value.version === 1);
-                if (!record) {
-                    if (policy !== "inspect") {
-                        throw new SyntaxError(`Native record at byte ${raw.start} requires a type`);
-                    }
-                    return;
-                }
-                if (record.value.type !== "session") {
-                    parent = record.value.id;
-                }
-                this.records.push(record);
-                this.byId.set(record.value.id, record);
-            }, { policy, requireNewline, end: this.end });
-            if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== this.stamp) {
-                throw new Error("Journal changed while indexing; refresh history.");
-            }
+            this.index(fd, Math.min(this.end, options.readBytes ?? Infinity));
+            this.checkInitial(stat, fs.fstatSync(fd, { bigint: true }), policy);
         }
         finally {
             fs.closeSync(fd);
@@ -65,21 +60,101 @@ export class NativeJournal {
             throw new Error("Not a readable native Pi session.");
         }
     }
-    branch(leaf, endedAt) {
+    checkInitial(before, after, policy) {
+        if (journalStamp(after) !== this.stamp &&
+            (policy !== "live" ||
+                after.size < before.size ||
+                `${after.dev}:${after.ino}` !== this.identity)) {
+            throw new Error("Journal changed while indexing; refresh history.");
+        }
+    }
+    index(fd, end) {
+        const buffer = Buffer.allocUnsafe(65536);
+        while (this.offset < end) {
+            const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - this.offset), this.offset);
+            if (count === 0) {
+                throw new Error("Journal truncated while reading");
+            }
+            this.frames.write(buffer.subarray(0, count));
+            this.offset += count;
+        }
+        this.frames.finish();
+    }
+    get indexed() {
+        return this.offset === this.end;
+    }
+    /** Incremental, LF-published indexing. Append work is budgeted independently of paint. */
+    refresh(bytes = 256 * 1024) {
+        const fd = fs.openSync(this.file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const stat = fs.fstatSync(fd, { bigint: true });
+            if (`${stat.dev}:${stat.ino}` !== this.identity || Number(stat.size) < this.offset) {
+                throw new Error("Native journal was replaced or truncated; reopen this conversation.");
+            }
+            if (journalStamp(stat) === this.stamp && this.indexed) {
+                return false;
+            }
+            const previous = this.records.length;
+            this.end = Number(stat.size);
+            this.index(fd, Math.min(this.end, this.offset + bytes));
+            this.stamp = journalStamp(stat);
+            return previous !== this.records.length;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    /** Project one immutable, published record, including bounded slices of very large strings. */
+    async project(record, select, stringChunk, signal) {
+        const fd = fs.openSync(this.file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        let stream;
+        try {
+            const stat = fs.fstatSync(fd, { bigint: true });
+            if (`${stat.dev}:${stat.ino}` !== this.identity || Number(stat.size) < record.end) {
+                throw new Error("Native journal was replaced or truncated.");
+            }
+            let value;
+            const frames = new JournalFrames(select, (entry) => {
+                value = entry.value;
+            }, { policy: "live", start: record.start, stringChunk });
+            stream = fs.createReadStream(this.file, {
+                fd,
+                start: record.start,
+                end: record.end - 1,
+                highWaterMark: 65536,
+                signal,
+            });
+            for await (const chunk of stream) {
+                if (!Buffer.isBuffer(chunk)) {
+                    throw new TypeError("Native journal reads require bytes.");
+                }
+                frames.write(chunk);
+            }
+            frames.finish();
+            if (!value) {
+                throw new Error("Native entry is not published.");
+            }
+            return value;
+        }
+        finally {
+            if (stream) {
+                stream.destroy();
+            }
+            else {
+                fs.closeSync(fd);
+            }
+        }
+    }
+    branch(leaf) {
         if (leaf === null) {
             return [];
         }
-        const eligible = endedAt === undefined
-            ? this.records
-            : this.records.filter((record) => record.value.type === "session" ||
-                Date.parse(record.value.timestamp ?? "") <= endedAt);
         let current = leaf !== undefined && leaf !== ""
             ? this.byId.get(leaf)
-            : eligible.findLast((record) => record.value.type !== "session");
+            : this.records.findLast((record) => record.value.type !== "session");
         const path = [];
         const seen = new Set();
-        const allowed = new Set(eligible.map((record) => record.value.id));
-        while (current && current.value.type !== "session" && allowed.has(current.value.id)) {
+        while (current && current.value.type !== "session") {
             if (seen.has(current.value.id)) {
                 throw new Error("Cyclic journal ancestry");
             }
@@ -116,24 +191,16 @@ export class NativeJournal {
             fs.closeSync(fd);
         }
     }
-    configuration(endedAt, leaf) {
-        const result = {};
-        let model;
-        for (const { value } of this.branch(leaf, endedAt)) {
-            if (value.type === "thinking_level_change" && typeof value.thinkingLevel === "string") {
-                result.thinking = value.thinkingLevel;
-            }
-            if (value.type === "model_change" ||
-                (value.type === "message" && recordAt(value, "message")?.role === "assistant")) {
-                model = value;
-            }
-        }
-        if (model) {
-            result.model = configurationModel(model);
-            result.modelRecordedAt = Date.parse(model.timestamp ?? "");
-        }
-        return result;
-    }
+}
+/** Native v3 writers append after attachment; loading older formats can rewrite in place.
+ * Outside prefix edits followed by same-inode growth are not an append-only operation.
+ */
+export function nativeAppend(before, after, header) {
+    return (header?.type === "session" &&
+        header.version === 3 &&
+        before.dev === after.dev &&
+        before.ino === after.ino &&
+        after.size > before.size);
 }
 export function journalStamp(stat) {
     return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;

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

@@ -1,6 +1,27 @@
-import { execFileSync } from "node:child_process";
-import { readLinuxProcess } from "../pi-intercom/broker/pid.js";
+import { execFile, execFileSync } from "node:child_process";
+import { readFileSync, readlinkSync } from "node:fs";
+import { isLinuxProcessReplaced, readLinuxProcess } from "../pi-intercom/broker/pid.js";
 import { hasErrorCode } from "./unknown.js";
+const BIRTH_FIELDS = ["lstart=", "pgid="];
+/** Capture only a real, cross-process clock context; unavailable context proves nothing. */
+export function readProcessClock() {
+    if (process.platform !== "android") {
+        return undefined;
+    }
+    try {
+        const boot = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+        const namespace = readlinkSync("/proc/self/ns/time");
+        const at = process.hrtime.bigint();
+        return at > 0n &&
+            /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(boot) &&
+            /^time:\[\d+\]$/.test(namespace)
+            ? { boot, namespace, at: at.toString() }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Capture the detached group leader's birth identity; Pi may replace its command-line title. */
 export function readChildProcessIdentity(pid) {
     if (!Number.isSafeInteger(pid) || pid <= 0) {
@@ -9,21 +30,113 @@ export function readChildProcessIdentity(pid) {
     if (process.platform === "linux") {
         return readLinuxProcess(pid)?.identity;
     }
+    return groupLeader(pid, readPsFields(pid, BIRTH_FIELDS));
+}
+function groupLeader(pid, birth) {
+    return Number(birth?.split(" ").at(-1)) === pid ? birth : undefined;
+}
+// Always one PID: Darwin ps given several PIDs scans every process at many times the cost.
+function psArguments(pid, fields) {
+    return ["-p", String(pid), ...fields.flatMap((field) => ["-o", field])];
+}
+function psOptions(zone) {
+    const env = { ...process.env, LC_ALL: "C", ...(zone === undefined ? {} : { TZ: zone }) };
+    return { encoding: "utf8", timeout: 1000, env };
+}
+function readPsFields(pid, fields, zone) {
     try {
-        const identity = execFileSync("ps", ["-p", String(pid), "-o", "lstart=", "-o", "pgid="], {
-            encoding: "utf8",
-            timeout: 1000,
+        return execFileSync("ps", psArguments(pid, fields), {
+            ...psOptions(zone),
             stdio: ["ignore", "pipe", "ignore"],
-            env: { ...process.env, LC_ALL: "C" },
         })
             .trim()
             .replace(/\s+/g, " ");
-        return Number(identity.split(" ").at(-1)) === pid ? identity : undefined;
     }
     catch {
         return undefined;
     }
 }
+/** Nonblocking `readPsFields`; a failed run likewise observes nothing. */
+function observePsFields(pid, fields, zone) {
+    return new Promise((resolve) => {
+        execFile("ps", psArguments(pid, fields), psOptions(zone), (error, stdout) => {
+            resolve(error ? undefined : stdout.trim().replace(/\s+/g, " "));
+        });
+    });
+}
+// C-locale ps lstart (whole-second birth, in the reader's zone), then the process group.
+const PS_IDENTITY = /^[A-Z][a-z]{2} ([A-Z][a-z]{2}) (\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4}) \d+$/;
+const MONTHS = "JanFebMarAprMayJunJulAugSepOctNovDec";
+/** Parses a birth observed with TZ=UTC0. */
+function utcBirth(birth) {
+    const [, month = "", day, hours, minutes, seconds, year] = PS_IDENTITY.exec(birth ?? "") ?? [];
+    const index = MONTHS.indexOf(month);
+    // Unreadable or malformed observations yield NaN, which never proves a later birth.
+    return month.length === 3 && index % 3 === 0
+        ? Date.UTC(Number(year), index / 3, Number(day), Number(hours), Number(minutes), Number(seconds))
+        : Number.NaN;
+}
+function sameClock(left, right) {
+    return left.boot === right.boot && left.namespace === right.namespace;
+}
+/** Android's elapsed age bounds birth in the saved monotonic clock, never wall time. */
+function clockBound(clock) {
+    const before = readProcessClock();
+    return clock !== undefined && before !== undefined && sameClock(clock, before)
+        ? { clock, before }
+        : undefined;
+}
+/** `elapsed` is observed after the bound's `before` read; the closing clock read follows both. */
+function bornAfter({ clock, before }, elapsed = "") {
+    const after = readProcessClock();
+    if (after === undefined || !sameClock(before, after) || !/^\d+$/.test(elapsed)) {
+        return false;
+    }
+    // Include displayed-second and native tick uncertainty. BOOTTIME age includes suspend,
+    // unlike hrtime's MONOTONIC clock, so suspend only moves this lower bound earlier.
+    const birth = BigInt(before.at) - (BigInt(elapsed) + 2n) * 1000000000n;
+    return BigInt(after.at) >= BigInt(before.at) && birth > BigInt(clock.at);
+}
+/**
+ * True only when a live PID provably names a different process than an owner-published record.
+ * Darwin identities are unzoned local times, so they are never compared across zones; only a
+ * UTC-observed birth strictly after the record's publication proves replacement. Android uses
+ * a conservative elapsed-age bound against its recorded boot-qualified monotonic clock.
+ */
+export function isChildProcessReplaced(pid, recorded, published, clock) {
+    if (process.platform === "linux") {
+        return isLinuxProcessReplaced(pid, recorded);
+    }
+    if (!PS_IDENTITY.test(recorded)) {
+        return false;
+    }
+    if (process.platform === "android") {
+        const bound = clockBound(clock);
+        return bound !== undefined && bornAfter(bound, readPsFields(pid, ["etimes="]));
+    }
+    return published !== undefined && utcBirth(readPsFields(pid, BIRTH_FIELDS, "UTC0")) > published;
+}
+/**
+ * Nonblocking `readChildProcessIdentity(pid) !== recorded && isChildProcessReplaced(...)` for
+ * routine liveness. Signals still need the fresh synchronous proof.
+ */
+export async function observeChildProcessReplaced(pid, recorded, published, clock) {
+    if (process.platform === "linux") {
+        return readChildProcessIdentity(pid) !== recorded && isLinuxProcessReplaced(pid, recorded);
+    }
+    if (!PS_IDENTITY.test(recorded) ||
+        groupLeader(pid, await observePsFields(pid, BIRTH_FIELDS)) === recorded) {
+        return false;
+    }
+    if (process.platform === "android") {
+        const bound = clockBound(clock);
+        return bound !== undefined && bornAfter(bound, await observePsFields(pid, ["etimes="]));
+    }
+    if (published === undefined) {
+        return false;
+    }
+    return utcBirth(await observePsFields(pid, BIRTH_FIELDS, "UTC0")) > published;
+}
 function trySignalChild(child, signal) {
     try {
         return child.kill(signal);

package/dist/shared/tui-action.js

@@ -0,0 +1,29 @@
+import { MouseRegion, TruncatedText, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+export function actionText(text, action) {
+    const component = new TruncatedText(text, 0, 0);
+    return new MouseRegion(component, (event) => {
+        if ((event.type !== "press" && event.type !== "click") ||
+            event.button !== "left" ||
+            event.x >= visibleWidth(truncateToWidth(text, event.width))) {
+            return;
+        }
+        if (event.type === "click") {
+            action(event.x);
+        }
+        return { handled: true, render: event.type === "click" };
+    });
+}
+/** Each visible hint dispatches the same action as its corresponding keyboard binding. */
+export function actionHints(hints) {
+    return actionText(hints.map((hint) => hint.text).join(" · "), (column) => {
+        let start = 0;
+        for (const hint of hints) {
+            const end = start + visibleWidth(hint.text);
+            if (column >= start && column < end) {
+                hint.action();
+                return;
+            }
+            start = end + 3;
+        }
+    });
+}

package/dist/shared/types.js

@@ -1,26 +1,5 @@
-/** Public compatibility barrel. Domain contracts depend on each other, never on implementation modules. */
 import * as os from "node:os";
 import * as path from "node:path";
-export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
-export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
-export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
-export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
-export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
-export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
-export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
-export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
-export const SUBAGENT_LIVE_INTERCOM_EVENT = "subagent:live-intercom";
-export const SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT = "subagent:live-intercom-delivery";
-export const SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT = "subagent:intercom-health-request";
-export const SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT = "subagent:intercom-health-response";
-export const SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT = "subagent:intercom-identity-request";
-export const SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT = "subagent:intercom-identity-response";
-// Constants
-// ============================================================================
-export const DEFAULT_MAX_OUTPUT = {
-    bytes: 200 * 1024,
-    lines: 5000,
-};
 function sanitizeTempScopeSegment(value) {
     const sanitized = value
         .trim()
@@ -65,8 +44,6 @@ function resolveHomeTempScopeId() {
     }
     return "shared";
 }
-const MAX_PARALLEL = 8;
-export const MAX_CONCURRENCY = 4;
 export function resolveTempRootDir(configured = process.env.PI_SUBAGENT_TEMP_ROOT) {
     const fallback = path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`);
     if (configured === undefined || configured.trim().length === 0) {
@@ -78,175 +55,3 @@ export function resolveTempRootDir(configured = process.env.PI_SUBAGENT_TEMP_ROO
     }
     return resolved;
 }
-export const TEMP_ROOT_DIR = resolveTempRootDir();
-export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
-export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
-export const RUNNER_ERROR_LOG_FILE = "runner-error.log";
-export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
-export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
-export const WIDGET_KEY = "subagent-async";
-export const SLASH_RESULT_TYPE = "subagent-slash-result";
-export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
-export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
-export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
-export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
-export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
-export const POLL_INTERVAL_MS = 1000;
-export const MAX_WIDGET_JOBS = 4;
-export const DEFAULT_SUBAGENT_MAX_DEPTH = 1;
-export const SUBAGENT_ACTIONS = [
-    "list",
-    "get",
-    "create",
-    "update",
-    "delete",
-    "status",
-    "history",
-    "search",
-    "interrupt",
-    "extend",
-    "resume",
-    "nudge",
-    "questions",
-    "answer",
-    "review",
-    "doctor",
-];
-export const DEFAULT_FORK_PREAMBLE = "You are a delegated subagent running from a fork of the parent session. " +
-    "Treat the inherited conversation as reference-only context, not a live thread to continue. " +
-    "Do not continue or answer prior messages as if they are waiting for a reply. " +
-    "Your sole job is to execute the task below and return a focused result for that task using your tools.";
-function normalizeTopLevelParallelValue(value) {
-    let parsed = NaN;
-    if (typeof value === "number") {
-        parsed = value;
-    }
-    else if (typeof value === "string") {
-        parsed = Number(value);
-    }
-    if (!Number.isInteger(parsed) || parsed < 1) {
-        return undefined;
-    }
-    return parsed;
-}
-export function resolveTopLevelParallelMaxTasks(value) {
-    return normalizeTopLevelParallelValue(value) ?? MAX_PARALLEL;
-}
-export function resolveTopLevelParallelConcurrency(override, configValue) {
-    return (normalizeTopLevelParallelValue(override) ??
-        normalizeTopLevelParallelValue(configValue) ??
-        MAX_CONCURRENCY);
-}
-export function getAsyncConfigPath(suffix) {
-    return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
-}
-export function wrapForkTask(task, preamble) {
-    if (preamble === false) {
-        return task;
-    }
-    const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;
-    const wrappedPrefix = `${effectivePreamble}\n\nTask:\n`;
-    if (task.startsWith(wrappedPrefix)) {
-        return task;
-    }
-    return `${wrappedPrefix}${task}`;
-}
-// ============================================================================
-// Recursion Depth Guard
-// ============================================================================
-export function normalizeMaxSubagentDepth(value) {
-    let parsed = NaN;
-    if (typeof value === "number") {
-        parsed = value;
-    }
-    else if (typeof value === "string") {
-        parsed = Number(value);
-    }
-    if (!Number.isInteger(parsed) || parsed < 0) {
-        return undefined;
-    }
-    return parsed;
-}
-export function resolveCurrentMaxSubagentDepth(configMaxDepth) {
-    return (normalizeMaxSubagentDepth(process.env.PI_SUBAGENT_MAX_DEPTH) ??
-        normalizeMaxSubagentDepth(configMaxDepth) ??
-        DEFAULT_SUBAGENT_MAX_DEPTH);
-}
-export function resolveChildMaxSubagentDepth(parentMaxDepth, agentMaxDepth) {
-    const normalizedParent = normalizeMaxSubagentDepth(parentMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
-    const normalizedAgent = normalizeMaxSubagentDepth(agentMaxDepth);
-    return normalizedAgent === undefined
-        ? normalizedParent
-        : Math.min(normalizedParent, normalizedAgent);
-}
-function parseSubagentDepth(value) {
-    if (value === undefined || value === null || value === "") {
-        return 0;
-    }
-    const depth = Number(value);
-    return Number.isInteger(depth) && depth >= 0 ? depth : undefined;
-}
-export function checkSubagentDepth(configMaxDepth) {
-    const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
-    const depth = parseSubagentDepth(process.env.PI_SUBAGENT_DEPTH);
-    if (depth === undefined) {
-        return { blocked: true, depth: maxDepth, maxDepth };
-    }
-    return { blocked: depth >= maxDepth, depth, maxDepth };
-}
-export function getSubagentDepthEnv(maxDepth) {
-    const childMaxDepth = normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth();
-    const parentDepth = parseSubagentDepth(process.env.PI_SUBAGENT_DEPTH);
-    const nextDepth = parentDepth === undefined ? childMaxDepth : parentDepth + 1;
-    return {
-        PI_SUBAGENT_DEPTH: String(nextDepth),
-        PI_SUBAGENT_MAX_DEPTH: String(childMaxDepth),
-    };
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-function formatBytes(bytes) {
-    if (bytes < 1024) {
-        return `${bytes}B`;
-    }
-    if (bytes < 1024 * 1024) {
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    }
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-export function truncateOutput(output, config, artifactPath) {
-    const lines = output.split("\n");
-    const bytes = Buffer.byteLength(output, "utf-8");
-    if (bytes <= config.bytes && lines.length <= config.lines) {
-        return { text: output, truncated: false };
-    }
-    let truncatedLines = lines;
-    if (lines.length > config.lines) {
-        truncatedLines = lines.slice(0, config.lines);
-    }
-    let result = truncatedLines.join("\n");
-    if (Buffer.byteLength(result, "utf-8") > config.bytes) {
-        let low = 0;
-        let high = result.length;
-        while (low < high) {
-            const mid = Math.floor((low + high + 1) / 2);
-            if (Buffer.byteLength(result.slice(0, mid), "utf-8") <= config.bytes) {
-                low = mid;
-            }
-            else {
-                high = mid - 1;
-            }
-        }
-        result = result.slice(0, low);
-    }
-    const keptLines = result.split("\n").length;
-    const marker = `[TRUNCATED: showing first ${keptLines} of ${lines.length} lines, ${formatBytes(Buffer.byteLength(result))} of ${formatBytes(bytes)}${artifactPath !== undefined && artifactPath.length > 0 ? ` - full output at ${artifactPath}` : ""}]\n`;
-    return {
-        text: marker + result,
-        truncated: true,
-        originalBytes: bytes,
-        originalLines: lines.length,
-        artifactPath,
-    };
-}

package/dist/shared/unknown.d.ts

@@ -0,0 +1,9 @@
+/** JSON and caught failures cross the process/filesystem boundary as unknown values. */
+export type UnknownRecord = Readonly<Record<string, unknown>>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isUnknownArray(value: unknown): value is readonly unknown[];
+export declare function recordAt(value: unknown, key: string | number): UnknownRecord | undefined;
+export declare function errorMessage(error: unknown): string;
+export declare function hasErrorCode(error: unknown, code: string): boolean;
+/** Retain native error names without letting a broken stringifier replace the caught failure. */
+export declare function errorDescription(error: unknown): string;

package/docs/code-quality.md

@@ -26,7 +26,7 @@ Tests retain complexity 15, depth 4 and parameters 6. Cohesive test suites have
 no size or statement limits.
 
 Formatting uses width 100, two spaces, LF and double quotes. npm owns lockfile
-formatting. Generated runtime schemas and build outputs keep their own bytes.
+formatting. Build outputs keep their own bytes.
 The VS Code Oxc extension uses these same lint and formatting configurations.
 
 `npm run ci` runs lint, formatting, TypeScript, package/install smokes and all
@@ -34,5 +34,8 @@ tests. CI separately qualifies the latest official Pi on GitHub-hosted Linux and
 the maintained fork on Linux and macOS. There is no custom checker build, probe
 suite or self-hosted runner requirement.
 
-CI's lint job also checks schema/validator drift against the committed dev dependencies,
-before qualification substitutes the selected host graph.
+CI's lint job also enforces the production line/byte shrink budget before
+qualification substitutes the selected host graph. The retired workflow schema
+generator and its patching dependency are not part of the new runtime.
+The active-child viewer has an approved aggregate budget of 19,000 source lines
+and 22,500 production lines. The 1 MiB byte ceiling and all lint limits stay unchanged.