@specific.dev/spectest 0.131.10 → 0.131.12

package/dist/components/replay-websocket.js

@@ -154,6 +154,8 @@ export function replayWebSocket(args) {
     let deadline;
     let stopped = false;
     let sentClose = false;
+    let receivedMessages = 0, receivedCandidates = 0;
+    let lastCandidate;
     const diagnostic = (detail) => new Error(`${label}, input #${position + 1}: ${detail}`);
     const clear = () => { clearTimeout(timer); clearTimeout(deadline); };
     const finish = (error) => {
@@ -169,7 +171,18 @@ export function replayWebSocket(args) {
         finish(error);
         socket?.close(1011, "WebSocket replay failed");
     };
-    const missing = () => diagnostic(`required input never arrived; expected ${record.inputs[position]}`);
+    const missing = () => {
+        const expected = record.inputs[position];
+        const progress = record.inputMode === "anchors"
+            ? ` occurrence ${record.inputOccurrences[position]}; observed ${occurrences.get(expected) ?? 0} occurrences; received ${receivedMessages} messages, ${receivedCandidates} candidates; last candidate ${lastCandidate ?? "<none>"}`
+            : "";
+        const reordered = record.inputMode === "anchors"
+            && (occurrences.get(expected) ?? 0) >= record.inputOccurrences[position];
+        const detail = reordered
+            ? "required input arrived before preceding anchors matched"
+            : "required input never arrived";
+        return diagnostic(`${detail}; expected ${expected}${progress}`);
+    };
     const armDeadline = () => {
         clearTimeout(deadline);
         if (position < record.inputs.length)
@@ -251,10 +264,13 @@ export function replayWebSocket(args) {
             if (stopped)
                 return;
             try {
+                receivedMessages++;
                 if (args.match.candidates) {
                     let matched = false;
                     for (const actual of args.match.candidates(message)) {
                         const count = occurrence(occurrences, actual);
+                        receivedCandidates++;
+                        lastCandidate = actual;
                         if (actual !== record.inputs[position] || count !== record.inputOccurrences[position])
                             continue;
                         barriers[++position] = performance.now();

package/dist/daemon.js

@@ -52,7 +52,7 @@ import { fakeFunctions, fakeFunctionParameters, callFakeFunction } from "./harne
 import { dispatchFake } from "./harness/fake-websocket.js";
 import { casesMetadata as catalogueCases, groupsMetadata as catalogueGroups, } from "./harness/catalogue.js";
 import { summarizeBuildKit } from "./harness/buildkit-progress.js";
-import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta } from "./harness/log-delta.js";
+import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta, mergeServiceLogDeltas } from "./harness/log-delta.js";
 import { resolveHostPath as resolveVolumeHostPath, sanitizeSegment, } from "./harness/volume-paths.js";
 import { pollUntilReady } from "./harness/ready-poll.js";
 import { fsUsageDiagnostics } from "./harness/wrapper-rules.js";
@@ -1158,6 +1158,12 @@ async function runContainer(svc, tag, volumeFlags,
 // runtime `startService` (whose service isn't in LOWERED) to give the new
 // container docker-native multi-label resolution for its `hostnames`.
 extraAliases = []) {
+    // Preserve the previous incarnation before the name is reused.
+    if (RUNTIME_SERVICES.has(svc.name))
+        await stopRuntimeService(svc.name);
+    STOPPED_LOG_SERVICES.delete(svc.name);
+    LOG_MARKERS.delete(`${svc.name}\0stdout`);
+    LOG_MARKERS.delete(`${svc.name}\0stderr`);
     // Idempotent: clean up any leftover container with the same name.
     await docker(["rm", "-f", svc.name], 30_000);
     // The argv, and every rule shaping it, lives in `harness/container-run.ts`
@@ -2469,6 +2475,15 @@ async function stopRuntimeService(name) {
     const t0 = Date.now();
     const resv = reserveEvent();
     const svc = RUNTIME_SERVICES.get(name);
+    // Freeze log production before reading, while Docker still owns the logs.
+    // Keep force-stop semantics; removing first destroys the only copy.
+    await docker(["kill", name], 30_000);
+    if (!STOPPED_LOG_SERVICES.has(name)) {
+        const delta = await captureServiceLogDelta(name, true);
+        const previous = STOPPED_LOG_DELTAS.get(name);
+        STOPPED_LOG_DELTAS.set(name, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+        STOPPED_LOG_SERVICES.add(name);
+    }
     await docker(["rm", "-f", name], 30_000);
     RUNTIME_SERVICES.delete(name);
     for (const entry of svc?.tls ?? [])
@@ -2921,6 +2936,10 @@ function parkCoverageBundle(caseId, captures) {
  * so it travels with the snapshot into every fork.
  */
 const LOG_MARKERS = new Map();
+// Fork with the harness, like markers. Deltas drain once per case; names remain
+// excluded from Docker reads until a replacement container starts.
+const STOPPED_LOG_DELTAS = new Map();
+const STOPPED_LOG_SERVICES = new Set();
 /**
  * Inspect a container's run state for {@link ServiceLogDelta}: `{}` while
  * running (or when inspect fails — a removed container has no state left to
@@ -2949,43 +2968,51 @@ async function captureServiceLogDeltas() {
         byName.set(s.name, s);
     for (const [name, s] of RUNTIME_SERVICES)
         byName.set(name, s);
-    const services = [...byName.values()];
-    return Promise.all(services.map(async (svc) => {
-        const [r, stop] = await Promise.all([
-            docker(["logs", "--timestamps", svc.name], 30_000),
-            containerStopState(svc.name),
-        ]);
-        if (r.code !== 0) {
-            // Container gone/renamed — surface the CLI error, leave markers put.
-            const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
-            return {
-                service: svc.name,
-                stdout: "",
-                stdoutTruncated: false,
-                stdoutReset: false,
-                stderr: err.value,
-                stderrTruncated: err.truncated,
-                stderrReset: false,
-                ...stop,
-            };
-        }
-        const outKey = `${svc.name}stdout`;
-        const errKey = `${svc.name}stderr`;
-        const out = streamDelta(r.stdout, LOG_MARKERS.get(outKey)?.lines ?? 0);
-        const err = streamDelta(r.stderr, LOG_MARKERS.get(errKey)?.lines ?? 0);
-        LOG_MARKERS.set(outKey, { lines: out.total });
-        LOG_MARKERS.set(errKey, { lines: err.total });
+    const deltas = new Map(STOPPED_LOG_DELTAS);
+    for (const delta of await Promise.all([...byName.keys()]
+        .filter(name => !STOPPED_LOG_SERVICES.has(name)).map(name => captureServiceLogDelta(name)))) {
+        const previous = deltas.get(delta.service);
+        deltas.set(delta.service, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+    }
+    STOPPED_LOG_DELTAS.clear();
+    return [...deltas.values()];
+}
+async function captureServiceLogDelta(name, final = false) {
+    const [r, stop] = await Promise.all([
+        docker(["logs", "--timestamps", name], 30_000),
+        containerStopState(name),
+    ]);
+    if (r.code !== 0) {
+        // Container gone/renamed — surface the CLI error, leave markers put.
+        const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
         return {
-            service: svc.name,
-            stdout: out.delta,
-            stdoutTruncated: out.truncated,
-            stdoutReset: out.reset,
-            stderr: err.delta,
+            service: name,
+            stdout: "",
+            stdoutTruncated: false,
+            stdoutReset: false,
+            stderr: err.value,
             stderrTruncated: err.truncated,
-            stderrReset: err.reset,
+            stderrReset: false,
             ...stop,
         };
-    }));
+    }
+    const outKey = `${name}stdout`;
+    const errKey = `${name}stderr`;
+    const complete = (text) => final && text && !text.endsWith("\n") ? text + "\n" : text;
+    const out = streamDelta(complete(r.stdout), LOG_MARKERS.get(outKey)?.lines ?? 0);
+    const err = streamDelta(complete(r.stderr), LOG_MARKERS.get(errKey)?.lines ?? 0);
+    LOG_MARKERS.set(outKey, { lines: out.total });
+    LOG_MARKERS.set(errKey, { lines: err.total });
+    return {
+        service: name,
+        stdout: out.delta,
+        stdoutTruncated: out.truncated,
+        stdoutReset: out.reset,
+        stderr: err.delta,
+        stderrTruncated: err.truncated,
+        stderrReset: err.reset,
+        ...stop,
+    };
 }
 // ────────────────────────────────────────────────────────────────────────
 // Coverage capture (opt-in per service; see coverage.ts + harness/coverage.ts)
@@ -4423,9 +4450,8 @@ async function runOne(testCase) {
         if (timer)
             clearTimeout(timer);
         phoneRecordings = await phones.finish();
-        const phoneErrors = phoneRecordings.flatMap(r => r.error ? [r.error] : []);
-        if (phoneErrors.length && outcome.status === "passed")
-            outcome = { status: "failed", error: { message: phoneErrors.join("\n") } };
+        // Recordings are dashboard artifacts. Keep capture errors on their metadata
+        // without changing the result of the call steps and assertions.
         nativeAndroid.deactivate();
         RECORDING_EXEC = undefined;
         INTERCEPTORS.endScope();

package/dist/harness/log-delta.d.ts

@@ -52,3 +52,12 @@ export interface StreamDelta {
  * capture repeats the other half, since the marker counts lines.
  */
 export declare function streamDelta(full: string, marker: number): StreamDelta;
+/** Join successive container incarnations into one bounded per-service delta. */
+export declare function mergeServiceLogDeltas<T extends {
+    stdout: string;
+    stderr: string;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    stdoutReset: boolean;
+    stderrReset: boolean;
+}>(earlier: T, later: T): T;

package/dist/harness/log-delta.js

@@ -81,3 +81,13 @@ export function streamDelta(full, marker) {
     const capped = capMiddle(delta, LOG_DELTA_MAX_BYTES);
     return { delta: capped.value, total, reset, truncated: capped.truncated };
 }
+/** Join successive container incarnations into one bounded per-service delta. */
+export function mergeServiceLogDeltas(earlier, later) {
+    const stdout = capMiddle(earlier.stdout + later.stdout, LOG_DELTA_MAX_BYTES);
+    const stderr = capMiddle(earlier.stderr + later.stderr, LOG_DELTA_MAX_BYTES);
+    return { ...later, stdout: stdout.value, stderr: stderr.value,
+        stdoutTruncated: earlier.stdoutTruncated || later.stdoutTruncated || stdout.truncated,
+        stderrTruncated: earlier.stderrTruncated || later.stderrTruncated || stderr.truncated,
+        stdoutReset: earlier.stdoutReset || later.stdoutReset,
+        stderrReset: earlier.stderrReset || later.stderrReset };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.131.10",
+  "version": "0.131.12",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/replay-websocket.ts

@@ -197,6 +197,8 @@ export function replayWebSocket(args: {
   let deadline: ReturnType<typeof setTimeout> | undefined;
   let stopped = false;
   let sentClose = false;
+  let receivedMessages = 0, receivedCandidates = 0;
+  let lastCandidate: string | undefined;
   const diagnostic = (detail: string) => new Error(`${label}, input #${position + 1}: ${detail}`);
   const clear = () => { clearTimeout(timer); clearTimeout(deadline); };
   const finish = (error?: Error) => {
@@ -211,7 +213,18 @@ export function replayWebSocket(args: {
     finish(error);
     socket?.close(1011, "WebSocket replay failed");
   };
-  const missing = () => diagnostic(`required input never arrived; expected ${record.inputs[position]}`);
+  const missing = () => {
+    const expected = record.inputs[position];
+    const progress = record.inputMode === "anchors"
+      ? ` occurrence ${record.inputOccurrences![position]}; observed ${occurrences.get(expected) ?? 0} occurrences; received ${receivedMessages} messages, ${receivedCandidates} candidates; last candidate ${lastCandidate ?? "<none>"}`
+      : "";
+    const reordered = record.inputMode === "anchors"
+      && (occurrences.get(expected) ?? 0) >= record.inputOccurrences![position];
+    const detail = reordered
+      ? "required input arrived before preceding anchors matched"
+      : "required input never arrived";
+    return diagnostic(`${detail}; expected ${expected}${progress}`);
+  };
   const armDeadline = () => {
     clearTimeout(deadline);
     if (position < record.inputs.length) deadline = setTimeout(() => fail(missing()), args.timeoutMs);
@@ -277,10 +290,13 @@ export function replayWebSocket(args: {
     message(_ws, message) {
       if (stopped) return;
       try {
+        receivedMessages++;
         if (args.match.candidates) {
           let matched = false;
           for (const actual of args.match.candidates(message)) {
             const count = occurrence(occurrences, actual);
+            receivedCandidates++;
+            lastCandidate = actual;
             if (actual !== record.inputs[position] || count !== record.inputOccurrences![position]) continue;
             barriers[++position] = performance.now();
             matched = true;

package/src/components/replayFake-websocket.test.ts

@@ -344,6 +344,30 @@ test("unmatched candidates cannot extend the required anchor deadline", async ()
   expect(h.state.websocketErrors.join()).toContain("required input never arrived");
 });
 
+test("missing anchors report hashed candidate progress and occurrence counts without payloads", async () => {
+  const key: WebSocketKey<null> = { initial: null,
+    input(state, message) { return { state, key: message === "ignored" ? null : message }; },
+    output(state) { return { state, anchorPreviousInput: true }; },
+  };
+  const wanted = websocketMatcher(() => "private wanted")("x")!;
+  const last = websocketMatcher(() => "private last")("x")!;
+  const h = await harness([{ request, inputMode: "anchors", inputs: [wanted], inputOccurrences: [2], messages: [] }], key);
+  const c = await h.connect();
+  await c.message("private wanted");
+  await c.message("private last");
+  await c.message("ignored");
+  await c.close();
+  const error = h.state.websocketErrors.join();
+  expect(error).toContain(`expected ${wanted} occurrence 2; observed 1 occurrences`);
+  expect(error).toContain(`received 3 messages, 2 candidates; last candidate ${last}`);
+  expect(error).not.toContain("private");
+
+  const empty = await harness([{ request, inputMode: "anchors", inputs: [wanted], inputOccurrences: [1], messages: [] }], key);
+  const noInput = await empty.connect();
+  await noInput.close();
+  expect(empty.state.websocketErrors.join()).toContain("observed 0 occurrences; received 0 messages, 0 candidates; last candidate <none>");
+});
+
 test("anchor validation and hook failures are explicit", async () => {
   const key: WebSocketKey<null> = { initial: null,
     input(state, message) { return { state, key: message }; },
@@ -428,3 +452,26 @@ test("a reached response anchor catches up older output without adding its stale
   expect(c.sent).toEqual([...messages.map(m => m.data), "response"]);
   await c.close(); expect(h.state.websocketErrors).toEqual([]);
 });
+
+
+test("an anchor observed before its predecessor is diagnosed as out of order", async () => {
+  const key: WebSocketKey<null> = { initial: null,
+    input(state, message) { return { state, key: message }; },
+    output(state) { return { state, anchorPreviousInput: true }; },
+  };
+  const hash = (value: string) => websocketMatcher(() => value)("x")!;
+  const h = await harness([{ request, inputMode: "anchors",
+    inputs: [hash("start"), hash("warmup"), hash("question")],
+    inputOccurrences: [1, 1, 1],
+    messages: [{ type: "text", data: "answer", afterInput: 3, delayMs: 0 }],
+  }], key);
+  const c = await h.connect();
+  await c.message("start");
+  await c.message("question");
+  await c.message("warmup");
+  await tick();
+  expect(c.sent).toEqual([]);
+  await c.close();
+  expect(h.state.websocketErrors.join()).toContain("input #3: required input arrived before preceding anchors matched");
+  expect(h.state.websocketErrors.join()).toContain("occurrence 1; observed 1 occurrences");
+});

package/src/daemon.ts

@@ -109,7 +109,7 @@ import {
   type GroupMeta,
 } from "./harness/catalogue.js";
 import { summarizeBuildKit, type BuildStep } from "./harness/buildkit-progress.js";
-import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta } from "./harness/log-delta.js";
+import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta, mergeServiceLogDeltas } from "./harness/log-delta.js";
 import {
   resolveHostPath as resolveVolumeHostPath,
   sanitizeSegment,
@@ -1489,6 +1489,11 @@ async function runContainer(
   // container docker-native multi-label resolution for its `hostnames`.
   extraAliases: string[] = [],
 ): Promise<void> {
+  // Preserve the previous incarnation before the name is reused.
+  if (RUNTIME_SERVICES.has(svc.name)) await stopRuntimeService(svc.name);
+  STOPPED_LOG_SERVICES.delete(svc.name);
+  LOG_MARKERS.delete(`${svc.name}\0stdout`);
+  LOG_MARKERS.delete(`${svc.name}\0stderr`);
   // Idempotent: clean up any leftover container with the same name.
   await docker(["rm", "-f", svc.name], 30_000);
 
@@ -2947,6 +2952,15 @@ async function stopRuntimeService(name: string): Promise<void> {
   const t0 = Date.now();
   const resv = reserveEvent();
   const svc = RUNTIME_SERVICES.get(name);
+  // Freeze log production before reading, while Docker still owns the logs.
+  // Keep force-stop semantics; removing first destroys the only copy.
+  await docker(["kill", name], 30_000);
+  if (!STOPPED_LOG_SERVICES.has(name)) {
+    const delta = await captureServiceLogDelta(name, true);
+    const previous = STOPPED_LOG_DELTAS.get(name);
+    STOPPED_LOG_DELTAS.set(name, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+    STOPPED_LOG_SERVICES.add(name);
+  }
   await docker(["rm", "-f", name], 30_000);
   RUNTIME_SERVICES.delete(name);
   for (const entry of svc?.tls ?? []) await unbindRuntimeTls(entry.hostname);
@@ -3482,6 +3496,10 @@ function parkCoverageBundle(
  * so it travels with the snapshot into every fork.
  */
 const LOG_MARKERS = new Map<string, { lines: number }>();
+// Fork with the harness, like markers. Deltas drain once per case; names remain
+// excluded from Docker reads until a replacement container starts.
+const STOPPED_LOG_DELTAS = new Map<string, ServiceLogDelta>();
+const STOPPED_LOG_SERVICES = new Set<string>();
 
 /** Per-(service, stream) delta byte cap. Over this we keep head+tail and
  *  elide the middle — the head preserves the continuation from the parent,
@@ -3537,45 +3555,52 @@ async function captureServiceLogDeltas(): Promise<ServiceLogDelta[]> {
   const byName = new Map<string, NamedService>();
   for (const s of namedServices(l.project.environment)) byName.set(s.name, s);
   for (const [name, s] of RUNTIME_SERVICES) byName.set(name, s);
-  const services = [...byName.values()];
-  return Promise.all(
-    services.map(async (svc): Promise<ServiceLogDelta> => {
-      const [r, stop] = await Promise.all([
-        docker(["logs", "--timestamps", svc.name], 30_000),
-        containerStopState(svc.name),
-      ]);
-      if (r.code !== 0) {
-        // Container gone/renamed — surface the CLI error, leave markers put.
-        const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
-        return {
-          service: svc.name,
-          stdout: "",
-          stdoutTruncated: false,
-          stdoutReset: false,
-          stderr: err.value,
-          stderrTruncated: err.truncated,
-          stderrReset: false,
-          ...stop,
-        };
-      }
-      const outKey = `${svc.name}stdout`;
-      const errKey = `${svc.name}stderr`;
-      const out = streamDelta(r.stdout, LOG_MARKERS.get(outKey)?.lines ?? 0);
-      const err = streamDelta(r.stderr, LOG_MARKERS.get(errKey)?.lines ?? 0);
-      LOG_MARKERS.set(outKey, { lines: out.total });
-      LOG_MARKERS.set(errKey, { lines: err.total });
-      return {
-        service: svc.name,
-        stdout: out.delta,
-        stdoutTruncated: out.truncated,
-        stdoutReset: out.reset,
-        stderr: err.delta,
-        stderrTruncated: err.truncated,
-        stderrReset: err.reset,
-        ...stop,
-      };
-    }),
-  );
+  const deltas = new Map(STOPPED_LOG_DELTAS);
+  for (const delta of await Promise.all([...byName.keys()]
+    .filter(name => !STOPPED_LOG_SERVICES.has(name)).map(name => captureServiceLogDelta(name)))) {
+    const previous = deltas.get(delta.service);
+    deltas.set(delta.service, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+  }
+  STOPPED_LOG_DELTAS.clear();
+  return [...deltas.values()];
+}
+
+async function captureServiceLogDelta(name: string, final = false): Promise<ServiceLogDelta> {
+  const [r, stop] = await Promise.all([
+    docker(["logs", "--timestamps", name], 30_000),
+    containerStopState(name),
+  ]);
+  if (r.code !== 0) {
+    // Container gone/renamed — surface the CLI error, leave markers put.
+    const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
+    return {
+      service: name,
+      stdout: "",
+      stdoutTruncated: false,
+      stdoutReset: false,
+      stderr: err.value,
+      stderrTruncated: err.truncated,
+      stderrReset: false,
+      ...stop,
+    };
+  }
+  const outKey = `${name}stdout`;
+  const errKey = `${name}stderr`;
+  const complete = (text: string) => final && text && !text.endsWith("\n") ? text + "\n" : text;
+  const out = streamDelta(complete(r.stdout), LOG_MARKERS.get(outKey)?.lines ?? 0);
+  const err = streamDelta(complete(r.stderr), LOG_MARKERS.get(errKey)?.lines ?? 0);
+  LOG_MARKERS.set(outKey, { lines: out.total });
+  LOG_MARKERS.set(errKey, { lines: err.total });
+  return {
+    service: name,
+    stdout: out.delta,
+    stdoutTruncated: out.truncated,
+    stdoutReset: out.reset,
+    stderr: err.delta,
+    stderrTruncated: err.truncated,
+    stderrReset: err.reset,
+    ...stop,
+  };
 }
 
 // ────────────────────────────────────────────────────────────────────────
@@ -5297,8 +5322,8 @@ async function runOne(testCase: TestCase<unknown>): Promise<RunResult> {
   } finally {
     if (timer) clearTimeout(timer);
     phoneRecordings = await phones.finish();
-    const phoneErrors = phoneRecordings.flatMap(r => r.error ? [r.error] : []);
-    if (phoneErrors.length && outcome.status === "passed") outcome = { status: "failed", error: { message: phoneErrors.join("\n") } };
+    // Recordings are dashboard artifacts. Keep capture errors on their metadata
+    // without changing the result of the call steps and assertions.
     nativeAndroid.deactivate();
     RECORDING_EXEC = undefined;
     INTERCEPTORS.endScope();

package/src/harness/log-delta.test.ts

@@ -123,3 +123,20 @@ describe("streamDelta", () => {
     expect(out.delta.length).toBeLessThan(big.length);
   });
 });
+
+test("repeated service incarnations retain both ends within the log cap", async () => {
+  const { mergeServiceLogDeltas, LOG_DELTA_MAX_BYTES } = await import("./log-delta");
+  const earlier = { stdout: "first\n" + "x".repeat(LOG_DELTA_MAX_BYTES), stderr: "old error\n",
+    stdoutTruncated: false, stderrTruncated: true, stdoutReset: false, stderrReset: false,
+    stopped: true, exitCode: 137 };
+  const later = { ...earlier, stdout: "last\n", stderr: "new error\n", stderrTruncated: false,
+    stopped: false, exitCode: 0 };
+  const result = mergeServiceLogDeltas(earlier, later);
+  expect(result.stdout.startsWith("first\n")).toBe(true);
+  expect(result.stdout.endsWith("last\n")).toBe(true);
+  expect(result.stdout.length).toBeLessThan(LOG_DELTA_MAX_BYTES + 100);
+  expect(result.stdoutTruncated).toBe(true);
+  expect(result.stderr).toBe("old error\nnew error\n");
+  expect(result.stderrTruncated).toBe(true);
+  expect(result.stopped).toBe(false);
+});

package/src/harness/log-delta.ts

@@ -98,3 +98,18 @@ export function streamDelta(full: string, marker: number): StreamDelta {
   const capped = capMiddle(delta, LOG_DELTA_MAX_BYTES);
   return { delta: capped.value, total, reset, truncated: capped.truncated };
 }
+
+/** Join successive container incarnations into one bounded per-service delta. */
+export function mergeServiceLogDeltas<T extends {
+  stdout: string; stderr: string;
+  stdoutTruncated: boolean; stderrTruncated: boolean;
+  stdoutReset: boolean; stderrReset: boolean;
+}>(earlier: T, later: T): T {
+  const stdout = capMiddle(earlier.stdout + later.stdout, LOG_DELTA_MAX_BYTES);
+  const stderr = capMiddle(earlier.stderr + later.stderr, LOG_DELTA_MAX_BYTES);
+  return { ...later, stdout: stdout.value, stderr: stderr.value,
+    stdoutTruncated: earlier.stdoutTruncated || later.stdoutTruncated || stdout.truncated,
+    stderrTruncated: earlier.stderrTruncated || later.stderrTruncated || stderr.truncated,
+    stdoutReset: earlier.stdoutReset || later.stdoutReset,
+    stderrReset: earlier.stderrReset || later.stderrReset };
+}

package/src/phone.test.ts

@@ -434,7 +434,7 @@ test("real harness exposes ctx.phone, seals recordings on every outcome and serv
     assert.equal(loaded.cases.length, 4);
     for (const [index, test] of loaded.cases.entries()) {
       const result = await METHODS.run({caseId:test.id});
-      assert.equal(result.status, index === 0 ? "passed" : "failed", JSON.stringify(result));
+      assert.equal(result.status, index === 0 || index === 3 ? "passed" : "failed", JSON.stringify(result));
       if (index === 1) assert.match(result.error.message, /application assertion failed/);
       if (index === 2) assert.match(result.error.message, /timed out/);
       assert.equal(result.phoneRecordings.length, 1);
@@ -442,7 +442,7 @@ test("real harness exposes ctx.phone, seals recordings on every outcome and serv
       if (index === 3) {
         const message = "Call recording could not be finalized: Phone recording encoder could not keep up with audio";
         assert.equal(recording.error, message);
-        assert.equal(result.error.message, message);
+        assert.equal(result.error, undefined);
         await assert.rejects(METHODS.phoneRecordingChunk({caseId:recording.id}), /Unknown/);
         continue;
       }

package/src/runtime-service-logs.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("stopped service logs survive removal and are emitted only in their owning case", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-stopped-logs-"));
+  try {
+    await mkdir(join(root, "spectest"));
+    await mkdir(join(root, "bin"));
+    await writeFile(join(root, "bin/docker"), `#!/bin/sh
+case "$1" in
+  kill) touch "$SPECTEST_APP_DIR/stopped" ;;
+  rm) touch "$SPECTEST_APP_DIR/removed" ;;
+  run) rm -f "$SPECTEST_APP_DIR/stopped" "$SPECTEST_APP_DIR/removed" ;;
+  inspect) echo 'exited 137' ;;
+  logs)
+    if [ -f "$SPECTEST_APP_DIR/removed" ]; then echo 'container removed' >&2; exit 1; fi
+    if [ -f "$SPECTEST_APP_DIR/stopped" ]; then
+      printf 'startup\nlast diagnostic\n'
+      printf 'failure detail' >&2
+    else printf 'startup\n'; fi ;;
+esac
+`, { mode: 0o755 });
+    await writeFile(join(root, "spectest/index.ts"), `
+      import { defineEnvironment } from ${JSON.stringify(new URL("./index.ts", import.meta.url).href)};
+      const env = defineEnvironment({ name: "logs", services: {
+        agent: { image: { type: "registry", reference: "busybox" } }
+      }});
+      export default env.project([
+        env.test("parent", async () => {}),
+        env.test("stop", async ctx => { await ctx.stopService("agent"); await ctx.stopService("agent"); }),
+        env.test("child", async () => {}),
+        env.test("reuse", async ctx => {
+          const spec = { name: "runtime", image: { type: "registry", reference: "busybox" } };
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+        }),
+      ]);
+    `);
+    const script = `
+      import { strict as assert } from "node:assert";
+      import { METHODS } from ${JSON.stringify(new URL("./daemon.ts", import.meta.url).href)};
+      const loaded = await METHODS.load({});
+      const parent = await METHODS.run({caseId: loaded.cases[0].id});
+      assert.equal(parent.serviceLogDeltas[0].stdout, "startup\\n");
+      const stopped = await METHODS.run({caseId: loaded.cases[1].id});
+      assert.equal(stopped.status, "passed", JSON.stringify(stopped));
+      assert.equal(stopped.serviceLogDeltas.length, 1);
+      assert.equal(stopped.serviceLogDeltas[0].stdout, "last diagnostic\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stderr, "failure detail\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stopped, true);
+      assert.equal(stopped.serviceLogDeltas[0].exitCode, 137);
+      const child = await METHODS.run({caseId: loaded.cases[2].id});
+      assert.deepEqual(child.serviceLogDeltas, []);
+      const reuse = await METHODS.run({caseId: loaded.cases[3].id});
+      assert.equal(reuse.status, "passed", JSON.stringify(reuse));
+      const logs = reuse.serviceLogDeltas.find(d => d.service === "runtime");
+      assert.equal(logs.stdout, "startup\\nlast diagnostic\\nstartup\\nlast diagnostic\\n");
+      assert.equal(logs.stderr, "failure detail\\nfailure detail\\n");
+      process.exit(0);
+    `;
+    const child = Bun.spawn([process.execPath, "--eval", script], {
+      env: { ...process.env, SPECTEST_APP_DIR: root, PATH: `${root}/bin:${process.env.PATH}` },
+      stdout: "pipe", stderr: "pipe",
+    });
+    const [code, stdout, stderr] = await Promise.all([
+      child.exited, new Response(child.stdout).text(), new Response(child.stderr).text(),
+    ]);
+    expect(code, stdout + stderr).toBe(0);
+  } finally { await rm(root, { recursive: true, force: true }); }
+}, 20_000);