@a5c-ai/babysitter-sdk 0.0.31 → 0.0.33

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AA4sCA,wBAAgB,mBAAmB;eAEf,MAAM,EAAE,GAA2B,OAAO,CAAC,MAAM,CAAC;kBAyCpD,MAAM;EAIvB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AA20CA,wBAAgB,mBAAmB;eAEf,MAAM,EAAE,GAA2B,OAAO,CAAC,MAAM,CAAC;kBAyCpD,MAAM;EAIvB"}

package/dist/cli/main.js

@@ -37,7 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBabysitterCli = createBabysitterCli;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
-const nodeTaskRunner_1 = require("./nodeTaskRunner");
+const commitEffectResult_1 = require("../runtime/commitEffectResult");
 const orchestrateIteration_1 = require("../runtime/orchestrateIteration");
 const createRun_1 = require("../runtime/createRun");
 const effectIndex_1 = require("../runtime/replay/effectIndex");
@@ -52,7 +52,7 @@ const USAGE = `Usage:
   babysitter run:events <runDir> [--runs-dir <dir>] [--json] [--limit <n>] [--reverse] [--filter-type <type>]
   babysitter run:rebuild-state <runDir> [--runs-dir <dir>] [--json] [--dry-run]
   babysitter run:iterate <runDir> [--runs-dir <dir>] [--json] [--verbose] [--iteration <n>]
-  babysitter task:run <runDir> <effectId> [--runs-dir <dir>] [--json] [--dry-run]
+  babysitter task:post <runDir> <effectId> --status <ok|error> [--runs-dir <dir>] [--json] [--dry-run] [--value <file>] [--error <file>] [--stdout-ref <ref>] [--stderr-ref <ref>] [--stdout-file <file>] [--stderr-file <file>] [--started-at <iso8601>] [--finished-at <iso8601>] [--metadata <file>] [--invocation-key <key>]
   babysitter run:step <runDir> [--runs-dir <dir>] [--json] [--now <iso8601>]
   babysitter task:list <runDir> [--runs-dir <dir>] [--pending] [--kind <kind>] [--json]
   babysitter task:show <runDir> <effectId> [--runs-dir <dir>] [--json]
@@ -129,6 +129,55 @@ function parseArgs(argv) {
             parsed.filterType = expectFlagValue(rest, ++i, "--filter-type");
             continue;
         }
+        if (arg === "--status") {
+            const raw = expectFlagValue(rest, ++i, "--status");
+            const normalized = raw.toLowerCase();
+            if (normalized !== "ok" && normalized !== "error") {
+                throw new Error(`--status must be "ok" or "error" (received: ${raw})`);
+            }
+            parsed.taskStatus = normalized === "ok" ? "ok" : "error";
+            continue;
+        }
+        if (arg === "--value") {
+            parsed.valuePath = expectFlagValue(rest, ++i, "--value");
+            continue;
+        }
+        if (arg === "--error") {
+            parsed.errorPath = expectFlagValue(rest, ++i, "--error");
+            continue;
+        }
+        if (arg === "--stdout-ref") {
+            parsed.stdoutRef = expectFlagValue(rest, ++i, "--stdout-ref");
+            continue;
+        }
+        if (arg === "--stderr-ref") {
+            parsed.stderrRef = expectFlagValue(rest, ++i, "--stderr-ref");
+            continue;
+        }
+        if (arg === "--stdout-file") {
+            parsed.stdoutFile = expectFlagValue(rest, ++i, "--stdout-file");
+            continue;
+        }
+        if (arg === "--stderr-file") {
+            parsed.stderrFile = expectFlagValue(rest, ++i, "--stderr-file");
+            continue;
+        }
+        if (arg === "--started-at") {
+            parsed.startedAt = expectFlagValue(rest, ++i, "--started-at");
+            continue;
+        }
+        if (arg === "--finished-at") {
+            parsed.finishedAt = expectFlagValue(rest, ++i, "--finished-at");
+            continue;
+        }
+        if (arg === "--metadata") {
+            parsed.metadataPath = expectFlagValue(rest, ++i, "--metadata");
+            continue;
+        }
+        if (arg === "--invocation-key") {
+            parsed.invocationKey = expectFlagValue(rest, ++i, "--invocation-key");
+            continue;
+        }
         if (arg === "--process-id") {
             parsed.processId = expectFlagValue(rest, ++i, "--process-id");
             continue;
@@ -159,7 +208,7 @@ function parseArgs(argv) {
         }
         positionals.push(arg);
     }
-    if (parsed.command === "task:run") {
+    if (parsed.command === "task:post") {
         [parsed.runDirArg, parsed.effectId] = positionals;
     }
     else if (parsed.command === "task:list") {
@@ -293,12 +342,8 @@ function logVerbose(command, parsed, details) {
         .join(" ");
     console.error(`[${command}] verbose ${formatted}`);
 }
-function determineTaskStatus(result) {
-    if (result.timedOut)
-        return "timeout";
-    if (result.exitCode == null)
-        return "skipped";
-    return result.exitCode === 0 ? "ok" : "error";
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function toRunRelativePosix(runDir, absolutePath) {
     if (!absolutePath)
@@ -418,7 +463,7 @@ async function handleRunCreate(parsed) {
         runId: parsed.runIdOverride,
         inputsPath: parsed.inputsPath ? path.resolve(parsed.inputsPath) : undefined,
     });
-    let inputs;
+    let inputs = undefined;
     if (parsed.inputsPath) {
         try {
             inputs = await readInputsFile(parsed.inputsPath);
@@ -653,71 +698,170 @@ async function handleRunRebuildState(parsed) {
     console.log(`[run:rebuild-state] runDir=${runDir}${suffix}`);
     return 0;
 }
-async function handleTaskRun(parsed) {
+async function handleTaskPost(parsed) {
     if (!parsed.runDirArg || !parsed.effectId) {
         console.error(USAGE);
         return 1;
     }
+    if (!parsed.taskStatus) {
+        console.error(`[task:post] missing required --status <ok|error>`);
+        return 1;
+    }
+    if (parsed.stdoutRef && parsed.stdoutFile) {
+        console.error(`[task:post] cannot combine --stdout-ref with --stdout-file`);
+        return 1;
+    }
+    if (parsed.stderrRef && parsed.stderrFile) {
+        console.error(`[task:post] cannot combine --stderr-ref with --stderr-file`);
+        return 1;
+    }
     const runDir = resolveRunDir(parsed.runsDir, parsed.runDirArg);
     const secretLogsAllowed = allowSecretLogs(parsed);
-    const streamers = buildTaskRunStreamers(parsed);
-    logVerbose("task:run", parsed, {
+    logVerbose("task:post", parsed, {
         runDir,
         effectId: parsed.effectId,
+        status: parsed.taskStatus,
         dryRun: parsed.dryRun,
         json: parsed.json,
         secretLogsAllowed,
     });
-    const index = await buildEffectIndexSafe(runDir, "task:run");
+    const index = await buildEffectIndexSafe(runDir, "task:post");
     if (!index)
         return 1;
     const record = index.getByEffectId(parsed.effectId);
     if (!record) {
-        console.error(`[task:run] effect ${parsed.effectId} not found at ${runDir}`);
+        console.error(`[task:post] effect ${parsed.effectId} not found at ${runDir}`);
         return 1;
     }
-    const kind = (record.kind ?? "").toLowerCase();
-    if (kind !== "node") {
-        console.error(`[task:run] effect ${parsed.effectId} has kind=${record.kind ?? "unknown"}; task:run only supports kind="node"`);
+    if (record.status !== "requested") {
+        console.error(`[task:post] effect ${parsed.effectId} is not requested (status=${record.status ?? "unknown"})`);
         return 1;
     }
-    const result = await (0, nodeTaskRunner_1.runNodeTaskFromCli)({
+    const nowIso = new Date().toISOString();
+    const startedAt = parsed.startedAt ?? nowIso;
+    const finishedAt = parsed.finishedAt ?? nowIso;
+    const resolveMaybeRunRelative = (candidate) => {
+        if (!candidate)
+            return undefined;
+        if (candidate === "-")
+            return candidate;
+        if (path.isAbsolute(candidate) || /^[A-Za-z]:[\\/]/.test(candidate)) {
+            return candidate;
+        }
+        return path.join(runDir, candidate);
+    };
+    const readJsonFile = async (_label, filename) => {
+        if (!filename)
+            return undefined;
+        if (filename === "-") {
+            const raw = await readStdinUtf8();
+            const trimmed = raw.trim();
+            return trimmed.length ? JSON.parse(trimmed) : undefined;
+        }
+        const absolute = resolveMaybeRunRelative(filename);
+        const raw = await node_fs_1.promises.readFile(absolute, "utf8");
+        const trimmed = raw.trim();
+        return trimmed.length ? JSON.parse(trimmed) : undefined;
+    };
+    const readTextFile = async (_label, filename) => {
+        if (!filename)
+            return undefined;
+        if (filename === "-") {
+            return await readStdinUtf8();
+        }
+        const absolute = resolveMaybeRunRelative(filename);
+        return await node_fs_1.promises.readFile(absolute, "utf8");
+    };
+    const metadataRaw = await readJsonFile("metadata", parsed.metadataPath);
+    const metadata = isJsonRecord(metadataRaw) ? metadataRaw : undefined;
+    const stdout = parsed.stdoutFile ? await readTextFile("stdout", parsed.stdoutFile) : undefined;
+    const stderr = parsed.stderrFile ? await readTextFile("stderr", parsed.stderrFile) : undefined;
+    let value = undefined;
+    let errorPayload = undefined;
+    if (parsed.taskStatus === "ok") {
+        value = await readJsonFile("value", parsed.valuePath);
+    }
+    else {
+        errorPayload =
+            (await readJsonFile("error", parsed.errorPath)) ??
+                {
+                    name: "Error",
+                    message: "Task reported failure",
+                };
+    }
+    const invocationKey = parsed.invocationKey ?? record.invocationKey;
+    const plan = {
+        runDir: toRunRelativePosix(runDir, runDir) ?? runDir,
+        effectId: parsed.effectId,
+        status: parsed.taskStatus,
+        valueProvided: parsed.valuePath ? true : false,
+        errorProvided: parsed.errorPath ? true : false,
+        stdoutRef: parsed.stdoutRef ?? null,
+        stderrRef: parsed.stderrRef ?? null,
+        stdoutFile: parsed.stdoutFile ?? null,
+        stderrFile: parsed.stderrFile ?? null,
+    };
+    if (parsed.dryRun) {
+        if (parsed.json) {
+            console.log(JSON.stringify({ status: "skipped", dryRun: true, plan }));
+        }
+        else {
+            console.log(`[task:post] status=skipped`);
+            console.error(`[task:post] dry-run plan ${JSON.stringify(plan)}`);
+        }
+        return 0;
+    }
+    const committed = await (0, commitEffectResult_1.commitEffectResult)({
         runDir,
         effectId: parsed.effectId,
-        invocationKey: record.invocationKey,
-        dryRun: parsed.dryRun,
-        onStdoutChunk: streamers.onStdoutChunk,
-        onStderrChunk: streamers.onStderrChunk,
+        invocationKey,
+        result: parsed.taskStatus === "ok"
+            ? {
+                status: "ok",
+                value,
+                stdout,
+                stderr,
+                stdoutRef: parsed.stdoutRef,
+                stderrRef: parsed.stderrRef,
+                startedAt,
+                finishedAt,
+                metadata,
+            }
+            : {
+                status: "error",
+                error: errorPayload,
+                stdout,
+                stderr,
+                stdoutRef: parsed.stdoutRef,
+                stderrRef: parsed.stderrRef,
+                startedAt,
+                finishedAt,
+                metadata,
+            },
     });
-    const status = determineTaskStatus(result);
-    const stdoutRef = resolveTaskRunArtifactRef(runDir, result.committed?.stdoutRef, result.io.stdoutPath);
-    const stderrRef = resolveTaskRunArtifactRef(runDir, result.committed?.stderrRef, result.io.stderrPath);
-    const outputRef = resolveTaskRunArtifactRef(runDir, result.committed?.resultRef, result.io.outputJsonPath);
-    const planPayload = parsed.dryRun ? buildTaskRunPlanPayload(runDir, result) : null;
-    if (parsed.dryRun && planPayload) {
-        logTaskRunPlan(planPayload);
-    }
+    const stdoutRef = normalizeArtifactRef(runDir, committed.stdoutRef) ?? null;
+    const stderrRef = normalizeArtifactRef(runDir, committed.stderrRef) ?? null;
+    const resultRef = normalizeArtifactRef(runDir, committed.resultRef) ?? null;
     if (parsed.json) {
-        const payload = {
-            status,
-            committed: result.committed ?? null,
-            stdoutRef: stdoutRef ?? null,
-            stderrRef: stderrRef ?? null,
-            resultRef: outputRef ?? null,
-        };
-        console.log(JSON.stringify(payload));
+        console.log(JSON.stringify({
+            status: parsed.taskStatus,
+            committed,
+            stdoutRef,
+            stderrRef,
+            resultRef,
+        }));
     }
     else {
-        const parts = [`[task:run] status=${status}`];
+        const parts = [`[task:post] status=${parsed.taskStatus}`];
         if (stdoutRef)
             parts.push(`stdoutRef=${stdoutRef}`);
         if (stderrRef)
             parts.push(`stderrRef=${stderrRef}`);
-        if (outputRef)
-            parts.push(`resultRef=${outputRef}`);
+        if (resultRef)
+            parts.push(`resultRef=${resultRef}`);
         console.log(parts.join(" "));
     }
-    return status === "ok" || status === "skipped" ? 0 : 1;
+    return parsed.taskStatus === "ok" ? 0 : 1;
 }
 function parseNowOverride(nowOverride) {
     if (!nowOverride)
@@ -976,42 +1120,13 @@ async function loadTaskResultPreview(runDir, effectId, record) {
     const data = await (0, tasks_1.readTaskResult)(runDir, effectId, record.resultRef);
     return { result: data ?? undefined, large: false };
 }
-function buildTaskRunPlanPayload(runDir, result) {
-    if (!result.command) {
-        throw new Error("task runner did not supply command metadata for dry-run planning");
-    }
-    const normalize = (absolute) => toRunRelativePosix(runDir, absolute) ?? absolute;
-    return {
-        command: {
-            binary: normalize(result.command.binary),
-            args: result.command.args.map((arg, index) => (index === 0 ? normalize(arg) : arg)),
-            cwd: normalize(result.command.cwd),
-        },
-        io: {
-            input: normalize(result.io.inputJsonPath),
-            output: normalize(result.io.outputJsonPath),
-            stdout: normalize(result.io.stdoutPath),
-            stderr: normalize(result.io.stderrPath),
-        },
-    };
-}
-function logTaskRunPlan(plan) {
-    console.error(`[task:run] dry-run plan ${JSON.stringify(plan)}`);
-}
-function resolveTaskRunArtifactRef(runDir, committedRef, fallbackPath) {
-    return normalizeArtifactRef(runDir, committedRef) ?? toRunRelativePosix(runDir, fallbackPath);
-}
-function buildTaskRunStreamers(parsed) {
-    const stdoutTarget = parsed.json ? process.stderr : process.stdout;
-    const stderrTarget = process.stderr;
-    return {
-        onStdoutChunk: (chunk) => {
-            stdoutTarget.write(chunk);
-        },
-        onStderrChunk: (chunk) => {
-            stderrTarget.write(chunk);
-        },
-    };
+async function readStdinUtf8() {
+    return await new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", reject);
+    });
 }
 function deriveRunState(lastLifecycleEventType, pendingTotal) {
     if (lastLifecycleEventType === "RUN_COMPLETED")
@@ -1152,8 +1267,8 @@ function createBabysitterCli() {
                 if (parsed.command === "run:events") {
                     return await handleRunEvents(parsed);
                 }
-                if (parsed.command === "task:run") {
-                    return await handleTaskRun(parsed);
+                if (parsed.command === "task:post") {
+                    return await handleTaskPost(parsed);
                 }
                 if (parsed.command === "run:step") {
                     return await handleRunStep(parsed);

package/dist/index.d.ts

@@ -3,8 +3,6 @@ export * from "./runtime/types";
 export * from "./storage";
 export * from "./storage/types";
 export * from "./tasks";
-export * from "./runner";
-export * from "./cli/nodeTaskRunner";
 export * from "./cli/main";
 export * from "./testing";
 export * from "./hooks";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -19,8 +19,6 @@ __exportStar(require("./runtime/types"), exports);
 __exportStar(require("./storage"), exports);
 __exportStar(require("./storage/types"), exports);
 __exportStar(require("./tasks"), exports);
-__exportStar(require("./runner"), exports);
-__exportStar(require("./cli/nodeTaskRunner"), exports);
 __exportStar(require("./cli/main"), exports);
 __exportStar(require("./testing"), exports);
 __exportStar(require("./hooks"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/babysitter-sdk",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Storage and run-registry primitives for event-sourced babysitter workflows.",
   "license": "UNLICENSED",
   "type": "commonjs",

package/dist/cli/nodeTaskRunner.d.ts

@@ -1,16 +0,0 @@
-import { TaskDef } from "../tasks/types";
-import { RunNodeTaskOptions, RunNodeTaskResult } from "../runner/nodeRunner";
-import { CommitEffectResultArtifacts, ProcessLogger } from "../runtime/types";
-export interface CliRunNodeTaskOptions extends Omit<RunNodeTaskOptions, "task" | "hydration" | "baseEnv"> {
-    task?: TaskDef;
-    baseEnv?: NodeJS.ProcessEnv;
-    invocationKey?: string;
-    logger?: ProcessLogger;
-}
-export interface CliRunNodeTaskResult extends RunNodeTaskResult {
-    hydratedKeys: string[];
-    missingKeys: string[];
-    committed?: CommitEffectResultArtifacts;
-}
-export declare function runNodeTaskFromCli(options: CliRunNodeTaskOptions): Promise<CliRunNodeTaskResult>;
-//# sourceMappingURL=nodeTaskRunner.d.ts.map

package/dist/cli/nodeTaskRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeTaskRunner.d.ts","sourceRoot":"","sources":["../../src/cli/nodeTaskRunner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAiC,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAG9E,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,2BAA2B,CAAC;CACzC;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqEtG"}

package/dist/cli/nodeTaskRunner.js

@@ -1,85 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runNodeTaskFromCli = runNodeTaskFromCli;
-const path_1 = __importDefault(require("path"));
-const tasks_1 = require("../storage/tasks");
-const env_1 = require("../runner/env");
-const nodeRunner_1 = require("../runner/nodeRunner");
-const runtime_1 = require("../runtime/hooks/runtime");
-async function runNodeTaskFromCli(options) {
-    const task = options.task ?? (await loadTaskDefinition(options.runDir, options.effectId));
-    const hydration = (0, env_1.hydrateCliNodeTaskEnv)(task, {
-        cleanEnv: options.cleanEnv,
-        envOverrides: options.envOverrides,
-        baseEnv: options.baseEnv ?? process.env,
-    });
-    const runId = extractRunIdFromPath(options.runDir);
-    const taskStartTime = Date.now();
-    // Compute project root for hook calls (parent of .a5c dir where plugins/ is located)
-    // runDir is like: /path/to/project/.a5c/runs/<runId>
-    // So we need 3 levels up: runs -> .a5c -> project
-    const projectRoot = path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(options.runDir)));
-    // Call on-task-start hook
-    await (0, runtime_1.callRuntimeHook)("on-task-start", {
-        runId,
-        effectId: options.effectId,
-        taskId: extractInvocationKey(task) || options.effectId,
-        kind: "node",
-    }, {
-        cwd: projectRoot,
-        logger: options.logger,
-    });
-    const result = await (0, nodeRunner_1.runNodeTask)({
-        ...options,
-        task,
-        hydration,
-    });
-    let committed;
-    if (!options.dryRun) {
-        committed = await (0, nodeRunner_1.commitNodeResult)({
-            runDir: options.runDir,
-            effectId: options.effectId,
-            invocationKey: options.invocationKey ?? extractInvocationKey(task),
-            logger: options.logger,
-            result,
-        });
-    }
-    // Call on-task-complete hook
-    await (0, runtime_1.callRuntimeHook)("on-task-complete", {
-        runId,
-        effectId: options.effectId,
-        taskId: extractInvocationKey(task) || options.effectId,
-        status: result.exitCode === 0 ? "ok" : "error",
-        duration: Date.now() - taskStartTime,
-    }, {
-        cwd: projectRoot,
-        logger: options.logger,
-    });
-    return {
-        ...result,
-        hydratedKeys: hydration.hydratedKeys,
-        missingKeys: hydration.missingKeys,
-        committed,
-    };
-}
-async function loadTaskDefinition(runDir, effectId) {
-    const def = await (0, tasks_1.readTaskDefinition)(runDir, effectId);
-    if (!def) {
-        throw new Error(`Task definition for effect ${effectId} is missing`);
-    }
-    return def;
-}
-function extractInvocationKey(task) {
-    const raw = task?.invocationKey;
-    return typeof raw === "string" && raw.trim().length > 0 ? raw : undefined;
-}
-function extractRunIdFromPath(runDir) {
-    // Extract runId from path like .a5c/runs/<runId> or absolute path ending with runId
-    const normalized = path_1.default.normalize(runDir);
-    const parts = normalized.split(path_1.default.sep);
-    // Get the last non-empty part
-    return parts[parts.length - 1] || "unknown";
-}

package/dist/runner/env.d.ts

@@ -1,58 +0,0 @@
-import { JsonRecord } from "../storage/types";
-import { TaskDef } from "../tasks/types";
-export interface NodeEnvHydrationOptions {
-    /**
-     * Env map already present on the TaskDef (safe, non-secret values).
-     */
-    nodeEnv?: Record<string, string | undefined>;
-    /**
-     * Task metadata containing the `redactedEnvKeys` array emitted by the node helper.
-     */
-    metadata?: JsonRecord;
-    /**
-     * Source environment to inherit values from (defaults to `process.env`).
-     */
-    baseEnv?: NodeJS.ProcessEnv;
-    /**
-     * Explicit overrides (e.g., CLI --env) that should win over `baseEnv` for hydrated keys.
-     */
-    overrides?: Record<string, string | undefined>;
-    /**
-     * When false, the returned env starts empty (aside from sanitized + hydrated keys).
-     * Redacted keys may still be sourced from `baseEnv`/`overrides` even if inheritance is disabled.
-     */
-    inheritProcessEnv?: boolean;
-}
-export interface NodeEnvHydrationResult {
-    env: Record<string, string>;
-    hydratedKeys: string[];
-    missingKeys: string[];
-}
-export interface ResolveNodeTaskEnvOptions extends Omit<NodeEnvHydrationOptions, "nodeEnv" | "metadata"> {
-    /**
-     * Optional metadata override; defaults to task.metadata.
-     */
-    metadata?: JsonRecord;
-}
-export interface CliHydratedEnvOptions {
-    /**
-     * When true, start from an empty env (aside from overrides and hydrated keys).
-     */
-    cleanEnv?: boolean;
-    /**
-     * Additional env pairs provided via CLI flags.
-     */
-    envOverrides?: Record<string, string | undefined>;
-    /**
-      * Base env for hydration (defaults to process.env).
-      */
-    baseEnv?: NodeJS.ProcessEnv;
-}
-/**
- * Merge the sanitized TaskDef env map with any redacted keys pulled from the caller's environment.
- */
-export declare function hydrateNodeTaskEnv(options?: NodeEnvHydrationOptions): NodeEnvHydrationResult;
-export declare function resolveNodeTaskEnv(task: TaskDef, options?: ResolveNodeTaskEnvOptions): NodeEnvHydrationResult;
-export declare function hydrateCliNodeTaskEnv(task: TaskDef, options?: CliHydratedEnvOptions): NodeEnvHydrationResult;
-export declare function extractRedactedEnvKeys(metadata?: JsonRecord): string[];
-//# sourceMappingURL=env.d.ts.map

package/dist/runner/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/runner/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C;;OAEG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,uBAAuB,EAAE,SAAS,GAAG,UAAU,CAAC;IACtG;;OAEG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD;;QAEI;IACJ,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,uBAA4B,GAAG,sBAAsB,CAuChG;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CASjH;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,qBAA0B,GAAG,sBAAsB,CAMhH;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,CAqBtE"}

package/dist/runner/env.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hydrateNodeTaskEnv = hydrateNodeTaskEnv;
-exports.resolveNodeTaskEnv = resolveNodeTaskEnv;
-exports.hydrateCliNodeTaskEnv = hydrateCliNodeTaskEnv;
-exports.extractRedactedEnvKeys = extractRedactedEnvKeys;
-/**
- * Merge the sanitized TaskDef env map with any redacted keys pulled from the caller's environment.
- */
-function hydrateNodeTaskEnv(options = {}) {
-    const inherit = options.inheritProcessEnv !== false;
-    const baseEnv = options.baseEnv ?? process.env;
-    const env = inherit ? cloneProcessEnv(baseEnv) : {};
-    if (options.nodeEnv) {
-        for (const [key, value] of Object.entries(options.nodeEnv)) {
-            if (!key || value === undefined || value === null)
-                continue;
-            env[key] = String(value);
-        }
-    }
-    const overrides = normalizeOverrides(options.overrides);
-    const metadataKeys = extractRedactedEnvKeys(options.metadata);
-    const hydratedKeys = [];
-    const missingKeys = [];
-    for (const key of metadataKeys) {
-        const overrideValue = overrides[key];
-        const sourceValue = overrideValue !== undefined ? overrideValue : baseEnv?.[key];
-        if (sourceValue === undefined) {
-            delete env[key];
-            missingKeys.push(key);
-            continue;
-        }
-        env[key] = sourceValue;
-        hydratedKeys.push(key);
-    }
-    for (const [key, value] of Object.entries(overrides)) {
-        if (!key)
-            continue;
-        env[key] = value;
-    }
-    return {
-        env,
-        hydratedKeys,
-        missingKeys,
-    };
-}
-function resolveNodeTaskEnv(task, options = {}) {
-    const metadata = options.metadata ?? task.metadata;
-    return hydrateNodeTaskEnv({
-        nodeEnv: task.node?.env,
-        metadata,
-        baseEnv: options.baseEnv,
-        overrides: options.overrides,
-        inheritProcessEnv: options.inheritProcessEnv,
-    });
-}
-function hydrateCliNodeTaskEnv(task, options = {}) {
-    return resolveNodeTaskEnv(task, {
-        baseEnv: options.baseEnv,
-        overrides: options.envOverrides,
-        inheritProcessEnv: options.cleanEnv ? false : true,
-    });
-}
-function extractRedactedEnvKeys(metadata) {
-    if (!metadata) {
-        return [];
-    }
-    const value = metadata["redactedEnvKeys"];
-    const raw = Array.isArray(value) ? value : [];
-    const seen = new Set();
-    const keys = [];
-    for (const entry of raw) {
-        if (typeof entry !== "string")
-            continue;
-        const key = entry.trim();
-        if (!key || seen.has(key))
-            continue;
-        seen.add(key);
-        keys.push(key);
-    }
-    keys.sort((a, b) => {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    });
-    return keys;
-}
-function cloneProcessEnv(source) {
-    if (!source) {
-        return {};
-    }
-    const env = {};
-    for (const [key, value] of Object.entries(source)) {
-        if (!key || typeof value !== "string")
-            continue;
-        env[key] = value;
-    }
-    return env;
-}
-function normalizeOverrides(overrides) {
-    if (!overrides) {
-        return {};
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(overrides)) {
-        if (!key || value === undefined || value === null)
-            continue;
-        result[key] = String(value);
-    }
-    return result;
-}

package/dist/runner/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./env";
-export * from "./nodeRunner";
-//# sourceMappingURL=index.d.ts.map

package/dist/runner/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runner/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC"}

package/dist/runner/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./env"), exports);
-__exportStar(require("./nodeRunner"), exports);

package/dist/runner/nodeRunner.d.ts

@@ -1,60 +0,0 @@
-import { CommitEffectResultArtifacts, ProcessLogger } from "../runtime/types";
-import { TaskDef } from "../tasks/types";
-import { NodeEnvHydrationResult } from "./env";
-export interface NodeCommandDetails {
-    binary: string;
-    args: string[];
-    cwd: string;
-}
-export interface RunNodeTaskOptions {
-    runDir: string;
-    effectId: string;
-    task?: TaskDef;
-    workspaceRoot?: string;
-    nodeBinaryPath?: string;
-    envOverrides?: Record<string, string | undefined>;
-    cleanEnv?: boolean;
-    inheritProcessEnv?: boolean;
-    baseEnv?: NodeJS.ProcessEnv;
-    hydration?: NodeEnvHydrationResult;
-    timeoutMs?: number;
-    dryRun?: boolean;
-    onStdoutChunk?: (chunk: string) => void;
-    onStderrChunk?: (chunk: string) => void;
-}
-export interface RunNodeTaskResult {
-    task: TaskDef;
-    command: NodeCommandDetails;
-    stdout: string;
-    stderr: string;
-    exitCode: number | null;
-    signal: NodeJS.Signals | null;
-    timedOut: boolean;
-    startedAt: string;
-    finishedAt: string;
-    durationMs: number;
-    timeoutMs: number;
-    output?: unknown;
-    io: ResolvedIoPaths;
-    hydrated: NodeEnvHydrationResult;
-}
-export declare class NodeTaskRunnerError extends Error {
-    readonly code: string;
-    constructor(message: string, code: string);
-}
-export declare function runNodeTask(options: RunNodeTaskOptions): Promise<RunNodeTaskResult>;
-export interface CommitNodeResultOptions {
-    runDir: string;
-    effectId: string;
-    invocationKey?: string;
-    logger?: ProcessLogger;
-    result: RunNodeTaskResult;
-}
-export declare function commitNodeResult(options: CommitNodeResultOptions): Promise<CommitEffectResultArtifacts>;
-export interface ResolvedIoPaths {
-    inputJsonPath: string;
-    outputJsonPath: string;
-    stdoutPath: string;
-    stderrPath: string;
-}
-//# sourceMappingURL=nodeRunner.d.ts.map

package/dist/runner/nodeRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeRunner.d.ts","sourceRoot":"","sources":["../../src/runner/nodeRunner.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,OAAO,EAAe,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAsB,MAAM,OAAO,CAAC;AAInE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,kBAAkB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,EAAE,EAAE,eAAe,CAAC;IACpB,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aACC,IAAI,EAAE,MAAM;gBAA7C,OAAO,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAI1D;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAwGzF;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAmC7G;AA8CD,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/runner/nodeRunner.js

@@ -1,354 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeTaskRunnerError = void 0;
-exports.runNodeTask = runNodeTask;
-exports.commitNodeResult = commitNodeResult;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const tasks_1 = require("../storage/tasks");
-const commitEffectResult_1 = require("../runtime/commitEffectResult");
-const env_1 = require("./env");
-const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
-class NodeTaskRunnerError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.name = "NodeTaskRunnerError";
-    }
-}
-exports.NodeTaskRunnerError = NodeTaskRunnerError;
-async function runNodeTask(options) {
-    const task = options.task ?? (await loadNodeTask(options.runDir, options.effectId));
-    validateNodeTask(task, options.effectId);
-    const hydration = options.hydration ??
-        (0, env_1.resolveNodeTaskEnv)(task, {
-            baseEnv: options.baseEnv ?? process.env,
-            overrides: options.envOverrides,
-            inheritProcessEnv: options.cleanEnv ? false : options.inheritProcessEnv,
-        });
-    const entryPath = resolveWorkspacePath(options.workspaceRoot ?? options.runDir, task.node?.entry, "node.entry", options.effectId);
-    const cwdPath = resolveWorkspacePath(options.workspaceRoot ?? options.runDir, task.node?.cwd, "node.cwd", options.effectId);
-    const args = task.node?.args ? [...task.node.args] : [];
-    const timeoutMs = typeof options.timeoutMs === "number" ? options.timeoutMs : task.node?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const commandDetails = {
-        binary: options.nodeBinaryPath ?? process.execPath,
-        args: [entryPath, ...args],
-        cwd: cwdPath ?? options.runDir,
-    };
-    const envForProcess = { ...hydration.env };
-    const ioPaths = applyIoEnv(envForProcess, options.runDir, options.effectId, task.io);
-    if (options.dryRun) {
-        const nowIso = new Date().toISOString();
-        return {
-            task,
-            stdout: "",
-            stderr: "",
-            exitCode: null,
-            signal: null,
-            timedOut: false,
-            startedAt: nowIso,
-            finishedAt: nowIso,
-            durationMs: 0,
-            timeoutMs,
-            command: commandDetails,
-            io: ioPaths,
-            hydrated: hydration,
-        };
-    }
-    await ensureParentDir(ioPaths.inputJsonPath);
-    await ensureParentDir(ioPaths.outputJsonPath);
-    await ensureParentDir(ioPaths.stdoutPath);
-    await ensureParentDir(ioPaths.stderrPath);
-    await stageTaskInputs({
-        task,
-        runDir: options.runDir,
-        effectId: options.effectId,
-        inputJsonPath: ioPaths.inputJsonPath,
-    });
-    const startedAtMs = Date.now();
-    const startedAtIso = new Date(startedAtMs).toISOString();
-    const runResult = await spawnNodeProcess({
-        command: commandDetails.binary,
-        args: commandDetails.args,
-        cwd: commandDetails.cwd,
-        env: envForProcess,
-        timeoutMs,
-        stdoutPath: ioPaths.stdoutPath,
-        stderrPath: ioPaths.stderrPath,
-        onStdoutChunk: options.onStdoutChunk,
-        onStderrChunk: options.onStderrChunk,
-    });
-    const finishedAtMs = Date.now();
-    const finishedAtIso = new Date(finishedAtMs).toISOString();
-    let parsedOutput;
-    parsedOutput = await readOptionalJson(ioPaths.outputJsonPath);
-    return {
-        task,
-        stdout: runResult.stdout,
-        stderr: runResult.stderr,
-        exitCode: runResult.exitCode,
-        signal: runResult.signal,
-        timedOut: runResult.timedOut,
-        startedAt: startedAtIso,
-        finishedAt: finishedAtIso,
-        durationMs: finishedAtMs - startedAtMs,
-        timeoutMs,
-        output: parsedOutput,
-        command: commandDetails,
-        io: ioPaths,
-        hydrated: hydration,
-    };
-}
-async function commitNodeResult(options) {
-    const { runDir, effectId, invocationKey, logger, result } = options;
-    const stdoutRef = toRunRelativePosix(runDir, result.io.stdoutPath);
-    const stderrRef = toRunRelativePosix(runDir, result.io.stderrPath);
-    const outputJsonRef = toRunRelativePosix(runDir, result.io.outputJsonPath);
-    const status = !result.timedOut && (result.exitCode === null || result.exitCode === 0) ? "ok" : "error";
-    const metadata = {
-        durationMs: result.durationMs,
-        timeoutMs: result.timeoutMs,
-        exitCode: result.exitCode,
-        signal: result.signal ?? undefined,
-        timedOut: result.timedOut,
-        outputJsonRef,
-    };
-    return (0, commitEffectResult_1.commitEffectResult)({
-        runDir,
-        effectId,
-        invocationKey,
-        logger,
-        result: {
-            status,
-            value: status === "ok" ? result.output : undefined,
-            error: status === "error" ? buildNodeTaskErrorPayload(result, outputJsonRef) : undefined,
-            stdout: result.stdout,
-            stderr: result.stderr,
-            stdoutRef,
-            stderrRef,
-            startedAt: result.startedAt,
-            finishedAt: result.finishedAt,
-            metadata,
-        },
-    });
-}
-async function loadNodeTask(runDir, effectId) {
-    const json = await (0, tasks_1.readTaskDefinition)(runDir, effectId);
-    if (!json) {
-        throw new NodeTaskRunnerError(`Task definition for effect ${effectId} is missing`, "missing_task");
-    }
-    return json;
-}
-function validateNodeTask(task, effectId) {
-    if (task.kind !== "node" || !task.node) {
-        throw new NodeTaskRunnerError(`Effect ${effectId} is not a node task`, "invalid_task_kind");
-    }
-    if (!task.node.entry || typeof task.node.entry !== "string") {
-        throw new NodeTaskRunnerError(`Effect ${effectId} node.entry is missing`, "missing_entry");
-    }
-}
-function resolveWorkspacePath(baseDir, value, field, effectId) {
-    if (!value) {
-        return undefined;
-    }
-    const normalized = value.replace(/\\/g, "/");
-    const isAbsolute = path_1.default.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized);
-    const resolved = isAbsolute ? normalized : path_1.default.join(baseDir, ...normalized.split("/"));
-    if (!resolved) {
-        throw new NodeTaskRunnerError(`Effect ${effectId} has an invalid ${field}`, "invalid_path");
-    }
-    return path_1.default.normalize(resolved);
-}
-function resolveRunRelativePath(runDir, relative) {
-    if (!relative)
-        return undefined;
-    if (path_1.default.isAbsolute(relative) || /^[A-Za-z]:[\\/]/.test(relative)) {
-        return path_1.default.normalize(relative);
-    }
-    const normalized = relative.replace(/\\/g, "/");
-    return path_1.default.join(runDir, ...normalized.split("/"));
-}
-function applyIoEnv(env, runDir, effectId, io) {
-    const normalizedIo = withDefaultIoHints(effectId, io);
-    const inputJsonPath = resolveRunRelativePath(runDir, normalizedIo.inputJsonPath);
-    const outputJsonPath = resolveRunRelativePath(runDir, normalizedIo.outputJsonPath);
-    const stdoutPath = resolveRunRelativePath(runDir, normalizedIo.stdoutPath);
-    const stderrPath = resolveRunRelativePath(runDir, normalizedIo.stderrPath);
-    env.BABYSITTER_INPUT_JSON = inputJsonPath;
-    env.BABYSITTER_OUTPUT_JSON = outputJsonPath;
-    env.BABYSITTER_STDOUT_PATH = stdoutPath;
-    env.BABYSITTER_STDERR_PATH = stderrPath;
-    env.BABYSITTER_EFFECT_ID = effectId;
-    return { inputJsonPath, outputJsonPath, stdoutPath, stderrPath };
-}
-async function readOptionalJson(filePath) {
-    try {
-        const contents = await fs_1.promises.readFile(filePath, "utf8");
-        if (!contents.trim()) {
-            return undefined;
-        }
-        return JSON.parse(contents);
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === "ENOENT") {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function withDefaultIoHints(effectId, io) {
-    const defaulted = {
-        inputJsonPath: `tasks/${effectId}/inputs.json`,
-        outputJsonPath: `tasks/${effectId}/result.json`,
-        stdoutPath: `tasks/${effectId}/stdout.log`,
-        stderrPath: `tasks/${effectId}/stderr.log`,
-    };
-    return {
-        inputJsonPath: typeof io?.inputJsonPath === "string" && io.inputJsonPath.trim().length > 0
-            ? io.inputJsonPath
-            : defaulted.inputJsonPath,
-        outputJsonPath: typeof io?.outputJsonPath === "string" && io.outputJsonPath.trim().length > 0
-            ? io.outputJsonPath
-            : defaulted.outputJsonPath,
-        stdoutPath: typeof io?.stdoutPath === "string" && io.stdoutPath.trim().length > 0 ? io.stdoutPath : defaulted.stdoutPath,
-        stderrPath: typeof io?.stderrPath === "string" && io.stderrPath.trim().length > 0 ? io.stderrPath : defaulted.stderrPath,
-    };
-}
-async function spawnNodeProcess(options) {
-    return new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(options.command, options.args, {
-            cwd: options.cwd,
-            env: options.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const stdoutStream = (0, fs_1.createWriteStream)(options.stdoutPath, { flags: "w" });
-        const stderrStream = (0, fs_1.createWriteStream)(options.stderrPath, { flags: "w" });
-        let streamsClosed = false;
-        const finishStreams = () => {
-            if (streamsClosed)
-                return;
-            streamsClosed = true;
-            stdoutStream.end();
-            stderrStream.end();
-        };
-        let settled = false;
-        const finishWithError = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            finishStreams();
-            reject(error);
-        };
-        const finishWithSuccess = (payload) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            finishStreams();
-            resolve(payload);
-        };
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        child.stdout?.setEncoding("utf8");
-        child.stdout?.on("data", (chunk) => {
-            stdout += chunk;
-            stdoutStream.write(chunk);
-            options.onStdoutChunk?.(chunk);
-        });
-        child.stderr?.setEncoding("utf8");
-        child.stderr?.on("data", (chunk) => {
-            stderr += chunk;
-            stderrStream.write(chunk);
-            options.onStderrChunk?.(chunk);
-        });
-        stdoutStream.on("error", (error) => {
-            child.kill();
-            finishWithError(new NodeTaskRunnerError(`Failed to write stdout log: ${error.message}`, "stdout_log_error"));
-        });
-        stderrStream.on("error", (error) => {
-            child.kill();
-            finishWithError(new NodeTaskRunnerError(`Failed to write stderr log: ${error.message}`, "stderr_log_error"));
-        });
-        const timeoutHandle = options.timeoutMs > 0
-            ? setTimeout(() => {
-                timedOut = true;
-                child.kill();
-            }, options.timeoutMs)
-            : undefined;
-        child.on("error", (error) => {
-            finishWithError(new NodeTaskRunnerError(`Failed to spawn node task: ${error.message}`, "spawn_error"));
-        });
-        child.on("close", (code, signal) => {
-            finishWithSuccess({ stdout, stderr, exitCode: code, signal, timedOut });
-        });
-    });
-}
-async function ensureParentDir(filePath) {
-    await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
-}
-async function stageTaskInputs(options) {
-    const inlineInputs = options.task.inputs;
-    const hasInlineInputs = inlineInputs !== undefined;
-    const maybeInputsRef = options.task.inputsRef;
-    const inputsRef = typeof maybeInputsRef === "string" ? maybeInputsRef : undefined;
-    if (!hasInlineInputs && !inputsRef) {
-        return;
-    }
-    const payload = hasInlineInputs && inlineInputs !== undefined
-        ? inlineInputs
-        : await readInputsRefValue(options.runDir, inputsRef, options.effectId);
-    await fs_1.promises.writeFile(options.inputJsonPath, JSON.stringify(payload, null, 2) + "\n", "utf8");
-}
-async function readInputsRefValue(runDir, ref, effectId) {
-    const resolved = resolveRunRelativePath(runDir, ref);
-    if (!resolved) {
-        throw new NodeTaskRunnerError(`Effect ${effectId} has an invalid inputsRef path`, "invalid_inputs_ref");
-    }
-    try {
-        const contents = await fs_1.promises.readFile(resolved, "utf8");
-        if (!contents.trim()) {
-            throw new NodeTaskRunnerError(`Effect ${effectId} inputsRef file is empty`, "empty_inputs_ref");
-        }
-        return JSON.parse(contents);
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === "ENOENT") {
-            throw new NodeTaskRunnerError(`Effect ${effectId} inputsRef file is missing`, "missing_inputs_ref");
-        }
-        throw error;
-    }
-}
-function buildNodeTaskErrorPayload(result, outputJsonRef) {
-    const base = result.exitCode === null
-        ? "Node task exited without a code"
-        : `Node task exited with code ${result.exitCode}${result.signal ? ` (signal ${result.signal})` : ""}`;
-    const message = result.timedOut ? `Node task timed out after ${result.timeoutMs}ms` : base;
-    return {
-        message,
-        exitCode: result.exitCode,
-        signal: result.signal ?? undefined,
-        timedOut: result.timedOut,
-        stdout: result.stdout,
-        stderr: result.stderr,
-        outputJsonRef,
-    };
-}
-function toRunRelativePosix(runDir, absolutePath) {
-    if (!absolutePath)
-        return undefined;
-    const relative = path_1.default.relative(runDir, absolutePath);
-    if (!relative || relative.startsWith(".."))
-        return undefined;
-    return relative.replace(/\\/g, "/");
-}