@psnext/slingcli 2.4.20260520-2 → 2.4.20260520-4

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/repo-utils.js

@@ -0,0 +1,39 @@
+import { SessionError, } from "../types.js";
+import { Session } from "./session.js";
+import { uuidv7 } from "./uuid.js";
+export function createSessionId() {
+    return uuidv7();
+}
+export function createTimestamp() {
+    return new Date().toISOString();
+}
+export function toSession(storage) {
+    return new Session(storage);
+}
+export function getFileSystemResultOrThrow(result, message) {
+    if (!result.ok) {
+        const code = result.error.code === "not_found" ? "not_found" : "storage";
+        throw new SessionError(code, `${message}: ${result.error.message}`, result.error);
+    }
+    return result.value;
+}
+export async function getEntriesToFork(storage, options) {
+    if (!options.entryId)
+        return storage.getEntries();
+    const target = await storage.getEntry(options.entryId);
+    if (!target) {
+        throw new SessionError("invalid_fork_target", `Entry ${options.entryId} not found`);
+    }
+    let effectiveLeafId;
+    if ((options.position ?? "before") === "at") {
+        effectiveLeafId = target.id;
+    }
+    else {
+        if (target.type !== "message" || target.message.role !== "user") {
+            throw new SessionError("invalid_fork_target", `Entry ${options.entryId} is not a user message`);
+        }
+        effectiveLeafId = target.parentId;
+    }
+    return storage.getPathToRoot(effectiveLeafId);
+}
+//# sourceMappingURL=repo-utils.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/session.js

@@ -1,4 +1,5 @@
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage } from "../messages.js";
+import { SessionError } from "../types.js";
 export function buildSessionContext(pathEntries) {
     let thinkingLevel = "off";
     let model = null;
@@ -154,7 +155,7 @@ export class Session {
     }
     async appendLabel(targetId, label) {
         if (!(await this.storage.getEntry(targetId))) {
-            throw new Error(`Entry ${targetId} not found`);
+            throw new SessionError("not_found", `Entry ${targetId} not found`);
         }
         return this.appendTypedEntry({
             type: "label",
@@ -176,7 +177,7 @@ export class Session {
     }
     async moveTo(entryId, summary) {
         if (entryId !== null && !(await this.storage.getEntry(entryId))) {
-            throw new Error(`Entry ${entryId} not found`);
+            throw new SessionError("not_found", `Entry ${entryId} not found`);
         }
         await this.storage.setLeafId(entryId);
         if (!summary)

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/uuid.js

@@ -0,0 +1,50 @@
+let lastTimestamp = -Infinity;
+let sequence = 0;
+function fillRandomBytes(bytes) {
+    const crypto = globalThis.crypto;
+    if (crypto?.getRandomValues) {
+        crypto.getRandomValues(bytes);
+        return;
+    }
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+}
+export function uuidv7() {
+    const random = new Uint8Array(16);
+    fillRandomBytes(random);
+    const timestamp = Date.now();
+    if (timestamp > lastTimestamp) {
+        sequence = random[6] * 0x1000000 + random[7] * 0x10000 + random[8] * 0x100 + random[9];
+        lastTimestamp = timestamp;
+    }
+    else {
+        sequence = (sequence + 1) >>> 0;
+        if (sequence === 0) {
+            lastTimestamp++;
+        }
+    }
+    const bytes = new Uint8Array(16);
+    bytes[0] = (lastTimestamp / 0x10000000000) & 0xff;
+    bytes[1] = (lastTimestamp / 0x100000000) & 0xff;
+    bytes[2] = (lastTimestamp / 0x1000000) & 0xff;
+    bytes[3] = (lastTimestamp / 0x10000) & 0xff;
+    bytes[4] = (lastTimestamp / 0x100) & 0xff;
+    bytes[5] = lastTimestamp & 0xff;
+    bytes[6] = 0x70 | ((sequence >>> 28) & 0x0f);
+    bytes[7] = (sequence >>> 20) & 0xff;
+    bytes[8] = 0x80 | ((sequence >>> 14) & 0x3f);
+    bytes[9] = (sequence >>> 6) & 0xff;
+    bytes[10] = ((sequence & 0x3f) << 2) | (random[10] & 0x03);
+    bytes[11] = random[11];
+    bytes[12] = random[12];
+    bytes[13] = random[13];
+    bytes[14] = random[14];
+    bytes[15] = random[15];
+    return formatUuid(bytes);
+}
+function formatUuid(bytes) {
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+//# sourceMappingURL=uuid.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/skills.js

@@ -1,5 +1,6 @@
 import ignore from "ignore";
 import { parse } from "yaml";
+import { toError } from "./types.js";
 const MAX_NAME_LENGTH = 64;
 const MAX_DESCRIPTION_LENGTH = 1024;
 const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
@@ -18,8 +19,20 @@ export async function loadSkills(env, dirs) {
     const skills = [];
     const diagnostics = [];
     for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
-        const rootInfo = await safeFileInfo(env, dir);
-        if (!rootInfo || (await resolveKind(env, rootInfo)) !== "directory")
+        const rootInfoResult = await env.fileInfo(dir);
+        if (!rootInfoResult.ok) {
+            if (rootInfoResult.error.code !== "not_found") {
+                diagnostics.push({
+                    type: "warning",
+                    code: "file_info_failed",
+                    message: rootInfoResult.error.message,
+                    path: dir,
+                });
+            }
+            continue;
+        }
+        const rootInfo = rootInfoResult.value;
+        if ((await resolveKind(env, rootInfo, diagnostics)) !== "directory")
             continue;
         const result = await loadSkillsFromDirInternal(env, rootInfo.path, true, ignore(), rootInfo.path);
         skills.push(...result.skills);
@@ -49,24 +62,33 @@ export async function loadSourcedSkills(env, inputs, mapSkill) {
 async function loadSkillsFromDirInternal(env, dir, includeRootFiles, ignoreMatcher, rootDir) {
     const skills = [];
     const diagnostics = [];
-    if (!(await env.exists(dir)))
-        return { skills, diagnostics };
-    const dirInfo = await safeFileInfo(env, dir);
-    if (!dirInfo || (await resolveKind(env, dirInfo)) !== "directory")
+    const dirInfoResult = await env.fileInfo(dir);
+    if (!dirInfoResult.ok) {
+        if (dirInfoResult.error.code !== "not_found") {
+            diagnostics.push({
+                type: "warning",
+                code: "file_info_failed",
+                message: dirInfoResult.error.message,
+                path: dir,
+            });
+        }
         return { skills, diagnostics };
-    await addIgnoreRules(env, ignoreMatcher, dir, rootDir);
-    let entries;
-    try {
-        entries = await env.listDir(dir);
     }
-    catch {
+    const dirInfo = dirInfoResult.value;
+    if ((await resolveKind(env, dirInfo, diagnostics)) !== "directory")
+        return { skills, diagnostics };
+    await addIgnoreRules(env, ignoreMatcher, dir, rootDir, diagnostics);
+    const entriesResult = await env.listDir(dir);
+    if (!entriesResult.ok) {
+        diagnostics.push({ type: "warning", code: "list_failed", message: entriesResult.error.message, path: dir });
         return { skills, diagnostics };
     }
+    const entries = entriesResult.value;
     for (const entry of entries) {
         if (entry.name !== "SKILL.md")
             continue;
         const fullPath = entry.path;
-        const kind = await resolveKind(env, entry);
+        const kind = await resolveKind(env, entry, diagnostics);
         if (kind !== "file")
             continue;
         const relPath = relativeEnvPath(rootDir, fullPath);
@@ -82,7 +104,7 @@ async function loadSkillsFromDirInternal(env, dir, includeRootFiles, ignoreMatch
         if (entry.name.startsWith(".") || entry.name === "node_modules")
             continue;
         const fullPath = entry.path;
-        const kind = await resolveKind(env, entry);
+        const kind = await resolveKind(env, entry, diagnostics);
         if (!kind)
             continue;
         const relPath = relativeEnvPath(rootDir, fullPath);
@@ -104,24 +126,36 @@ async function loadSkillsFromDirInternal(env, dir, includeRootFiles, ignoreMatch
     }
     return { skills, diagnostics };
 }
-async function addIgnoreRules(env, ig, dir, rootDir) {
+async function addIgnoreRules(env, ig, dir, rootDir, diagnostics) {
     const relativeDir = relativeEnvPath(rootDir, dir);
     const prefix = relativeDir ? `${relativeDir}/` : "";
     for (const filename of IGNORE_FILE_NAMES) {
         const ignorePath = joinEnvPath(dir, filename);
-        const info = await safeFileInfo(env, ignorePath);
-        if (info?.kind !== "file")
+        const info = await env.fileInfo(ignorePath);
+        if (!info.ok) {
+            if (info.error.code !== "not_found") {
+                diagnostics.push({
+                    type: "warning",
+                    code: "file_info_failed",
+                    message: info.error.message,
+                    path: ignorePath,
+                });
+            }
+            continue;
+        }
+        if (info.value.kind !== "file")
+            continue;
+        const content = await env.readTextFile(ignorePath);
+        if (!content.ok) {
+            diagnostics.push({ type: "warning", code: "read_failed", message: content.error.message, path: ignorePath });
             continue;
-        try {
-            const content = await env.readTextFile(ignorePath);
-            const patterns = content
-                .split(/\r?\n/)
-                .map((line) => prefixIgnorePattern(line, prefix))
-                .filter((line) => Boolean(line));
-            if (patterns.length > 0)
-                ig.add(patterns);
         }
-        catch { }
+        const patterns = content.value
+            .split(/\r?\n/)
+            .map((line) => prefixIgnorePattern(line, prefix))
+            .filter((line) => Boolean(line));
+        if (patterns.length > 0)
+            ig.add(patterns);
     }
 }
 function prefixIgnorePattern(line, prefix) {
@@ -146,37 +180,41 @@ function prefixIgnorePattern(line, prefix) {
 }
 async function loadSkillFromFile(env, filePath) {
     const diagnostics = [];
-    try {
-        const rawContent = await env.readTextFile(filePath);
-        const { frontmatter, body } = parseFrontmatter(rawContent);
-        const skillDir = dirnameEnvPath(filePath);
-        const parentDirName = basenameEnvPath(skillDir);
-        for (const error of validateDescription(frontmatter.description)) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        const name = frontmatter.name || parentDirName;
-        for (const error of validateName(name, parentDirName)) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        if (!frontmatter.description || frontmatter.description.trim() === "") {
-            return { skill: null, diagnostics };
-        }
-        return {
-            skill: {
-                name,
-                description: frontmatter.description,
-                content: body,
-                filePath,
-                disableModelInvocation: frontmatter["disable-model-invocation"] === true,
-            },
-            diagnostics,
-        };
+    const rawContent = await env.readTextFile(filePath);
+    if (!rawContent.ok) {
+        diagnostics.push({ type: "warning", code: "read_failed", message: rawContent.error.message, path: filePath });
+        return { skill: null, diagnostics };
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "failed to parse skill file";
-        diagnostics.push({ type: "warning", message, path: filePath });
+    const parsed = parseFrontmatter(rawContent.value);
+    if (!parsed.ok) {
+        diagnostics.push({ type: "warning", code: "parse_failed", message: parsed.error.message, path: filePath });
         return { skill: null, diagnostics };
     }
+    const { frontmatter, body } = parsed.value;
+    const skillDir = dirnameEnvPath(filePath);
+    const parentDirName = basenameEnvPath(skillDir);
+    const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
+    for (const error of validateDescription(description)) {
+        diagnostics.push({ type: "warning", code: "invalid_metadata", message: error, path: filePath });
+    }
+    const frontmatterName = typeof frontmatter.name === "string" ? frontmatter.name : undefined;
+    const name = frontmatterName || parentDirName;
+    for (const error of validateName(name, parentDirName)) {
+        diagnostics.push({ type: "warning", code: "invalid_metadata", message: error, path: filePath });
+    }
+    if (!description || description.trim() === "") {
+        return { skill: null, diagnostics };
+    }
+    return {
+        skill: {
+            name,
+            description,
+            content: body,
+            filePath,
+            disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        },
+        diagnostics,
+    };
 }
 function validateName(name, parentDirName) {
     const errors = [];
@@ -204,35 +242,49 @@ function validateDescription(description) {
     return errors;
 }
 function parseFrontmatter(content) {
-    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (!normalized.startsWith("---"))
-        return { frontmatter: {}, body: normalized };
-    const endIndex = normalized.indexOf("\n---", 3);
-    if (endIndex === -1)
-        return { frontmatter: {}, body: normalized };
-    const yamlString = normalized.slice(4, endIndex);
-    const body = normalized.slice(endIndex + 4).trim();
-    return { frontmatter: (parse(yamlString) ?? {}), body };
-}
-async function safeFileInfo(env, path) {
     try {
-        return await env.fileInfo(path);
+        const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (!normalized.startsWith("---"))
+            return { ok: true, value: { frontmatter: {}, body: normalized } };
+        const endIndex = normalized.indexOf("\n---", 3);
+        if (endIndex === -1)
+            return { ok: true, value: { frontmatter: {}, body: normalized } };
+        const yamlString = normalized.slice(4, endIndex);
+        const body = normalized.slice(endIndex + 4).trim();
+        return { ok: true, value: { frontmatter: (parse(yamlString) ?? {}), body } };
     }
-    catch {
-        return undefined;
+    catch (error) {
+        return { ok: false, error: toError(error) };
     }
 }
-async function resolveKind(env, info) {
+async function resolveKind(env, info, diagnostics) {
     if (info.kind === "file" || info.kind === "directory")
         return info.kind;
-    try {
-        const realPath = await env.realPath(info.path);
-        const target = await env.fileInfo(realPath);
-        return target.kind === "file" || target.kind === "directory" ? target.kind : undefined;
+    const canonicalPath = await env.canonicalPath(info.path);
+    if (!canonicalPath.ok) {
+        if (canonicalPath.error.code !== "not_found") {
+            diagnostics.push({
+                type: "warning",
+                code: "file_info_failed",
+                message: canonicalPath.error.message,
+                path: info.path,
+            });
+        }
+        return undefined;
     }
-    catch {
+    const target = await env.fileInfo(canonicalPath.value);
+    if (!target.ok) {
+        if (target.error.code !== "not_found") {
+            diagnostics.push({
+                type: "warning",
+                code: "file_info_failed",
+                message: target.error.message,
+                path: info.path,
+            });
+        }
         return undefined;
     }
+    return target.value.kind === "file" || target.value.kind === "directory" ? target.value.kind : undefined;
 }
 function joinEnvPath(base, child) {
     return `${base.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;

package/node_modules/@earendil-works/pi-agent-core/dist/harness/types.js

@@ -1,16 +1,94 @@
-/** Error thrown by {@link ExecutionEnv} file operations. */
+/** Create a successful {@link Result}. */
+export function ok(value) {
+    return { ok: true, value };
+}
+/** Create a failed {@link Result}. */
+export function err(error) {
+    return { ok: false, error };
+}
+/** Return the success value or throw the failure error. Intended for tests and explicit adapter boundaries. */
+export function getOrThrow(result) {
+    if (!result.ok)
+        throw result.error;
+    return result.value;
+}
+/** Return the success value or `undefined`. Only object values are allowed to avoid truthiness bugs with primitives. */
+export function getOrUndefined(result) {
+    return result.ok ? result.value : undefined;
+}
+/** Normalize unknown thrown values into Error instances before using them as typed error causes. */
+export function toError(error) {
+    if (error instanceof Error)
+        return error;
+    if (typeof error === "string")
+        return new Error(error);
+    try {
+        return new Error(JSON.stringify(error));
+    }
+    catch {
+        return new Error(String(error));
+    }
+}
+/** Error returned by {@link FileSystem} file operations. */
 export class FileError extends Error {
-    code;
-    path;
-    constructor(
     /** Backend-independent error code. */
-    code, message, 
+    code;
     /** Absolute addressed path associated with the failure, when available. */
-    path, options) {
-        super(message, options);
+    path;
+    constructor(code, message, path, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "FileError";
         this.code = code;
         this.path = path;
-        this.name = "FileError";
+    }
+}
+/** Error returned by {@link ExecutionEnv.exec}. */
+export class ExecutionError extends Error {
+    /** Backend-independent error code. */
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "ExecutionError";
+        this.code = code;
+    }
+}
+/** Error returned by compaction helpers. */
+export class CompactionError extends Error {
+    /** Backend-independent error code. */
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "CompactionError";
+        this.code = code;
+    }
+}
+/** Error returned by branch summarization helpers. */
+export class BranchSummaryError extends Error {
+    /** Backend-independent error code. */
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "BranchSummaryError";
+        this.code = code;
+    }
+}
+/** Error thrown by session storage, repositories, and session tree operations. */
+export class SessionError extends Error {
+    /** Session subsystem error code. */
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "SessionError";
+        this.code = code;
+    }
+}
+/** Public AgentHarness failure with a stable top-level classification. */
+export class AgentHarnessError extends Error {
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "AgentHarnessError";
+        this.code = code;
     }
 }
 //# sourceMappingURL=types.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/utils/shell-output.js

@@ -1,8 +1,11 @@
-import { randomBytes } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { ExecutionError, err, ok, toError, } from "../types.js";
 import { DEFAULT_MAX_BYTES, truncateTail } from "./truncate.js";
+function toExecutionError(error) {
+    if (error instanceof ExecutionError)
+        return error;
+    const cause = toError(error);
+    return new ExecutionError("unknown", cause.message, cause);
+}
 export function sanitizeBinaryOutput(str) {
     return Array.from(str)
         .filter((char) => {
@@ -23,35 +26,61 @@ export async function executeShellWithCapture(env, command, options) {
     const outputChunks = [];
     let outputBytes = 0;
     const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
-    let tempFilePath;
-    let tempFileStream;
+    const encoder = new TextEncoder();
     let totalBytes = 0;
-    const ensureTempFile = () => {
-        if (tempFilePath)
+    let fullOutputPath;
+    let writeChain = Promise.resolve(ok(undefined));
+    let captureError;
+    const appendFullOutput = (text) => {
+        if (!fullOutputPath || captureError)
             return;
-        const id = randomBytes(8).toString("hex");
-        tempFilePath = join(tmpdir(), `bash-${id}.log`);
-        tempFileStream = createWriteStream(tempFilePath);
-        for (const chunk of outputChunks) {
-            tempFileStream.write(chunk);
-        }
+        const path = fullOutputPath;
+        writeChain = writeChain.then(async (previous) => {
+            if (!previous.ok)
+                return previous;
+            const appendResult = await env.appendFile(path, text, options?.abortSignal);
+            return appendResult.ok ? ok(undefined) : err(toExecutionError(appendResult.error));
+        });
+    };
+    const ensureFullOutputFile = (initialContent) => {
+        if (fullOutputPath || captureError)
+            return;
+        writeChain = writeChain.then(async (previous) => {
+            if (!previous.ok)
+                return previous;
+            const tempFile = await env.createTempFile({
+                prefix: "bash-",
+                suffix: ".log",
+                abortSignal: options?.abortSignal,
+            });
+            if (!tempFile.ok)
+                return err(toExecutionError(tempFile.error));
+            fullOutputPath = tempFile.value;
+            const appendResult = await env.appendFile(tempFile.value, initialContent, options?.abortSignal);
+            return appendResult.ok ? ok(undefined) : err(toExecutionError(appendResult.error));
+        });
     };
     const onChunk = (chunk) => {
-        totalBytes += Buffer.byteLength(chunk, "utf-8");
-        const text = sanitizeBinaryOutput(chunk).replace(/\r/g, "");
-        if (totalBytes > DEFAULT_MAX_BYTES) {
-            ensureTempFile();
-        }
-        if (tempFileStream) {
-            tempFileStream.write(text);
+        try {
+            totalBytes += encoder.encode(chunk).byteLength;
+            const text = sanitizeBinaryOutput(chunk).replace(/\r/g, "");
+            if (totalBytes > DEFAULT_MAX_BYTES && !fullOutputPath) {
+                ensureFullOutputFile(outputChunks.join("") + text);
+            }
+            else {
+                appendFullOutput(text);
+            }
+            outputChunks.push(text);
+            outputBytes += text.length;
+            while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
+                const removed = outputChunks.shift();
+                outputBytes -= removed.length;
+            }
+            options?.onChunk?.(text);
         }
-        outputChunks.push(text);
-        outputBytes += text.length;
-        while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
-            const removed = outputChunks.shift();
-            outputBytes -= removed.length;
+        catch (error) {
+            captureError = toExecutionError(error);
         }
-        options?.onChunk?.(text);
     };
     try {
         const result = await env.exec(command, {
@@ -59,39 +88,39 @@ export async function executeShellWithCapture(env, command, options) {
             onStdout: onChunk,
             onStderr: onChunk,
         });
-        const fullOutput = outputChunks.join("");
-        const truncationResult = truncateTail(fullOutput);
-        if (truncationResult.truncated) {
-            ensureTempFile();
+        const tailOutput = outputChunks.join("");
+        const truncationResult = truncateTail(tailOutput);
+        if (truncationResult.truncated && !fullOutputPath) {
+            ensureFullOutputFile(tailOutput);
+        }
+        const writeResult = await writeChain;
+        if (!writeResult.ok)
+            return err(writeResult.error);
+        if (captureError)
+            return err(captureError);
+        if (!result.ok) {
+            if (result.error.code === "aborted" || options?.abortSignal?.aborted) {
+                return ok({
+                    output: truncationResult.truncated ? truncationResult.content : tailOutput,
+                    exitCode: undefined,
+                    cancelled: true,
+                    truncated: truncationResult.truncated,
+                    fullOutputPath,
+                });
+            }
+            return err(result.error);
         }
-        tempFileStream?.end();
-        const cancelled = options?.signal?.aborted ?? false;
-        return {
-            output: truncationResult.truncated ? truncationResult.content : fullOutput,
-            exitCode: cancelled ? undefined : result.exitCode,
+        const cancelled = options?.abortSignal?.aborted ?? false;
+        return ok({
+            output: truncationResult.truncated ? truncationResult.content : tailOutput,
+            exitCode: cancelled ? undefined : result.value.exitCode,
             cancelled,
             truncated: truncationResult.truncated,
-            fullOutputPath: tempFilePath,
-        };
+            fullOutputPath,
+        });
     }
-    catch (err) {
-        if (options?.signal?.aborted) {
-            const fullOutput = outputChunks.join("");
-            const truncationResult = truncateTail(fullOutput);
-            if (truncationResult.truncated) {
-                ensureTempFile();
-            }
-            tempFileStream?.end();
-            return {
-                output: truncationResult.truncated ? truncationResult.content : fullOutput,
-                exitCode: undefined,
-                cancelled: true,
-                truncated: truncationResult.truncated,
-                fullOutputPath: tempFilePath,
-            };
-        }
-        tempFileStream?.end();
-        throw err;
+    catch (error) {
+        return err(toExecutionError(error));
     }
 }
 //# sourceMappingURL=shell-output.js.map