poe-code 3.0.258 → 3.0.259

package/packages/agent-script/dist/modules/log.js

@@ -1,3 +1,4 @@
+import { addBrokenPipeListener, createBrokenPipeState, createSafeOutputStream } from "../output-stream.js";
 export function makeLogModule(sink = createJsonlStdoutSink()) {
     const normalizedSink = readSink(sink);
     return {
@@ -26,8 +27,11 @@ export function makeLogModule(sink = createJsonlStdoutSink()) {
     };
 }
 function createJsonlStdoutSink() {
+    const brokenPipe = createBrokenPipeState();
+    const stdout = createSafeOutputStream(process.stdout, brokenPipe);
+    addBrokenPipeListener(process.stdout, brokenPipe);
     return (entry) => {
-        process.stdout.write(`${JSON.stringify(toJsonValue(entry, new WeakSet()))}\n`);
+        stdout.write(`${JSON.stringify(toJsonValue(entry, new WeakSet()))}\n`);
     };
 }
 function readNonEmptyString(value, label) {

package/packages/agent-script/dist/modules/registry.js

@@ -1,3 +1,4 @@
+import { attachErrorSpan } from "../error/shape.js";
 import { wrapCancelableBindings } from "../interp/cancel.js";
 import { readHostOperationPolicy, wrapCallerInjectedBindings } from "../interp/host-bridge.js";
 import { registerPendingHostCallPolicy } from "../snapshot/policy.js";
@@ -29,7 +30,7 @@ function bindImportDeclaration(declaration, registry, wrappedModules, bindings,
     const moduleName = declaration.source.value;
     const moduleExports = registry.get(moduleName);
     if (moduleExports === undefined) {
-        throw new Error(createUnknownModuleMessage(moduleName, [...registry.keys()]));
+        throw createModuleImportError(createUnknownModuleMessage(moduleName, [...registry.keys()]), declaration.source.span);
     }
     const wrappedExports = wrappedModules.get(moduleName) ??
         wrapCancelableBindings(wrapCallerInjectedBindings(Object.fromEntries(moduleExports), {
@@ -42,7 +43,7 @@ function bindImportDeclaration(declaration, registry, wrappedModules, bindings,
     for (const specifier of declaration.specifiers) {
         const localName = specifier.local.name;
         if (Object.hasOwn(bindings, localName)) {
-            throw new Error(`Cannot redeclare imported binding '${localName}'.`);
+            throw createModuleImportError(`Cannot redeclare imported binding '${localName}'.`, specifier.local.span);
         }
         bindings[localName] = resolveImportSpecifier(moduleName, specifier, wrappedExports);
     }
@@ -56,7 +57,12 @@ function resolveImportSpecifier(moduleName, specifier, wrappedExports) {
     if (exportedValue !== undefined || Object.hasOwn(wrappedExports, exportName)) {
         return exportedValue;
     }
-    throw new Error(createUnknownExportMessage(moduleName, exportName, Object.keys(wrappedExports).sort()));
+    throw createModuleImportError(createUnknownExportMessage(moduleName, exportName, Object.keys(wrappedExports).sort()), specifier.span);
+}
+function createModuleImportError(message, span) {
+    const error = new Error(message);
+    attachErrorSpan(error, span);
+    return error;
 }
 function normalizeModuleRegistry(modules) {
     if (modules === undefined) {

package/packages/agent-script/dist/output-stream.d.ts

@@ -0,0 +1,12 @@
+export type OutputStream = {
+    off?(event: "error", listener: (error: unknown) => void): void;
+    on?(event: "error", listener: (error: unknown) => void): void;
+    write(chunk: string): void;
+};
+export type BrokenPipeState = {
+    closed: boolean;
+};
+export declare function createBrokenPipeState(): BrokenPipeState;
+export declare function createSafeOutputStream(stream: OutputStream, brokenPipe: BrokenPipeState): OutputStream;
+export declare function withBrokenPipeGuard<TResult>(streams: readonly OutputStream[], brokenPipe: BrokenPipeState, callback: () => Promise<TResult>): Promise<TResult>;
+export declare function addBrokenPipeListener(stream: OutputStream, brokenPipe: BrokenPipeState): () => void;

package/packages/agent-script/dist/output-stream.js

@@ -0,0 +1,50 @@
+import { hasOwnErrorCode } from "./error-codes.js";
+export function createBrokenPipeState() {
+    return { closed: false };
+}
+export function createSafeOutputStream(stream, brokenPipe) {
+    return {
+        write(chunk) {
+            if (brokenPipe.closed) {
+                return;
+            }
+            try {
+                stream.write(chunk);
+            }
+            catch (error) {
+                if (isBrokenPipeError(error)) {
+                    brokenPipe.closed = true;
+                    return;
+                }
+                throw error;
+            }
+        }
+    };
+}
+export async function withBrokenPipeGuard(streams, brokenPipe, callback) {
+    const removeListeners = streams.map((stream) => addBrokenPipeListener(stream, brokenPipe));
+    try {
+        return await callback();
+    }
+    finally {
+        for (const removeListener of removeListeners) {
+            removeListener();
+        }
+    }
+}
+export function addBrokenPipeListener(stream, brokenPipe) {
+    const onError = (error) => {
+        if (isBrokenPipeError(error)) {
+            brokenPipe.closed = true;
+            return;
+        }
+        throw error;
+    };
+    stream.on?.("error", onError);
+    return () => {
+        stream.off?.("error", onError);
+    };
+}
+function isBrokenPipeError(error) {
+    return hasOwnErrorCode(error, "EPIPE");
+}

package/packages/agent-script/dist/parse/parser.d.ts

@@ -55,7 +55,7 @@ export type TemplateElement = BaseNode & {
     tail: boolean;
     value: {
         raw: string;
-        cooked: string;
+        cooked: string | undefined;
     };
 };
 export type TemplateLiteral = BaseNode & {

package/packages/agent-script/dist/parse/parser.js

@@ -4,6 +4,8 @@ import { formatParseError } from "./format-error.js";
 import { createExportDefaultDeclaration, createExportNamedDeclaration } from "./parse-export.js";
 import { createImportMeta, isImportMetaTokenSequence } from "./parse-import-meta.js";
 import { parseRegex } from "../interp/regex/parse.js";
+const MAX_CONDITIONAL_EXPRESSION_DEPTH = 256;
+const MAX_IF_STATEMENT_DEPTH = 2_048;
 export class DisallowedSyntaxError extends Error {
     constructor(syntax, position) {
         super(`Disallowed syntax '${syntax}' at line ${position.line}, column ${position.column}.`);
@@ -18,6 +20,7 @@ const MULTIPLICATIVE_OPERATORS = new Set(["*", "/", "%"]);
 const BITWISE_OR_OPERATORS = new Set(["|"]);
 const BITWISE_XOR_OPERATORS = new Set(["^"]);
 const BITWISE_AND_OPERATORS = new Set(["&"]);
+const MAX_UNICODE_CODE_POINT = 0x10ffff;
 const TOP_LEVEL_STATEMENT_KEYWORDS = new Set([
     "break",
     "const",
@@ -96,6 +99,8 @@ class Parser {
     tokens;
     index = 0;
     breakableDepth = 0;
+    conditionalExpressionDepth = 0;
+    ifStatementDepth = 0;
     loopDepth = 0;
     generatorBody = false;
     scopes = [new Map()];
@@ -254,23 +259,33 @@ class Parser {
         };
     }
     parseConditionalExpression() {
-        const test = this.parseCoalesceExpression();
-        if (this.consumePunctuator("?") === undefined) {
-            return test;
+        if (this.conditionalExpressionDepth >= MAX_CONDITIONAL_EXPRESSION_DEPTH) {
+            const token = this.currentToken();
+            throw new Error(`Conditional expression nesting limit exceeded at line ${token.start.line}, column ${token.start.column}.`);
+        }
+        this.conditionalExpressionDepth += 1;
+        try {
+            const test = this.parseCoalesceExpression();
+            if (this.consumePunctuator("?") === undefined) {
+                return test;
+            }
+            const consequent = this.parseExpression();
+            this.expectPunctuator(":");
+            const alternate = this.parseConditionalExpression();
+            return {
+                node: {
+                    type: "ConditionalExpression",
+                    test: test.node,
+                    consequent: consequent.node,
+                    alternate: alternate.node,
+                    span: createSpan(test.node.span.start, alternate.node.span.end)
+                },
+                parenthesized: false
+            };
+        }
+        finally {
+            this.conditionalExpressionDepth -= 1;
         }
-        const consequent = this.parseExpression();
-        this.expectPunctuator(":");
-        const alternate = this.parseConditionalExpression();
-        return {
-            node: {
-                type: "ConditionalExpression",
-                test: test.node,
-                consequent: consequent.node,
-                alternate: alternate.node,
-                span: createSpan(test.node.span.start, alternate.node.span.end)
-            },
-            parenthesized: false
-        };
     }
     parseArrowFunctionBody() {
         if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
@@ -436,28 +451,38 @@ class Parser {
         throw new DisallowedSyntaxError("label", firstLabelToken.start);
     }
     parseIfStatement() {
-        const ifToken = this.expectKeyword("if");
-        this.expectPunctuator("(");
-        const test = this.parseExpression({ allowSequence: true }).node;
-        this.expectPunctuator(")");
-        const consequent = this.parseStatement();
-        if (consequent.type !== "BlockStatement") {
-            while (this.currentToken().type === "punctuator" &&
-                this.currentToken().value === ";" &&
-                this.peekToken(1).type === "keyword" &&
-                this.peekToken(1).value === "else") {
-                this.index += 1;
+        if (this.ifStatementDepth >= MAX_IF_STATEMENT_DEPTH) {
+            const token = this.currentToken();
+            throw new Error(`If statement nesting limit exceeded at line ${token.start.line}, column ${token.start.column}.`);
+        }
+        this.ifStatementDepth += 1;
+        try {
+            const ifToken = this.expectKeyword("if");
+            this.expectPunctuator("(");
+            const test = this.parseExpression({ allowSequence: true }).node;
+            this.expectPunctuator(")");
+            const consequent = this.parseStatement();
+            if (consequent.type !== "BlockStatement") {
+                while (this.currentToken().type === "punctuator" &&
+                    this.currentToken().value === ";" &&
+                    this.peekToken(1).type === "keyword" &&
+                    this.peekToken(1).value === "else") {
+                    this.index += 1;
+                }
             }
+            const elseToken = this.consumeKeyword("else");
+            const alternate = elseToken === undefined ? undefined : this.parseStatement();
+            return {
+                type: "IfStatement",
+                test,
+                consequent,
+                alternate,
+                span: createSpan(ifToken.start, alternate?.span.end ?? consequent.span.end)
+            };
+        }
+        finally {
+            this.ifStatementDepth -= 1;
         }
-        const elseToken = this.consumeKeyword("else");
-        const alternate = elseToken === undefined ? undefined : this.parseStatement();
-        return {
-            type: "IfStatement",
-            test,
-            consequent,
-            alternate,
-            span: createSpan(ifToken.start, alternate?.span.end ?? consequent.span.end)
-        };
     }
     parseSwitchStatement() {
         const switchToken = this.currentToken();
@@ -784,7 +809,7 @@ class Parser {
     }
     parseExportDefaultDeclaration(exportToken) {
         this.index += 1;
-        if (this.currentToken().value === "function" || this.currentToken().value === "class") {
+        if (this.currentToken().value === "class") {
             throw new DisallowedSyntaxError(`export default ${this.currentToken().value}`, this.currentToken().start);
         }
         const declaration = this.parseExpression().node;
@@ -1447,7 +1472,7 @@ class Parser {
             const next = this.currentToken();
             const hasArgument = delegate ||
                 (!hasLineBreakBetween(token, next) &&
-                    !(next.type === "punctuator" && (next.value === ";" || next.value === "}")) &&
+                    !(next.type === "punctuator" && isYieldArgumentTerminator(next.value)) &&
                     next.type !== "eof");
             const argument = hasArgument ? this.parseAssignmentExpression().node : undefined;
             if (delegate && argument === undefined) {
@@ -1591,7 +1616,7 @@ class Parser {
                 continue;
             }
             if (this.currentToken().type === "template") {
-                const quasi = createTemplateLiteral(this.currentToken());
+                const quasi = createTemplateLiteral(this.currentToken(), { allowMalformedEscapes: true });
                 this.index += 1;
                 expression = {
                     node: {
@@ -1679,7 +1704,7 @@ class Parser {
         if (token.type === "template") {
             this.index += 1;
             return {
-                node: createTemplateLiteral(token),
+                node: createTemplateLiteral(token, { allowMalformedEscapes: false }),
                 parenthesized: false
             };
         }
@@ -2834,6 +2859,9 @@ function isAssignmentOperator(value) {
             return false;
     }
 }
+function isYieldArgumentTerminator(value) {
+    return value === ";" || value === "}" || value === ")" || value === "]" || value === ",";
+}
 function createNumericLiteral(token) {
     return {
         type: "NumericLiteral",
@@ -2915,7 +2943,7 @@ function createLiteralFromToken(token) {
     }
     return createKeywordLiteral(token);
 }
-function createTemplateLiteral(token) {
+function createTemplateLiteral(token, options = { allowMalformedEscapes: false }) {
     const raw = token.value;
     const expressions = [];
     const quasis = [];
@@ -2928,7 +2956,7 @@ function createTemplateLiteral(token) {
             continue;
         }
         if (char === "$" && raw[cursor + 1] === "{") {
-            quasis.push(createTemplateElement(token.start, raw, quasiStart, cursor, false));
+            quasis.push(createTemplateElement(token.start, raw, quasiStart, cursor, false, options));
             const expressionStart = cursor + 2;
             const expressionEnd = findTemplateExpressionEnd(raw, expressionStart);
             expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart)));
@@ -2938,7 +2966,7 @@ function createTemplateLiteral(token) {
         }
         cursor += 1;
     }
-    quasis.push(createTemplateElement(token.start, raw, quasiStart, raw.length - 1, true));
+    quasis.push(createTemplateElement(token.start, raw, quasiStart, raw.length - 1, true, options));
     return {
         type: "TemplateLiteral",
         expressions,
@@ -2997,18 +3025,96 @@ function isDecimalDigit(value) {
 function isHexDigit(value) {
     return isDecimalDigit(value) || (value >= "a" && value <= "f") || (value >= "A" && value <= "F");
 }
-function createTemplateElement(templateStart, rawTemplate, rawStart, rawEnd, tail) {
+function isOctalDigit(value) {
+    return value >= "0" && value <= "7";
+}
+function createTemplateElement(templateStart, rawTemplate, rawStart, rawEnd, tail, options) {
     const rawValue = rawTemplate.slice(rawStart, rawEnd);
+    const cooked = decodeTemplateElementCooked(rawValue, options.allowMalformedEscapes);
+    if (cooked.invalid !== undefined && !options.allowMalformedEscapes) {
+        const position = positionWithinRaw(templateStart, rawTemplate, rawStart + cooked.invalid.index);
+        throw new Error(`${cooked.invalid.message} at line ${position.line}, column ${position.column}.`);
+    }
     return {
         type: "TemplateElement",
         tail,
         value: {
             raw: rawValue,
-            cooked: decodeEscapedText(normalizeTemplateLineTerminators(rawValue))
+            cooked: cooked.invalid === undefined ? cooked.value : undefined
         },
         span: createSpan(positionWithinRaw(templateStart, rawTemplate, rawStart), positionWithinRaw(templateStart, rawTemplate, rawEnd))
     };
 }
+function decodeTemplateElementCooked(value, allowMalformedEscapes) {
+    const normalized = normalizeTemplateLineTerminators(value);
+    const invalid = findMalformedTemplateEscape(normalized);
+    if (invalid !== undefined) {
+        return allowMalformedEscapes ? { invalid } : { invalid };
+    }
+    return {
+        value: decodeEscapedText(normalized)
+    };
+}
+function findMalformedTemplateEscape(value) {
+    let index = 0;
+    while (index < value.length) {
+        if (value[index] !== "\\") {
+            index += 1;
+            continue;
+        }
+        const next = value[index + 1];
+        if (next === undefined || next === "\n") {
+            index += 2;
+            continue;
+        }
+        if (next === "u") {
+            if (!isValidUnicodeEscape(value, index)) {
+                return { index, message: "Invalid unicode escape" };
+            }
+            index += 2;
+            continue;
+        }
+        if (next === "x") {
+            const hex = value.slice(index + 2, index + 4);
+            if (hex.length !== 2 || ![...hex].every(isHexDigit)) {
+                return { index, message: "Invalid hex escape" };
+            }
+            index += 4;
+            continue;
+        }
+        if (next === "0") {
+            if (isDecimalDigit(value[index + 2] ?? "")) {
+                return { index, message: "Legacy octal escape sequences are not supported" };
+            }
+            index += 2;
+            continue;
+        }
+        if (isOctalDigit(next)) {
+            return { index, message: "Legacy octal escape sequences are not supported" };
+        }
+        index += 2;
+    }
+    return undefined;
+}
+function isValidUnicodeEscape(value, start) {
+    let index = start + 2;
+    if (value[index] === "{") {
+        index += 1;
+        const codePointStart = index;
+        while (index < value.length && value[index] !== "}") {
+            if (!isHexDigit(value[index] ?? "")) {
+                return false;
+            }
+            index += 1;
+        }
+        if (index === codePointStart || value[index] !== "}") {
+            return false;
+        }
+        return Number.parseInt(value.slice(codePointStart, index), 16) <= MAX_UNICODE_CODE_POINT;
+    }
+    const hex = value.slice(index, index + 4);
+    return hex.length === 4 && [...hex].every(isHexDigit);
+}
 function findTemplateExpressionEnd(raw, start) {
     let depth = 1;
     let index = start;

package/packages/agent-script/dist/parse/tokenizer.js

@@ -164,6 +164,10 @@ class Lexer {
     skipTrivia() {
         while (!this.isAtEnd()) {
             const char = this.currentChar();
+            if (this.isHashbangCommentStart()) {
+                this.skipLineComment();
+                continue;
+            }
             if (isWhitespace(char) || isLineBreak(char)) {
                 this.advance();
                 continue;
@@ -244,7 +248,7 @@ class Lexer {
                 return;
             }
             if (char === "\\") {
-                this.readEscapedLiteralCharacter();
+                this.skipEscapedTemplateCharacter();
                 continue;
             }
             if (char === "$" && this.peekChar(1) === "{") {
@@ -405,7 +409,7 @@ class Lexer {
                 return;
             }
             if (char === "\\") {
-                this.readEscapedLiteralCharacter();
+                this.skipEscapedTemplateCharacter();
                 continue;
             }
             if (char === "$" && this.peekChar(1) === "{") {
@@ -706,6 +710,10 @@ class Lexer {
     isHtmlStyleCommentDelimiter() {
         return this.source.startsWith("<!--", this.index) || this.source.startsWith("-->", this.index);
     }
+    isHashbangCommentStart() {
+        return (this.source.startsWith("#!", this.index) &&
+            (this.index === 0 || (this.index === 1 && this.source[0] === "\uFEFF")));
+    }
     readUnicodeEscape() {
         const escapeStart = this.position();
         this.advance();
@@ -760,6 +768,21 @@ class Lexer {
         }
         this.advance();
     }
+    skipEscapedTemplateCharacter() {
+        this.advance();
+        if (this.isAtEnd()) {
+            return;
+        }
+        const escaped = this.currentChar();
+        if (escaped === "\r") {
+            this.advance();
+            if (this.currentChar() === "\n") {
+                this.advance();
+            }
+            return;
+        }
+        this.advance();
+    }
     readExtendedUnicodeEscape(escapeStart) {
         this.advance();
         const codePointStart = this.position();
@@ -852,7 +875,7 @@ function isOctalDigit(char) {
     return char >= "0" && char <= "7";
 }
 function isWhitespace(char) {
-    return char === " " || char === "\t" || char === "\v" || char === "\f";
+    return char === " " || char === "\t" || char === "\v" || char === "\f" || char === "\uFEFF";
 }
 function isLineBreak(char) {
     return char === "\n" || char === "\r";

package/packages/agent-script/dist/run.js

@@ -5,6 +5,7 @@ import { restore } from "./restore.js";
 import { Budget } from "./interp/budget.js";
 import { wrapCancelableBindings } from "./interp/cancel.js";
 import { enterSnapshotRun } from "./interp/running-state.js";
+import { createSandboxPromiseRejectionTracker, observeSandboxPromise, withSandboxPromiseRejectionTracker } from "./interp/promise-tracker.js";
 import { HostCallJournal } from "./interp/host-call.js";
 import { createConsoleJsonGlobals } from "./interp/globals/console-json.js";
 import { createCollectionGlobals } from "./interp/globals/collections.js";
@@ -33,10 +34,12 @@ export class UnhandledRejectionError extends Error {
         replaceErrorStack(this);
     }
 }
+const DEFAULT_MAX_CALL_DEPTH = 1_000;
 export function run(source, options = {}) {
     const lifecycle = { hostCallbackDepth: 0 };
     const dumpController = createDumpController(lifecycle);
-    const result = (async () => {
+    const promiseTracker = createSandboxPromiseRejectionTracker();
+    const result = withSandboxPromiseRejectionTracker(promiseTracker, async () => {
         const deactivateOtelSink = activateOtelSink(options.otelSink);
         let leaveSnapshotRun;
         let createFailureSnapshot;
@@ -46,7 +49,7 @@ export function run(source, options = {}) {
             if (restoredSnapshot !== undefined) {
                 leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
             }
-            const budget = options.budget ?? new Budget();
+            const budget = options.budget ?? new Budget({ maxCallDepth: DEFAULT_MAX_CALL_DEPTH });
             budget.reset();
             const filename = options.filename ?? "<input>";
             const module = parseExecutableModule(source, filename);
@@ -189,6 +192,7 @@ export function run(source, options = {}) {
             });
             dumpController.finalize(snapshot);
             await throwIfReturnedPromiseRejected(result);
+            await throwIfUnhandledPromiseRejected(promiseTracker);
             return {
                 ...result,
                 snapshot
@@ -218,13 +222,14 @@ export function run(source, options = {}) {
             leaveSnapshotRun?.();
             deactivateOtelSink();
         }
-    })();
+    });
     return attachDumpController(result, dumpController);
 }
 async function throwIfReturnedPromiseRejected(result) {
     if (!result.ok || !isSandboxPromise(result.returnValue)) {
         return;
     }
+    observeSandboxPromise(result.returnValue);
     let rejected = false;
     let rejectionReason;
     result.returnValue.promise.then(() => undefined, (reason) => {
@@ -240,6 +245,12 @@ async function throwIfReturnedPromiseRejected(result) {
         throw new UnhandledRejectionError(rejectionReason, result.returnValue.span);
     }
 }
+async function throwIfUnhandledPromiseRejected(tracker) {
+    const unhandled = await tracker.findUnhandledRejection();
+    if (unhandled !== undefined) {
+        throw new UnhandledRejectionError(unhandled.reason, unhandled.span);
+    }
+}
 async function callEntryPoint(input) {
     const defaultExport = input.scope.lookup("default");
     if (!defaultExport.found) {

package/packages/agent-script/dist/runner/run-harness.js

@@ -2,6 +2,7 @@ import { readFile, stat } from "node:fs/promises";
 import { extname } from "node:path";
 import { supportsSpawnMode } from "@poe-code/agent-spawn/configs";
 import { SPAWN_MODES } from "@poe-code/agent-spawn/types";
+import { hasOwnErrorCode } from "../error-codes.js";
 import { extractBlock } from "../loader/extract-block.js";
 import { splitFrontmatter } from "../loader/frontmatter.js";
 import { lint } from "../lint.js";
@@ -86,6 +87,10 @@ export async function runHarnessPair(filepath, options) {
     const modules = options.modulesFor(frontmatter, meta);
     const diagnostics = lint(executableSource, {
         allowedExportNames: ["schema"],
+        defaultExport: {
+            parameters: ["frontmatter"],
+            required: true
+        },
         filename: pair.scriptPath,
         frontmatterFields: Object.keys(frontmatter),
         modules: createLintModulesFromRuntimeRegistry(modules)
@@ -112,11 +117,19 @@ export async function runHarnessPair(filepath, options) {
     });
 }
 async function readHarnessFile(filepath) {
-    const stats = await stat(filepath);
-    if (!stats.isFile()) {
-        throw new Error(`Harness path must point to a file: ${filepath}`);
+    try {
+        const stats = await stat(filepath);
+        if (!stats.isFile()) {
+            throw new Error(`Harness path must point to a file: ${filepath}`);
+        }
+        return await readFile(filepath, "utf8");
+    }
+    catch (error) {
+        if (hasOwnErrorCode(error, "ENOENT") || hasOwnErrorCode(error, "ENOTDIR")) {
+            throw new Error(`Harness file not found: ${filepath}`);
+        }
+        throw error;
     }
-    return readFile(filepath, "utf8");
 }
 function loadExecutableSource(filepath, source) {
     if (extname(filepath) === ".ajs") {
@@ -136,7 +149,7 @@ function loadExecutableSource(filepath, source) {
     const { source: executableBlock, lineOffset } = extractBlock(body);
     const absoluteLineOffset = countLineBreaks(source.slice(0, source.length - body.length)) + lineOffset;
     return {
-        executableSource: createLineOffsetSource(executableBlock, absoluteLineOffset),
+        executableSource: createLineOffsetSource(stripHashbang(executableBlock), absoluteLineOffset),
         frontmatter,
         isRawScript: false
     };
@@ -202,6 +215,16 @@ function excludeHarnessModule(modules, isRawScript) {
 function stripByteOrderMark(source) {
     return source.startsWith("\uFEFF") ? source.slice(1) : source;
 }
+function stripHashbang(source) {
+    if (!source.startsWith("#!")) {
+        return source;
+    }
+    const lineBreakIndex = source.indexOf("\n");
+    if (lineBreakIndex === -1) {
+        return "";
+    }
+    return source.slice(lineBreakIndex + 1);
+}
 function countLineBreaks(source) {
     let count = 0;
     for (const character of source) {

package/packages/agent-traces/dist/collect.d.ts

@@ -0,0 +1,4 @@
+import type { CollectHumanPromptsOptions, CollectHumanPromptsResult, HumanPromptRecord, TraceReader } from "./types.js";
+export declare function collectHumanPromptsFromReaders(readers: TraceReader[], options?: CollectHumanPromptsOptions): Promise<CollectHumanPromptsResult>;
+export declare function collectHumanPrompts(options?: CollectHumanPromptsOptions): Promise<HumanPromptRecord[]>;
+export declare function collectHumanPromptsWithStats(options?: CollectHumanPromptsOptions): Promise<CollectHumanPromptsResult>;