@glubean/runner 0.5.0 → 0.7.0

package/dist/generate_summary.js

@@ -18,6 +18,8 @@ export function generateSummary(events) {
     let schemaValidationTotal = 0;
     let schemaValidationFailed = 0;
     let schemaValidationWarnings = 0;
+    const nodeVerdicts = [];
+    const lastIndexByNodeId = new Map();
     for (const e of events) {
         switch (e.type) {
             case "assertion":
@@ -42,6 +44,23 @@ export function generateSummary(events) {
                 else if (e.status === "skipped")
                     stepSkipped++;
                 break;
+            case "node_end": {
+                // A group bracket is DISPLAY-ONLY (phase4 §2): its members each emit
+                // their own node_end — counting the container would double-count and
+                // dilute grades. Render layers still see the bracket on the timeline.
+                if (e.kind === "group")
+                    break;
+                const verdict = { status: e.status, grade: e.grade };
+                const retryOfPrevious = e.attempt !== undefined && e.attempt > 1 && lastIndexByNodeId.has(e.nodeId);
+                if (retryOfPrevious) {
+                    nodeVerdicts[lastIndexByNodeId.get(e.nodeId)] = verdict;
+                }
+                else {
+                    lastIndexByNodeId.set(e.nodeId, nodeVerdicts.length);
+                    nodeVerdicts.push(verdict);
+                }
+                break;
+            }
             case "warning":
                 warningTotal++;
                 if (!e.condition)
@@ -64,12 +83,36 @@ export function generateSummary(events) {
     const httpErrorRate = httpRequestTotal > 0
         ? Math.round((httpErrorTotal / httpRequestTotal) * 10000) / 10000
         : 0;
+    // Resolve per-node verdicts (retry chains already folded above).
+    let nodePassed = 0;
+    let nodeFailed = 0;
+    let nodeSkipped = 0;
+    const nodeGrades = { full: 0, partial: 0, trace: 0, opaque: 0 };
+    for (const verdict of nodeVerdicts) {
+        if (verdict.status === "passed")
+            nodePassed++;
+        else if (verdict.status === "failed")
+            nodeFailed++;
+        else
+            nodeSkipped++;
+        nodeGrades[verdict.grade]++;
+    }
+    const nodeTotal = nodeVerdicts.length;
     // Derive success:
     // 1. Any error/status event → failure (crash, timeout, process exit)
     //    These event types are not in TimelineEvent but may be present
     //    when callers pass ExecutionEvent[] or GlubeanEvent[] via `as any`.
     // 2. If step_end events exist, use them as authority
-    // 3. Otherwise fall back to assertion results
+    // 3. Else if node_end events exist (vNext workflow): node verdicts AND
+    //    assertion counts must BOTH be clean. Verdicts catch what assertions
+    //    can't (a thrown-node failure leaves no failed assertion); assertions
+    //    catch what verdicts can't (a setup soft-failure skips every node, so
+    //    no node is "failed" — and the wrapping test's error event is NOT in
+    //    the timeline array, so a recomputed summary would otherwise pass).
+    //    Retry noise can't poison this: a quarantined attempt's failed asserts
+    //    never reach the host timeline (sdk S2.4c) — every failed assertion
+    //    present is verdict-relevant.
+    // 4. Otherwise fall back to assertion results
     let success;
     const hasHardFailure = events.some((e) => {
         const t = e.type;
@@ -98,6 +141,9 @@ export function generateSummary(events) {
         if (hasStepEnds) {
             success = stepFailed === 0;
         }
+        else if (nodeTotal > 0) {
+            success = nodeFailed === 0 && assertionFailed === 0;
+        }
         else {
             success = assertionFailed === 0;
         }
@@ -112,6 +158,11 @@ export function generateSummary(events) {
         stepPassed,
         stepFailed,
         stepSkipped,
+        nodeTotal,
+        nodePassed,
+        nodeFailed,
+        nodeSkipped,
+        nodeGrades,
         warningTotal,
         warningTriggered,
         schemaValidationTotal,

package/dist/generate_summary.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate_summary.js","sourceRoot":"","sources":["../src/generate_summary.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generate_summary.js","sourceRoot":"","sources":["../src/generate_summary.ts"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,MAAuB;IACrD,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,IAAI,qBAAqB,GAAG,CAAC,CAAC;IAC9B,IAAI,sBAAsB,GAAG,CAAC,CAAC;IAC/B,IAAI,wBAAwB,GAAG,CAAC,CAAC;IAWjC,MAAM,YAAY,GAAkB,EAAE,CAAC;IACvC,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEpD,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;YACf,KAAK,WAAW;gBACd,cAAc,EAAE,CAAC;gBACjB,IAAI,CAAC,CAAC,CAAC,MAAM;oBAAE,eAAe,EAAE,CAAC;gBACjC,MAAM;YAER,KAAK,OAAO;gBACV,gBAAgB,EAAE,CAAC;gBACnB,IAAI,CAAC,CAAC,IAAI,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;oBAC/D,MAAM,MAAM,GAAI,CAAC,CAAC,IAA2B,CAAC,MAAM,CAAC;oBACrD,IAAI,MAAM,IAAI,GAAG;wBAAE,cAAc,EAAE,CAAC;gBACtC,CAAC;gBACD,MAAM;YAER,KAAK,UAAU;gBACb,SAAS,EAAE,CAAC;gBACZ,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ;oBAAE,UAAU,EAAE,CAAC;qBACnC,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ;oBAAE,UAAU,EAAE,CAAC;qBACxC,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS;oBAAE,WAAW,EAAE,CAAC;gBAC/C,MAAM;YAER,KAAK,UAAU,CAAC,CAAC,CAAC;gBAChB,qEAAqE;gBACrE,qEAAqE;gBACrE,sEAAsE;gBACtE,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO;oBAAE,MAAM;gBAC9B,MAAM,OAAO,GAAgB,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;gBAClE,MAAM,eAAe,GACnB,CAAC,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC9E,IAAI,eAAe,EAAE,CAAC;oBACpB,YAAY,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAE,CAAC,GAAG,OAAO,CAAC;gBAC3D,CAAC;qBAAM,CAAC;oBACN,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;oBACrD,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC7B,CAAC;gBACD,MAAM;YACR,CAAC;YAGD,KAAK,SAAS;gBACZ,YAAY,EAAE,CAAC;gBACf,IAAI,CAAC,CAAC,CAAC,SAAS;oBAAE,gBAAgB,EAAE,CAAC;gBACrC,MAAM;YAER,KAAK,mBAAmB;gBACtB,qBAAqB,EAAE,CAAC;gBACxB,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;oBACf,IAAI,CAAC,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;wBAC1B,wBAAwB,EAAE,CAAC;oBAC7B,CAAC;yBAAM,CAAC;wBACN,8BAA8B;wBAC9B,sBAAsB,EAAE,CAAC;oBAC3B,CAAC;gBACH,CAAC;gBACD,MAAM;QACV,CAAC;IACH,CAAC;IAED,MAAM,aAAa,GACjB,gBAAgB,GAAG,CAAC;QAClB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,GAAG,gBAAgB,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK;QACjE,CAAC,CAAC,CAAC,CAAC;IAER,iEAAiE;IACjE,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,UAAU,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IAChE,KAAK,MAAM,OAAO,IAAI,YAAY,EAAE,CAAC;QACnC,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ;YAAE,UAAU,EAAE,CAAC;aACzC,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ;YAAE,UAAU,EAAE,CAAC;;YAC9C,WAAW,EAAE,CAAC;QACnB,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;IAC9B,CAAC;IACD,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC;IAEtC,kBAAkB;IAClB,qEAAqE;IACrE,mEAAmE;IACnE,wEAAwE;IACxE,qDAAqD;IACrD,uEAAuE;IACvE,yEAAyE;IACzE,0EAA0E;IAC1E,0EAA0E;IAC1E,yEAAyE;IACzE,wEAAwE;IACxE,2EAA2E;IAC3E,wEAAwE;IACxE,kCAAkC;IAClC,8CAA8C;IAC9C,IAAI,OAAgB,CAAC;IACrB,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QACvC,MAAM,CAAC,GAAI,CAAsB,CAAC,IAAI,CAAC;QACvC,IAAI,CAAC,KAAK,OAAO;YAAE,OAAO,IAAI,CAAC;QAC/B,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;YACnB,MAAM,CAAC,GAAI,CAAyB,CAAC,MAAM,CAAC;YAC5C,OAAO,CAAC,KAAK,WAAW,IAAI,CAAC,KAAK,SAAS,CAAC;QAC9C,CAAC;QACD,2EAA2E;QAC3E,oEAAoE;QACpE,2EAA2E;QAC3E,4BAA4B;QAC5B,IAAI,CAAC,KAAK,QAAQ;YAAE,OAAQ,CAAwB,CAAC,KAAK,KAAK,SAAS,CAAC;QACzE,0EAA0E;QAC1E,IAAI,CAAC,KAAK,MAAM;YAAE,OAAQ,CAAwB,CAAC,KAAK,KAAK,SAAS,CAAC;QACvE,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;IACH,IAAI,cAAc,EAAE,CAAC;QACnB,OAAO,GAAG,KAAK,CAAC;IAClB,CAAC;SAAM,CAAC;QACN,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;QAC9D,IAAI,WAAW,EAAE,CAAC;YAChB,OAAO,GAAG,UAAU,KAAK,CAAC,CAAC;QAC7B,CAAC;aAAM,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,GAAG,UAAU,KAAK,CAAC,IAAI,eAAe,KAAK,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,eAAe,KAAK,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED,OAAO;QACL,cAAc;QACd,eAAe;QACf,gBAAgB;QAChB,cAAc;QACd,aAAa;QACb,SAAS;QACT,UAAU;QACV,UAAU;QACV,WAAW;QACX,SAAS;QACT,UAAU;QACV,UAAU;QACV,WAAW;QACX,UAAU;QACV,YAAY;QACZ,gBAAgB;QAChB,qBAAqB;QACrB,sBAAsB;QACtB,wBAAwB;QACxB,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/harness.js

@@ -8,9 +8,14 @@
 import { parseArgs } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { inferJsonSchema, truncateDeep } from "./schema_inference.js";
+import { USE_ENGINE, createEngineCore, runViaEngine, engineRoutesId } from "./engine-bridge.js";
 import { bootstrap } from "./bootstrap.js";
 import { loadProjectOverlays } from "@glubean/scanner";
 import { setRuntime, setExplicitInput, setBootstrapInput, setForceStandalone, } from "@glubean/sdk/internal";
+// Workflow executor — now node-only and owned by this package (plan 0007). The host
+// drives a built workflow via runWorkflow (invocation inversion) and attributes inline
+// ctx.http traces to the active node scope via __activeWorkflowNodeCtx (the ALS rebind).
+import { runWorkflow, WorkflowPhaseFailedError, __activeWorkflowNodeCtx, } from "./workflow/execute.js";
 import ky from "ky";
 import { isTestBranchStep, isTestPollStep } from "@glubean/sdk";
 import { Expectation } from "@glubean/sdk/expect";
@@ -189,14 +194,136 @@ function incrAssertions(passed) {
  * Use this for all test-scoped event output to ensure concurrent events can be
  * attributed to the correct test.
  */
+/** Events that STEER THE PARENT while the test is still running — the
+ * executor re-arms the subprocess timeout on `timeout_update`, and
+ * ProjectRunner forwards `session:set` to sibling files. Holding them in the
+ * parallel buffer until the test finishes would defeat them (a long test
+ * would be killed at the OLD deadline — codex S2.12 R24 P2), so they bypass
+ * buffering. Out-of-order arrival is fine: both are keyed/merged by the
+ * parent, not attributed to a contiguous test block. */
+const CONTROL_EVENT_TYPES = new Set(["timeout_update", "session:set"]);
 function emitEvent(event) {
     const trc = currentTestCtx();
-    if (trc) {
-        console.log(JSON.stringify({ ...event, testId: trc.testId }));
+    const json = JSON.stringify(trc ? { ...event, testId: trc.testId } : event);
+    if (CONTROL_EVENT_TYPES.has(event.type)) {
+        console.log(json);
+        return;
     }
-    else {
-        console.log(JSON.stringify(event));
+    writeEventLine(json);
+}
+// ── Parallel-batch event buffering (codex S2.12 R22 P1) ─────────────────────
+// Under batchConcurrency > 1, tests run concurrently and their stdout events
+// would interleave — downstream collectors (CLI render, result JSON) keep
+// per-test state that assumes each test's start..status block is CONTIGUOUS.
+// Each parallel task runs inside this ALS with its own line buffer; the task
+// flushes the whole buffer atomically (sync loop — no awaits) when it
+// finishes. Sequential runs never enter the ALS: zero behavior change.
+const parallelEventBuffer = new AsyncLocalStorage();
+function writeEventLine(json) {
+    const buf = parallelEventBuffer.getStore();
+    if (buf)
+        buf.push(json);
+    else
+        console.log(json);
+}
+/**
+ * Write a wire event produced by the engine path (runner-on-engine, plan 0005).
+ * Mirrors emitEvent's control-event bypass, but the event already carries its
+ * testId (the engine path runs outside the testContext ALS, so testId is sourced
+ * from the engine event's own id, not currentTestCtx()).
+ */
+function emitEngineWire(ev) {
+    // Mirror the legacy ctx.session.set: update the subprocess-local sessionData so
+    // sibling tests in this process see it (batch mode), in addition to forwarding
+    // the control event to the parent (codex P2).
+    if (ev.type === "session:set") {
+        sessionData[ev.key] = ev.value;
     }
+    const json = JSON.stringify(ev);
+    if (CONTROL_EVENT_TYPES.has(ev.type)) {
+        console.log(json);
+        return;
+    }
+    writeEventLine(json);
+}
+// ── vNext workflow per-node evidence → first-class timeline events ──────────
+// The SDK's workflow executor emits node evidence as namespaced GlubeanEvents
+// over ctx.event (workflow:node_start / node_end / poll_attempt — see
+// sdk/src/workflow/execute.ts §17 #9). The harness unwraps the three known
+// shapes into first-class timeline events so node id + grade reach
+// generateSummary and the Cloud payload directly (§17 #9/#10 consumption).
+// Anything else — other `workflow:*` names, malformed payloads — returns null
+// and stays a generic pass-through `event` (a misshapen payload must not mint
+// a misshapen first-class event).
+const NODE_STATUSES = new Set(["passed", "failed", "skipped"]);
+const NODE_GRADES = new Set(["full", "partial", "trace", "opaque"]);
+const POLL_OUTCOMES = new Set(["satisfied", "probe", "failed"]);
+function workflowEventToTimeline(ev) {
+    if (ev.type !== "workflow:node_start" &&
+        ev.type !== "workflow:node_end" &&
+        ev.type !== "workflow:poll_attempt" &&
+        ev.type !== "workflow:branch_decision") {
+        return null;
+    }
+    const d = ev.data;
+    if (!d || typeof d.nodeId !== "string")
+        return null;
+    const attemptFields = {
+        ...(typeof d.attempt === "number" ? { attempt: d.attempt } : {}),
+        ...(typeof d.attempts === "number" ? { attempts: d.attempts } : {}),
+    };
+    if (ev.type === "workflow:node_start") {
+        return {
+            type: "node_start",
+            nodeId: d.nodeId,
+            kind: typeof d.kind === "string" ? d.kind : "unknown",
+            name: typeof d.name === "string" ? d.name : d.nodeId,
+            ...attemptFields,
+        };
+    }
+    if (ev.type === "workflow:node_end") {
+        if (typeof d.status !== "string" || !NODE_STATUSES.has(d.status))
+            return null;
+        if (typeof d.grade !== "string" || !NODE_GRADES.has(d.grade))
+            return null;
+        return {
+            type: "node_end",
+            nodeId: d.nodeId,
+            kind: typeof d.kind === "string" ? d.kind : "unknown",
+            name: typeof d.name === "string" ? d.name : d.nodeId,
+            status: d.status,
+            grade: d.grade,
+            durationMs: typeof d.durationMs === "number" ? d.durationMs : 0,
+            ...(typeof d.error === "string" ? { error: d.error } : {}),
+            ...attemptFields,
+        };
+    }
+    if (ev.type === "workflow:poll_attempt") {
+        if (typeof d.attempt !== "number" ||
+            typeof d.outcome !== "string" ||
+            !POLL_OUTCOMES.has(d.outcome)) {
+            return null;
+        }
+        return {
+            type: "poll_attempt",
+            nodeId: d.nodeId,
+            attempt: d.attempt,
+            outcome: d.outcome,
+            durationMs: typeof d.durationMs === "number" ? d.durationMs : 0,
+        };
+    }
+    // workflow:branch_decision (addendum §9 — branch/switch/route taken case)
+    if ((d.mode !== "predicate" && d.mode !== "value") ||
+        (typeof d.takenIndex !== "number" && d.takenIndex !== "default")) {
+        return null;
+    }
+    return {
+        type: "branch_decision",
+        nodeId: d.nodeId,
+        mode: d.mode,
+        takenIndex: d.takenIndex,
+        ...(typeof d.takenLabel === "string" ? { takenLabel: d.takenLabel } : {}),
+    };
 }
 /**
  * Start monitoring memory usage.
@@ -552,8 +679,18 @@ const ctx = {
             ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
         });
     },
-    // Structured event emission
+    // Structured event emission. The vNext workflow executor's per-node
+    // evidence (§17 #9) rides this channel as namespaced GlubeanEvents — the
+    // harness UNWRAPS the three known types into first-class timeline events
+    // (node id + grade reach generateSummary / the Cloud payload directly,
+    // not as a double-wrapped custom blob). Any other type — including other
+    // `workflow:*` names — stays a generic pass-through event.
     event: (ev) => {
+        const firstClass = workflowEventToTimeline(ev);
+        if (firstClass) {
+            emitEvent(firstClass);
+            return;
+        }
         emitEvent({
             type: "event",
             data: ev,
@@ -657,6 +794,24 @@ const ctx = {
     },
 };
 const requestTraceMap = new WeakMap();
+// Capture the outgoing request body for full-trace mode. ky 2 no longer exposes
+// `options.json`, so read it off a clone of the Request (parsed if JSON).
+async function captureRequestBody(request) {
+    try {
+        const text = await request.clone().text();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Max serialized body size (chars) to include in trace events. */
 const TRACE_BODY_MAX_SIZE = 1_048_576; // 1MB
 /**
@@ -722,18 +877,18 @@ const kyInstance = ky.create({
     retry: 0,
     hooks: {
         beforeRequest: [
-            (_request, options) => {
-                requestTraceMap.set(options, {
+            async ({ request, options }) => {
+                requestTraceMap.set(options.context, {
                     startTime: performance.now(),
-                    body: emitFullTrace
-                        ? (options.json ?? options.body ?? undefined)
-                        : undefined,
+                    body: emitFullTrace ? await captureRequestBody(request) : undefined,
                 });
             },
         ],
         afterResponse: [
-            async (request, _options, response) => {
-                const trace = requestTraceMap.get(_options);
+            async ({ request, options, response }) => {
+                // `request` here is the final (possibly hook-replaced) request — correct
+                // for the trace target; the trace state is keyed by the stable context.
+                const trace = requestTraceMap.get(options.context);
                 const duration = Math.round(performance.now() - (trace?.startTime ?? performance.now()));
                 // Increment HTTP counters for summary
                 {
@@ -807,17 +962,22 @@ const kyInstance = ky.create({
                     }
                     // Per-request state is on the options object; no global cleanup needed.
                 }
-                ctx.trace(traceData);
+                // Attribute to the active workflow node's scope when one is executing
+                // (the SDK's ctx.http rebind, §17 #10/#12): inline HTTP inside a
+                // workflow node promotes its grade and obeys the late-evidence
+                // quarantine. Outside a workflow node this is the closure ctx as ever.
+                const sink = __activeWorkflowNodeCtx() ?? ctx;
+                sink.trace(traceData);
                 // Auto-metric for response time
                 try {
                     const pathname = new URL(request.url).pathname;
-                    ctx.metric("http_duration_ms", duration, {
+                    sink.metric("http_duration_ms", duration, {
                         unit: "ms",
                         tags: { method: request.method, path: pathname },
                     });
                 }
                 catch {
-                    ctx.metric("http_duration_ms", duration, {
+                    sink.metric("http_duration_ms", duration, {
                         unit: "ms",
                         tags: { method: request.method },
                     });
@@ -844,6 +1004,13 @@ function normalizeOptions(options) {
     if (!options)
         return options;
     const normalized = { ...options };
+    // ky 2 renamed `prefixUrl` → `prefix` (with the same join semantics we rely on
+    // for "users" / "/users"). Glubean keeps `prefixUrl` as its public option and
+    // translates here at the ky boundary (codex ky2 P2-5; not `baseUrl`).
+    if (normalized.prefixUrl !== undefined) {
+        normalized.prefix = normalized.prefixUrl;
+        delete normalized.prefixUrl;
+    }
     // Remove empty searchParams so ky doesn't append a bare '?'
     if (normalized.searchParams != null) {
         if (normalized.searchParams instanceof URLSearchParams) {
@@ -947,7 +1114,7 @@ function wrapKy(instance, label = "base") {
         const responseHeadersSchema = normalized?.schema?.responseHeaders;
         if (responseHeadersSchema) {
             const { schema, severity } = resolveSchemaEntry(responseHeadersSchema);
-            const headersHook = (_req, _opts, response) => {
+            const headersHook = ({ response }) => {
                 const headersObj = normalizeHeadersForValidation(response.headers);
                 runSchemaValidation(headersObj, schema, "response headers", severity);
             };
@@ -1007,6 +1174,28 @@ function withEnvFallback(explicit) {
         },
     });
 }
+// runner-on-engine (plan 0005): when GLUBEAN_USE_ENGINE=1 the engine drives the
+// run-loop (executeNewTest delegates to RunnerCore). Construct it BEFORE
+// setRuntime so RunnerCore's ALS carrier is the one the SDK runtime fallback gets
+// set on — module-load configure() and the engine's runWithRuntime() then share a
+// single carrier (plan 0005 §接缝设计 / codex P1-5). Default OFF → no behavior change.
+const engineCore = USE_ENGINE
+    ? createEngineCore(emitEngineWire, {
+        // Pass the SAME fallback Proxies the legacy ctx/runtime use (.env →
+        // process.env), so engine-mode ctx.vars/secrets keep the system-env fallback
+        // (codex P2 / plan 0005 §E). The engine layers per-run input over these
+        // without destroying the Proxy.
+        vars: withEnvFallback(rawVars),
+        secrets: withEnvFallback(rawSecrets),
+        // RAW vars (un-proxied) so ctx.vars.all() returns {...rawVars} exactly — legacy
+        // parity for empty/overlay vars (codex Phase-8 P2).
+        varsRaw: rawVars,
+        // Forward the trace policy so the engine's ky auto-trace capture matches legacy.
+        emitFullTrace: !!emitFullTrace,
+        inferSchema: !!inferSchema,
+        truncateArrays: !!truncateArrays,
+    })
+    : undefined;
 setRuntime({
     vars: withEnvFallback(rawVars),
     secrets: withEnvFallback(rawSecrets),
@@ -1269,8 +1458,8 @@ try {
                 testObj = findTestByExport(userModule, exportNamesMap[id]);
             }
             if (!testObj) {
-                console.log(JSON.stringify({ type: "start", id, name: id, testId: id }));
-                console.log(JSON.stringify({ type: "status", status: "failed", id, testId: id, error: `Test "${id}" not found in module` }));
+                writeEventLine(JSON.stringify({ type: "start", id, name: id, testId: id }));
+                writeEventLine(JSON.stringify({ type: "status", status: "failed", id, testId: id, error: `Test "${id}" not found in module` }));
                 hasFailure = true;
                 return;
             }
@@ -1279,12 +1468,12 @@ try {
             }
             catch (error) {
                 if (error instanceof SkipError) {
-                    console.log(JSON.stringify({ type: "status", status: "skipped", id, testId: id, reason: error.reason }));
+                    writeEventLine(JSON.stringify({ type: "status", status: "skipped", id, testId: id, reason: error.reason }));
                 }
                 else {
                     hasFailure = true;
                     const reason = classifyErrorReason(error);
-                    console.log(JSON.stringify({
+                    writeEventLine(JSON.stringify({
                         type: "status", status: "failed", id, testId: id,
                         error: error instanceof Error ? error.message : String(error),
                         stack: error instanceof Error ? error.stack : undefined,
@@ -1334,7 +1523,20 @@ try {
             const { default: PQueue } = await import("p-queue");
             const queue = new PQueue({ concurrency: batchConcurrency });
             for (const id of expandedIds) {
-                void queue.add(() => runOneTest(id));
+                void queue.add(() => {
+                    const buf = [];
+                    return parallelEventBuffer.run(buf, async () => {
+                        try {
+                            await runOneTest(id);
+                        }
+                        finally {
+                            // Atomic flush: the loop is synchronous, so this test's whole
+                            // event block lands contiguously on stdout.
+                            for (const line of buf)
+                                console.log(line);
+                        }
+                    });
+                });
             }
             await queue.onIdle();
         }
@@ -1483,7 +1685,96 @@ async function withFixtures(fixtures, baseCtx, runTest) {
  *
  * @param test The Test object to execute
  */
+/**
+ * Structural gate for the engine path (plan 0005): Phase 0 routes ONLY simple
+ * tests. Steps stay on legacy until the engine emits step_start/step_end + per-step
+ * index/retry/timeout (Phase 1); branch/poll (Phase 2/3); test.extend() fixtures
+ * and workflow later. Routing a steps test now would lose its step timeline and
+ * skew summaries (codex P2). ctx-surface gaps (validate/metric/…) are managed by
+ * only exercising migrated features under the flag.
+ */
+function engineSupports(test) {
+    if (test.fixtures && Object.keys(test.fixtures).length > 0)
+        return false;
+    // Built workflow / contract wrappers are simple-shaped Tests, but their fn emits
+    // workflow:* events the LEGACY harness unwraps into node/poll timeline events (and
+    // inbound contract is node-only) — the browser-safe engine doesn't, so keep them on
+    // legacy even under route-all (codex Phase-3 P2; plan 0005 §scope). The SDK marks
+    // these wrappers with __glubean_kind.
+    if (test.__glubean_kind)
+        return false;
+    if (test.type === "simple")
+        return true;
+    if (test.type === "steps") {
+        // Linear steps + retry/timeout (Phase 1) + branch (Phase 2) + poll (Phase 3).
+        return stepsEngineSupported(test.steps ?? []);
+    }
+    return false;
+}
+function stepsEngineSupported(steps) {
+    for (const step of steps) {
+        // poll steps (Phase 3) are now engine-supported; recurse into branch cases for
+        // any still-unsupported shape (none today — kept as a structural guard).
+        if (isTestBranchStep(step)) {
+            for (const c of step.branch.cases)
+                if (!stepsEngineSupported(c.steps))
+                    return false;
+            if (!stepsEngineSupported(step.branch.default ?? []))
+                return false;
+        }
+    }
+    return true;
+}
 async function executeNewTest(test) {
+    // runner-on-engine (plan 0005): route to the engine only when (a) the engine is
+    // active, (b) this test id is on the per-test allowlist (GLUBEAN_ENGINE_TESTIDS;
+    // "*" = all at cutover) — so the flag never sends arbitrary production tests
+    // through an incomplete ctx (codex), and (c) the test's shape is supported. The
+    // engine owns its scope/carrier/per-event-id and runs OUTSIDE the legacy
+    // testContext ALS (testId comes from each event's own id). Anything else → legacy.
+    if (engineCore && engineRoutesId(test.meta.id) && engineSupports(test)) {
+        // Wrap with the same memory monitoring as the legacy path so the final status
+        // carries peakMemoryBytes/peakMemoryMB (codex P2).
+        startMemoryMonitoring();
+        const result = await runViaEngine(engineCore, test, { session: sessionData, retryCount });
+        const peakBytes = stopMemoryMonitoring();
+        // Status emission mirrors the legacy split: a throw re-raises so the dispatcher
+        // reports "failed" + exit 1 (the engine swallows throws into a result); success
+        // and skip emit their status here (plan 0005 / codex P2). A soft assertion
+        // failure is NOT a throw → it "completed" (pass/fail is derived from the
+        // assertion events downstream, as in the legacy path).
+        if (result.threw) {
+            const err = new Error(result.error ?? "test threw");
+            // Re-raise with the user's original name + stack so classifyErrorReason() and
+            // diagnostics match the legacy path (codex P2).
+            if (result.errorName)
+                err.name = result.errorName;
+            if (result.errorStack)
+                err.stack = result.errorStack;
+            throw err;
+        }
+        if (result.stepsFailed) {
+            // Node parity (harness.ts:2686): a steps test with any failed step throws after
+            // teardown so the dispatcher reports failed + exit 1 — unlike a simple test's
+            // soft assertion ("completes"). A branch-decision failure carries its own message.
+            throw new Error(result.stepsFailMessage ?? "One or more steps failed");
+        }
+        if (result.status === "skipped") {
+            // Re-raise a harness SkipError(reason) so the SAME dispatcher catch that
+            // handles a legacy ctx.skip() emits the skipped status (with `reason`) — byte
+            // parity with legacy, which throws skipRequest out to the dispatcher (plan 0005).
+            throw new SkipError(result.skipReason);
+        }
+        emitEngineWire({
+            type: "status",
+            status: "completed",
+            id: test.meta.id,
+            testId: test.meta.id,
+            peakMemoryBytes: peakBytes,
+            peakMemoryMB: (peakBytes / 1024 / 1024).toFixed(2),
+        });
+        return;
+    }
     const testTags = normalizeTestTags(test.meta.tags);
     const testMeta = { id: test.meta.id, tags: testTags };
     const trc = new TestRunContext(test.meta.id, testMeta);
@@ -1506,6 +1797,27 @@ async function executeNewTest(test) {
             // Core test body — receives the effective ctx (base or fixture-augmented)
             const runTestBody = async (effectiveCtx) => {
                 if (test.type === "simple") {
+                    // Invocation inversion (plan 0007): a built workflow is a first-class DEF, not a
+                    // self-executing test. The SDK marks the wrapper `__glubean_kind === "workflow"`
+                    // and attaches the Workflow IR to `__glubean_workflow`; the host run-loop drives
+                    // it through the workflow executor here — like RunnerCore.run() dispatches simple
+                    // vs steps. This replaces the SDK's old wfTest.fn (which called runWorkflow
+                    // itself); the VERDICT mapping is identical, just host-owned: a skipped run →
+                    // ctx.skip(reason) (throws GlubeanSkipError, caught by the same dispatcher); a
+                    // failed run → rethrow the cause so the dispatcher reports failed + exit 1.
+                    const wfIr = test.__glubean_workflow;
+                    if (wfIr) {
+                        const result = await runWorkflow(wfIr, effectiveCtx);
+                        if (result.status === "skipped") {
+                            // Prefer the user-authored runtime ctx.skip(reason), then the authored
+                            // meta.skip, then a generic fallback (parity with the old wfTest.fn).
+                            effectiveCtx.skip(result.skipReason ?? wfIr.meta.skip ?? `workflow "${wfIr.meta.id}" skipped`);
+                        }
+                        if (result.status === "failed") {
+                            throw result.error ?? new WorkflowPhaseFailedError(wfIr.meta.id, "workflow");
+                        }
+                        return;
+                    }
                     if (!test.fn) {
                         throw new Error(`Invalid test "${test.meta.id}": missing fn`);
                     }