poe-code 3.0.258 → 3.0.259

package/packages/agent-script/dist/interp/interpreter.js

@@ -86,15 +86,16 @@ export async function interpret(node, options = {}) {
         peakDataSize: { enumerable: false, value: 0, writable: true }
     });
     const activeLoopIterations = new Map();
+    const microtasks = [];
     hoistVarDeclarations(node, scope);
-    const evaluation = await evaluateNode(node, {
+    const context = {
         budget,
         callStack: [],
         onYield: options.onYield,
         rootNode: node,
         scope,
         stats,
-        microtasks: [],
+        microtasks,
         activeLoopIterations,
         restoredLoopIterations: new Map(Object.entries(options.snapshot?.loopIterations ?? {}).map(([nodeId, iteration]) => [
             Number(nodeId),
@@ -102,7 +103,9 @@ export async function interpret(node, options = {}) {
         ])),
         generatorResume: options.generatorResume,
         generatorYield: options.generatorYield
-    });
+    };
+    const evaluation = await evaluateNode(node, context);
+    await drainMicrotasks(context);
     const snapshot = scope.snapshot();
     reconcileDataBudget(budget, stats, scope, "hasValue" in evaluation && evaluation.hasValue ? evaluation.value : undefined);
     if (evaluation.kind === "error") {
@@ -143,6 +146,21 @@ export async function interpret(node, options = {}) {
     };
 }
 export { Scope } from "./scope.js";
+async function drainMicrotasks(context) {
+    let idleTurns = 0;
+    while (idleTurns < 20) {
+        const task = context.microtasks.shift();
+        if (task === undefined) {
+            idleTurns += 1;
+            await Promise.resolve();
+            continue;
+        }
+        idleTurns = 0;
+        context.budget.visitNode();
+        task();
+        await Promise.resolve();
+    }
+}
 async function evaluateNode(node, context) {
     context.budget.visitNode();
     context.stats.nodeVisits += 1;
@@ -225,7 +243,7 @@ async function evaluateArrayExpression(node, context) {
             if (!spreadValues.ok) {
                 return spreadValues.result;
             }
-            values.push(...spreadValues.value);
+            appendArrayValues(values, spreadValues.value);
             context.budget.allocateArrayLength(values.length);
             continue;
         }
@@ -263,6 +281,9 @@ async function evaluateObjectExpression(node, context) {
         if (value.kind !== "normal") {
             return value;
         }
+        if (isObjectPrototypeSetterProperty(property, key.value)) {
+            continue;
+        }
         defineSandboxProperty(object, String(key.value), value.value);
     }
     return {
@@ -271,6 +292,9 @@ async function evaluateObjectExpression(node, context) {
         value: object
     };
 }
+function isObjectPrototypeSetterProperty(property, key) {
+    return !property.computed && !property.shorthand && key === "__proto__";
+}
 async function evaluateTemplateLiteral(node, context) {
     let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
     for (let index = 0; index < node.expressions.length; index += 1) {
@@ -326,7 +350,9 @@ async function evaluateTemplateExpressionValues(node, context) {
 }
 function createTaggedTemplateStrings(node, context) {
     context.budget.allocateArrayLength(node.quasis.length);
-    const strings = node.quasis.map((quasi) => context.budget.allocateString(quasi.value.cooked));
+    const strings = node.quasis.map((quasi) => quasi.value.cooked === undefined
+        ? undefined
+        : context.budget.allocateString(quasi.value.cooked));
     context.budget.allocateArrayLength(node.quasis.length);
     const raw = node.quasis.map((quasi) => context.budget.allocateString(quasi.value.raw));
     Object.defineProperty(strings, "raw", {
@@ -565,7 +591,7 @@ async function evaluateIdentifier(node, context) {
     if (!binding.found) {
         return {
             kind: "error",
-            error: createError("UNBOUND_IDENTIFIER", node, `Identifier '${node.name}' is not defined.`)
+            error: createError("UNBOUND_IDENTIFIER", node, `Identifier '${node.name}' is not defined.`, context.callStack)
         };
     }
     return {
@@ -609,6 +635,12 @@ async function evaluateVariableDeclaration(node, context) {
         predeclareDeclarationBindings(node, context.scope);
     }
     for (const declarator of node.declarations) {
+        if (node.kind === "var" &&
+            declarator.init === undefined &&
+            declarator.id.type === "Identifier" &&
+            context.scope.lookup(declarator.id.name).found) {
+            continue;
+        }
         const restoredValue = declarator.id.type === "Identifier"
             ? context.scope.consumeRestoredBinding(declarator.id.name)
             : { found: false };
@@ -774,11 +806,21 @@ function predeclareStatementListBindings(statements, context) {
     for (const statement of statements) {
         if (statement.type === "FunctionDeclaration") {
             const name = statement.id.name;
-            if (names.has(name) || scope.hasOwnBinding(name)) {
+            if (names.has(name)) {
+                throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
+            }
+            const closure = createInterpretedClosure(statement, context, evaluateNode);
+            const ownBindingKind = scope.getOwnBindingKind(name);
+            if (ownBindingKind === "var") {
+                names.add(name);
+                scope.assign(name, closure);
+                continue;
+            }
+            if (ownBindingKind !== undefined) {
                 throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
             }
             names.add(name);
-            scope.declare(name, "const", createInterpretedClosure(statement, context, evaluateNode));
+            scope.declare(name, "const", closure);
             continue;
         }
         if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
@@ -1380,7 +1422,7 @@ async function evaluateUnaryExpression(node, context) {
     return {
         kind: "normal",
         hasValue: true,
-        value: applyUnaryOperator(node.operator, argument.value)
+        value: await applyUnaryOperator(node.operator, argument.value, context)
     };
 }
 async function evaluateDeleteExpression(node, context) {
@@ -1634,8 +1676,9 @@ function getConstructorName(callee) {
 function formatStackFrame(node, name) {
     return `    at ${name ?? "<anonymous>"} (line ${node.span.start.line}, column ${node.span.start.column})`;
 }
-function createError(code, node, message) {
+function createError(code, node, message, stackFrames = []) {
     const name = code === "UNBOUND_IDENTIFIER" ? "ReferenceError" : "Error";
+    const stack = [...stackFrames, formatStackFrame(node, undefined)];
     return {
         code,
         message,
@@ -1643,7 +1686,7 @@ function createError(code, node, message) {
         nodeId: node.nodeId,
         nodeType: node.type,
         span: node.span,
-        stack: formatErrorStack(name, message, [formatStackFrame(node, undefined)])
+        stack: formatErrorStack(name, message, stack)
     };
 }
 function attachFatalSandboxErrorContext(error, node, stackFrames) {
@@ -1900,7 +1943,7 @@ async function evaluateSetMethodCall(node, target, methodName, context) {
         leaveCall();
     }
 }
-function applyUnaryOperator(operator, value) {
+async function applyUnaryOperator(operator, value, context) {
     switch (operator) {
         case "!":
             return !value;
@@ -1911,11 +1954,11 @@ function applyUnaryOperator(operator, value) {
         case "void":
             return undefined;
         case "+":
-            return toNumber(value);
+            return toNumber(await toNumericPrimitive(value, context));
         case "-":
-            return -toNumber(value);
+            return -toNumber(await toNumericPrimitive(value, context));
         case "~":
-            return ~toNumber(value);
+            return ~toNumber(await toNumericPrimitive(value, context));
     }
 }
 function describeTypeofValue(value) {
@@ -1928,7 +1971,7 @@ function describeTypeofValue(value) {
     return typeof value;
 }
 function isTruthy(value) {
-    return applyUnaryOperator("!", value) === false;
+    return Boolean(value);
 }
 function applyBinaryOperator(node, left, right, context) {
     switch (node.operator) {
@@ -2112,6 +2155,24 @@ function toPrimitive(value) {
     }
     return toString(value);
 }
+async function toNumericPrimitive(value, context) {
+    if (isPrimitiveCoercionType(getCoercionType(value))) {
+        return value;
+    }
+    if (isIndexableSandboxValue(value)) {
+        for (const methodName of ["valueOf", "toString"]) {
+            const method = getMemberValue(value, methodName, context);
+            if (!isSandboxClosure(method)) {
+                continue;
+            }
+            const result = await invokeSandboxClosure(method, [], context, context.callStack, undefined, value);
+            if (isPrimitiveCoercionType(getCoercionType(result))) {
+                return result;
+            }
+        }
+    }
+    return toString(value);
+}
 function toNumber(value) {
     if (typeof value === "number") {
         return value;
@@ -2144,6 +2205,11 @@ function toString(value) {
 function isIndexableSandboxValue(value) {
     return Array.isArray(value) || isPlainSandboxObject(value);
 }
+function appendArrayValues(target, values) {
+    for (const value of values) {
+        target.push(value);
+    }
+}
 function isPlainSandboxObject(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -2287,7 +2353,7 @@ async function evaluateCallArguments(args, context) {
             if (!spreadValues.ok) {
                 return spreadValues;
             }
-            values.push(...spreadValues.value);
+            appendArrayValues(values, spreadValues.value);
             context.budget.allocateArrayLength(values.length);
             continue;
         }

package/packages/agent-script/dist/interp/methods/array.js

@@ -180,7 +180,8 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
             return budgetProducedValue(result, options.budget);
         }
         case "push": {
-            const nextLength = value.push(...args);
+            appendArrayValues(value, args);
+            const nextLength = value.length;
             budgetProducedValue(value, options.budget);
             return nextLength;
         }
@@ -189,12 +190,34 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
         case "shift":
             return budgetProducedValue(value.shift(), options.budget);
         case "unshift": {
-            const nextLength = value.unshift(...args);
+            prependArrayValues(value, args);
+            const nextLength = value.length;
             budgetProducedValue(value, options.budget);
             return nextLength;
         }
     }
 }
+function appendArrayValues(target, values) {
+    for (const value of values) {
+        target.push(value);
+    }
+}
+function prependArrayValues(target, values) {
+    const originalLength = target.length;
+    target.length = originalLength + values.length;
+    for (let index = originalLength - 1; index >= 0; index -= 1) {
+        const targetIndex = index + values.length;
+        if (Object.hasOwn(target, index)) {
+            target[targetIndex] = target[index];
+        }
+        else {
+            delete target[targetIndex];
+        }
+    }
+    for (let index = 0; index < values.length; index += 1) {
+        target[index] = values[index];
+    }
+}
 function isCallbackArrayMethod(methodName) {
     return (methodName === "map" ||
         methodName === "filter" ||

package/packages/agent-script/dist/interp/methods/regex.js

@@ -39,6 +39,6 @@ export function toMatchArray(match, input) {
         return null;
     }
     const result = [match.text, ...match.captures];
-    Object.assign(result, { index: match.index, input });
+    Object.assign(result, { groups: undefined, index: match.index, input });
     return result;
 }

package/packages/agent-script/dist/interp/promise-tracker.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorSourceSpan } from "../error/shape.js";
+import type { SandboxPromise, SandboxValue } from "./values.js";
+export declare class SandboxPromiseRejectionTracker {
+    private readonly records;
+    private readonly recordsByPromise;
+    observe(promise: SandboxPromise): void;
+    track(promise: SandboxPromise): void;
+    findUnhandledRejection(): Promise<{
+        reason: SandboxValue | undefined;
+        span: ErrorSourceSpan | undefined;
+    } | undefined>;
+}
+export declare function createSandboxPromiseRejectionTracker(): SandboxPromiseRejectionTracker;
+export declare function observeSandboxPromise(promise: SandboxPromise): void;
+export declare function trackSandboxPromise(promise: SandboxPromise): void;
+export declare function withSandboxPromiseRejectionTracker<TResult>(tracker: SandboxPromiseRejectionTracker, callback: () => TResult): TResult;

package/packages/agent-script/dist/interp/promise-tracker.js

@@ -0,0 +1,58 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export class SandboxPromiseRejectionTracker {
+    records = new Set();
+    recordsByPromise = new WeakMap();
+    observe(promise) {
+        const record = this.recordsByPromise.get(promise);
+        if (record !== undefined) {
+            record.observed = true;
+        }
+    }
+    track(promise) {
+        if (this.recordsByPromise.has(promise)) {
+            return;
+        }
+        const record = {
+            observed: false,
+            promise,
+            rejected: false
+        };
+        this.records.add(record);
+        this.recordsByPromise.set(promise, record);
+        promise.promise.then(() => undefined, (reason) => {
+            record.rejected = true;
+            record.rejectionReason = reason;
+        });
+        promise.promise.catch(() => undefined);
+    }
+    async findUnhandledRejection() {
+        await flushPromiseJobs();
+        for (const record of this.records) {
+            if (record.rejected && !record.observed) {
+                return {
+                    reason: record.rejectionReason,
+                    span: record.promise.span
+                };
+            }
+        }
+        return undefined;
+    }
+}
+const activePromiseTracker = new AsyncLocalStorage();
+export function createSandboxPromiseRejectionTracker() {
+    return new SandboxPromiseRejectionTracker();
+}
+export function observeSandboxPromise(promise) {
+    activePromiseTracker.getStore()?.observe(promise);
+}
+export function trackSandboxPromise(promise) {
+    activePromiseTracker.getStore()?.track(promise);
+}
+export function withSandboxPromiseRejectionTracker(tracker, callback) {
+    return activePromiseTracker.run(tracker, callback);
+}
+async function flushPromiseJobs() {
+    for (let index = 0; index < 20; index += 1) {
+        await Promise.resolve();
+    }
+}

package/packages/agent-script/dist/interp/promise.js

@@ -1,4 +1,5 @@
 import { SandboxError } from "./budget.js";
+import { observeSandboxPromise } from "./promise-tracker.js";
 import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
 export function createPromiseGlobals(options) {
     return {
@@ -54,21 +55,33 @@ export function getPromiseMember(target, property, budget, enqueue = (task) => P
     if (property === "then") {
         return createSandboxClosure({
             async: true,
-            call: ([onFulfilled, onRejected]) => createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget)))),
+            call: ([onFulfilled, onRejected]) => {
+                observeSandboxPromise(target);
+                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained))));
+                return chained;
+            },
             name: "then"
         });
     }
     if (property === "catch") {
         return createSandboxClosure({
             async: true,
-            call: ([onRejected]) => createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(undefined, value, "fulfilled", budget), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget)))),
+            call: ([onRejected]) => {
+                observeSandboxPromise(target);
+                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(undefined, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained))));
+                return chained;
+            },
             name: "catch"
         });
     }
     if (property === "finally") {
         return createSandboxClosure({
             async: true,
-            call: ([onFinally]) => createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseFinally(onFinally, value, "fulfilled", budget), (reason) => runPromiseFinally(onFinally, reason, "rejected", budget)))),
+            call: ([onFinally]) => {
+                observeSandboxPromise(target);
+                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained), (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained))));
+                return chained;
+            },
             name: "finally"
         });
     }
@@ -140,6 +153,7 @@ function resolveSandboxValueNow(value, options, seenThenables) {
         return Promise.resolve(value).then((resolved) => resolveSandboxValueNow(resolved, options, seenThenables), (reason) => Promise.reject(budgetIfNeeded(reason, options.budget)));
     }
     if (isSandboxPromise(value)) {
+        observeSandboxPromise(value);
         return value.promise.then((resolved) => {
             value.hostCallJournal?.consume(value.hostCall);
             return resolveSandboxValueNow(resolved, options, seenThenables);
@@ -226,30 +240,47 @@ function resolveThenable(value, then, options, seenThenables) {
         }
     }).then((resolved) => budgetIfNeeded(resolved, options.budget));
 }
-function runPromiseReaction(handler, value, state, budget) {
+function runPromiseReaction(handler, value, state, budget, self) {
     if (!isSandboxClosure(handler)) {
         return state === "fulfilled"
             ? Promise.resolve(value)
             : Promise.reject(budgetSandboxValue(value, budget));
     }
     try {
-        return resolveSandboxValue(handler.call([value]), { budget });
+        const result = handler.call([value]);
+        return resolveReactionResult(result, budget, self);
     }
     catch (error) {
         return Promise.reject(error);
     }
 }
-function runPromiseFinally(handler, value, state, budget) {
+function runPromiseFinally(handler, value, state, budget, self) {
     if (!isSandboxClosure(handler)) {
         return runPromiseReaction(undefined, value, state, budget);
     }
     try {
-        return resolveSandboxValue(handler.call([]), { budget }).then(() => runPromiseReaction(undefined, value, state, budget));
+        const result = handler.call([]);
+        return resolveReactionResult(result, budget, self).then(() => runPromiseReaction(undefined, value, state, budget));
     }
     catch (error) {
         return Promise.reject(error);
     }
 }
+function resolveReactionResult(result, budget, self) {
+    return Promise.resolve(result).then((resolved) => {
+        if (isSelfResolution(resolved, self)) {
+            return Promise.reject({
+                message: "Promise cannot resolve to itself.",
+                name: "TypeError"
+            });
+        }
+        return resolveSandboxValue(resolved, { budget });
+    });
+}
+function isSelfResolution(result, self) {
+    return (self !== undefined &&
+        (result === self || (isSandboxPromise(result) && result.promise === self.promise)));
+}
 function getThenable(value) {
     if (typeof value !== "object" ||
         value === null ||

package/packages/agent-script/dist/interp/scope.d.ts

@@ -25,6 +25,7 @@ export declare class Scope {
         found: false;
     };
     hasOwnBinding(name: string): boolean;
+    getOwnBindingKind(name: string): VariableDeclarationKind | undefined;
     isFunctionBoundary(): boolean;
     iterationChild(names: readonly string[]): Scope;
     lookupImportMeta(): InterpreterValue;

package/packages/agent-script/dist/interp/scope.js

@@ -39,6 +39,9 @@ export class Scope {
     hasOwnBinding(name) {
         return this.#bindings.has(name);
     }
+    getOwnBindingKind(name) {
+        return this.#bindings.get(name)?.kind;
+    }
     isFunctionBoundary() {
         return this.options.functionBoundary === true;
     }

package/packages/agent-script/dist/interp/values.js

@@ -1,5 +1,6 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { SandboxError } from "./budget.js";
+import { trackSandboxPromise } from "./promise-tracker.js";
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 const sandboxClosureBrand = Symbol("SandboxClosure");
@@ -57,6 +58,7 @@ export function createSandboxPromise(promise, metadata = {}) {
             value: metadata.hostCallJournal
         });
     }
+    trackSandboxPromise(sandboxPromise);
     return Object.freeze(sandboxPromise);
 }
 export function createSandboxGenerator(channel, metadata = undefined) {

package/packages/agent-script/dist/lint/index.d.ts

@@ -1,3 +1,4 @@
+import type { DefaultExportSignature } from "./rules/AS-export-import-meta.js";
 import { type SourceSpan } from "../parse/parser.js";
 import type { Modules } from "./rules/module-registry.js";
 export type Diagnostic = {
@@ -18,6 +19,7 @@ export type Fix = {
 export type LintOptions = {
     allowedExportNames?: readonly string[];
     allowedGlobals?: readonly string[];
+    defaultExport?: DefaultExportSignature;
     fix?: boolean;
     filename?: string;
     largeLiteralThreshold?: number;

package/packages/agent-script/dist/lint/index.js

@@ -77,9 +77,11 @@ const KNOWN_DIAGNOSTIC_CODES = new Set([
     "AS015",
     "AS-ASYNC-NOT-NEEDED",
     "AS-AWAIT-NON-PROMISE",
+    "AS-EXPORT-DEFAULT-MISSING",
     "AS-DESTRUCTURE-NULL-DEFAULT",
     "AS-EXPORT-DEFAULT-MULTIPLE",
     "AS-EXPORT-DEFAULT-NOT-ARROW",
+    "AS-EXPORT-DEFAULT-SIGNATURE",
     "AS-EXPORT-IMPORT-META",
     "AS-EXPORT-UNKNOWN",
     "AS-FLOATING-PROMISE",

package/packages/agent-script/dist/lint/rules/AS-export-import-meta.d.ts

@@ -1,5 +1,5 @@
 import { type SourceSpan } from "../../parse/parser.js";
-type DiagnosticCode = "AS-EXPORT-DEFAULT-MULTIPLE" | "AS-EXPORT-DEFAULT-NOT-ARROW" | "AS-EXPORT-UNKNOWN" | "AS-IMPORT-META-ASSIGN" | "AS-RETURN-AT-TOP";
+type DiagnosticCode = "AS-EXPORT-DEFAULT-MISSING" | "AS-EXPORT-DEFAULT-MULTIPLE" | "AS-EXPORT-DEFAULT-NOT-ARROW" | "AS-EXPORT-DEFAULT-SIGNATURE" | "AS-EXPORT-UNKNOWN" | "AS-IMPORT-META-ASSIGN" | "AS-RETURN-AT-TOP";
 export type Diagnostic = {
     code: DiagnosticCode;
     severity: "error" | "warning";
@@ -9,8 +9,13 @@ export type Diagnostic = {
     column: number;
     span: SourceSpan;
 };
+export type DefaultExportSignature = {
+    parameters?: readonly string[];
+    required?: boolean;
+};
 export declare function AS_EXPORT_IMPORT_META(source: string, options?: {
     allowedExportNames?: readonly string[];
+    defaultExport?: DefaultExportSignature;
     filename?: string;
 }): Diagnostic[];
 export {};

package/packages/agent-script/dist/lint/rules/AS-export-import-meta.js

@@ -1,14 +1,16 @@
 import { parseModule } from "../../parse/parser.js";
 export function AS_EXPORT_IMPORT_META(source, options = {}) {
-    return new Scanner(options.filename ?? "<input>", new Set(options.allowedExportNames ?? [])).scan(source);
+    return new Scanner(options.filename ?? "<input>", new Set(options.allowedExportNames ?? []), options.defaultExport).scan(source);
 }
 class Scanner {
     filename;
     allowedExportNames;
+    defaultExport;
     diagnostics = [];
-    constructor(filename, allowedExportNames) {
+    constructor(filename, allowedExportNames, defaultExport) {
         this.filename = filename;
         this.allowedExportNames = allowedExportNames;
+        this.defaultExport = defaultExport;
     }
     scan(source) {
         this.visitModule(parseModule(source, this.filename));
@@ -17,6 +19,9 @@ class Scanner {
     visitModule(node) {
         const defaultExports = node.body.filter((statement) => statement.type === "ExportDefaultDeclaration");
         const hasDefaultExport = defaultExports.length > 0;
+        if (!hasDefaultExport && this.defaultExport?.required === true) {
+            this.pushDiagnostic("AS-EXPORT-DEFAULT-MISSING", "error", "Module must export a default entry point.", node.span);
+        }
         for (const [index, statement] of defaultExports.entries()) {
             if (index > 0) {
                 this.pushDiagnostic("AS-EXPORT-DEFAULT-MULTIPLE", "error", "Module contains more than one export default declaration.", statement.span);
@@ -35,8 +40,11 @@ class Scanner {
                 this.visitExportNamedDeclaration(node.declaration);
                 return;
             case "ExportDefaultDeclaration":
-                if (node.declaration.type !== "ArrowFunctionExpression") {
-                    this.pushDiagnostic("AS-EXPORT-DEFAULT-NOT-ARROW", "error", "Export default initializer must be an arrow expression.", node.declaration.span);
+                if (!isDefaultExportCallable(node.declaration)) {
+                    this.pushDiagnostic("AS-EXPORT-DEFAULT-NOT-ARROW", "error", "Export default initializer must be an arrow or function expression.", node.declaration.span);
+                }
+                else {
+                    this.visitDefaultExportSignature(node.declaration);
                 }
                 this.visitExpression(node.declaration);
                 return;
@@ -89,6 +97,15 @@ class Scanner {
         }
         this.visitVariableDeclaration(node);
     }
+    visitDefaultExportSignature(node) {
+        const parameters = this.defaultExport?.parameters;
+        if (parameters === undefined) {
+            return;
+        }
+        if (!hasParameterNames(node, parameters)) {
+            this.pushDiagnostic("AS-EXPORT-DEFAULT-SIGNATURE", "error", `Default export must declare signature (${parameters.join(", ")}).`, node.span);
+        }
+    }
     visitIfStatement(node) {
         this.visitExpression(node.test);
         this.visitStatement(node.consequent);
@@ -162,6 +179,9 @@ class Scanner {
                     this.visitExpression(node.body);
                 }
                 return;
+            case "FunctionExpression":
+                this.visitStatement(node.body);
+                return;
             case "AwaitExpression":
                 this.visitExpression(node.argument);
                 return;
@@ -314,6 +334,15 @@ class Scanner {
         });
     }
 }
+function isDefaultExportCallable(node) {
+    return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function hasParameterNames(node, names) {
+    if (node.params.length !== names.length) {
+        return false;
+    }
+    return node.params.every((param, index) => param.type === "Identifier" && param.name === names[index]);
+}
 function isImportMetaReference(node) {
     if (node.type === "MetaProperty") {
         return true;

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

@@ -147,10 +147,11 @@ async function runSpawnAttempt(spawnAgent, input, onEvent, spawnId) {
 }
 function runObservedSpawn(moduleSink, input, operation) {
     const otelSink = input.otelSink ?? moduleSink ?? getActiveOtelSink();
+    const cwd = input.cwd ?? readCurrentWorkingDirectory();
     const span = safeStartSpan(otelSink, "agent.spawn", {
         agent: input.agent,
         mode: input.mode ?? "yolo",
-        cwd: input.cwd ?? process.cwd()
+        cwd
     });
     const deactivateSpan = activateOtelSpan(span);
     safeAddEvent(span, "prompt", { prompt: input.prompt });
@@ -176,6 +177,14 @@ function runObservedSpawn(moduleSink, input, operation) {
     bindOtelSpan(promise, span);
     return promise;
 }
+function readCurrentWorkingDirectory() {
+    try {
+        return process.cwd();
+    }
+    catch (error) {
+        throw new Error(`Unable to resolve current working directory: ${formatSpawnError(error)}`);
+    }
+}
 async function runSpawnRetry(spawnAgent, input, retryOptions, onEvent, spawnId, throwOnResultFailure = true) {
     const task = resolveTaskLabel(input);
     const startedAt = Date.now();