agent-dealer 1.2.7 → 1.2.9

package/bundle/server/dist/runners/muse-code-jsonl.js

@@ -32,14 +32,20 @@ function toEnvelope(o) {
     if (!rec || payloadType === undefined || !payload)
         return undefined;
     const stream = asRecord(rec.stream);
-    return { streamKind: str(stream?.kind), streamId: str(stream?.id), payloadType, payload };
+    return {
+        streamKind: str(stream?.kind),
+        streamId: str(stream?.id),
+        payloadType,
+        payload,
+    };
 }
 /** Envelopes plus the count of non-empty lines that were not a JSON envelope. */
-function readEnvelopes(raw) {
+function readEnvelopes(raw, lineTs) {
     const envelopes = [];
     let malformed = 0;
-    for (const line of raw.split("\n")) {
-        const t = line.trim();
+    const lines = raw.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const t = lines[i].trim();
         if (!t)
             continue;
         let parsed;
@@ -51,13 +57,49 @@ function readEnvelopes(raw) {
             continue;
         }
         const env = toEnvelope(parsed);
-        if (env)
-            envelopes.push(env);
+        if (env) {
+            const at = lineTs && i < lineTs.length ? lineTs[i] : null;
+            envelopes.push({
+                ...env,
+                recordedAt: parsed.recorded_at ?? null,
+                lineTs: typeof at === "number" && Number.isFinite(at) ? at : null,
+            });
+        }
         else
             malformed++;
     }
     return { envelopes, malformed };
 }
+/**
+ * NOT-307: usable event time for one envelope, epoch milliseconds. Dealer-observed
+ * arrival first; the stream's own `recorded_at` only as a fallback, and only when
+ * it parses — real sessions batch-stamp it (µs number, whole session in ~40ms),
+ * fixtures redact it to `<ts>`. Numbers above 1e14 are microseconds, below are
+ * milliseconds; strings go through Date.parse.
+ */
+function envelopeTimeMs(env) {
+    if (env.lineTs !== null)
+        return env.lineTs;
+    const r = env.recordedAt;
+    if (typeof r === "number" && Number.isFinite(r)) {
+        return r > 1e14 ? Math.round(r / 1000) : Math.round(r);
+    }
+    if (typeof r === "string") {
+        const ms = Date.parse(r);
+        return Number.isFinite(ms) ? ms : null;
+    }
+    return null;
+}
+function isoOf(ms) {
+    if (ms === null || !Number.isFinite(ms))
+        return null;
+    try {
+        return new Date(ms).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
 /** Session-log lines are auxiliary: unparseable ones are skipped rather than failing the run. */
 function readModelCompleted(sessionLog) {
     if (!sessionLog)
@@ -122,8 +164,12 @@ function classifyReason(reason) {
     return { kind: "other", message };
 }
 export function parseMuseRun(input) {
-    const { envelopes, malformed } = readEnvelopes(input.stdout);
+    const { envelopes, malformed } = readEnvelopes(input.stdout, input.lineTs);
     const stderr = input.stderr ?? "";
+    // A garbage `now` must never stamp garbage: only a parseable ISO string qualifies.
+    const fallbackTs = typeof input.now === "string" && input.now && Number.isFinite(Date.parse(input.now))
+        ? input.now
+        : null;
     let sessionId = null;
     const tools = new Map();
     const toolByTask = new Map();
@@ -132,6 +178,16 @@ export function parseMuseRun(input) {
     // The first run seen is the primary one; a cron job may start further runs in the same process.
     let primaryRunId = null;
     const runIds = new Set();
+    // NOT-307: stream-derived per-event times. firstTs anchors the `system` event;
+    // terminalTs anchors `assistant`/`result`; per-tool intent/result endpoints make
+    // durationMs. All stay null when the stream gave nothing usable (fixtures redact
+    // recorded_at, no lineTs) so unstamped output stays byte-stable.
+    let firstTs = null;
+    let terminalTs = null;
+    const noteEnvelopeTime = (at) => {
+        if (at !== null && firstTs === null)
+            firstTs = at;
+    };
     for (const env of envelopes) {
         const p = env.payload;
         if (sessionId === null && env.streamKind === "session" && env.streamId)
@@ -141,7 +197,11 @@ export function parseMuseRun(input) {
             runIds.add(runId);
         if (primaryRunId === null)
             primaryRunId = runId ?? null;
+        noteEnvelopeTime(isoOf(envelopeTimeMs(env)));
         if (env.payloadType === "run.terminal.completed" || env.payloadType === "run.terminal.failed") {
+            const at = isoOf(envelopeTimeMs(env));
+            if (at !== null && terminalTs === null)
+                terminalTs = at;
             terminals.push({
                 runId: runIdOf(p),
                 terminal: env.payloadType === "run.terminal.completed" ? "completed" : "failed",
@@ -156,7 +216,14 @@ export function parseMuseRun(input) {
             if (operation?.startsWith("tool:") && key?.startsWith("tool:")) {
                 const callId = key.slice("tool:".length);
                 const existing = tools.get(callId);
-                tools.set(callId, existing ?? { callId, name: operation.slice("tool:".length), outcome: null, error: null });
+                tools.set(callId, existing ?? {
+                    callId,
+                    name: operation.slice("tool:".length),
+                    outcome: null,
+                    error: null,
+                    startedAt: isoOf(envelopeTimeMs(env)),
+                    durationMs: null,
+                });
                 const taskId = str(event?.task_id);
                 if (taskId)
                     toolByTask.set(taskId, callId);
@@ -169,11 +236,17 @@ export function parseMuseRun(input) {
             const facts = asRecord(p.correlation_facts);
             const outcome = facts?.outcome === "success" || facts?.outcome === "failure" ? facts.outcome : null;
             const prev = tools.get(callId);
+            const endMs = envelopeTimeMs(env);
+            const startMs = prev?.startedAt ? Date.parse(prev.startedAt) : NaN;
             tools.set(callId, {
                 callId,
                 name: str(facts?.tool_name) ?? prev?.name ?? null,
                 outcome,
                 error: prev?.error ?? null,
+                startedAt: prev?.startedAt ?? null,
+                // Present only when the matching result arrived with both endpoints timed —
+                // a bare intent (tool still running at kill time) carries no duration.
+                durationMs: endMs !== null && Number.isFinite(startMs) && endMs >= startMs ? endMs - startMs : null,
             });
         }
         else if (env.payloadType === "task.lifecycle.failed") {
@@ -249,7 +322,17 @@ export function parseMuseRun(input) {
         rateLimited,
         failure,
         exitCode: input.exitCode,
-        events: normalizeMuseRun({ sessionId, confirmedModel, tools: toolList, finalText, usage, failure }),
+        events: normalizeMuseRun({
+            sessionId,
+            confirmedModel,
+            tools: toolList,
+            finalText,
+            usage,
+            failure,
+            now: fallbackTs,
+            firstTs,
+            terminalTs,
+        }),
     };
 }
 /**
@@ -260,18 +343,29 @@ export function parseMuseRun(input) {
  */
 export function normalizeMuseRun(r) {
     const out = [];
+    const at = (ts) => ts ? { ts } : r.now ? { ts: r.now } : {};
     if (r.sessionId) {
         out.push({
             type: "system",
             subtype: "init",
             session_id: r.sessionId,
             ...(r.confirmedModel ? { model: r.confirmedModel } : {}),
+            ...at(r.firstTs ?? null),
         });
     }
     for (const t of r.tools)
-        out.push({ type: "tool_call", name: t.name ?? "unknown" });
+        out.push({
+            type: "tool_call",
+            name: t.name ?? "unknown",
+            ...at(t.startedAt),
+            ...(t.durationMs !== null ? { durationMs: t.durationMs } : {}),
+        });
     if (r.finalText) {
-        out.push({ type: "assistant", message: { content: [{ type: "text", text: r.finalText }] } });
+        out.push({
+            type: "assistant",
+            message: { content: [{ type: "text", text: r.finalText }] },
+            ...at(r.terminalTs ?? null),
+        });
     }
     const usage = {};
     if (r.usage.inputTokens !== null)
@@ -286,6 +380,7 @@ export function normalizeMuseRun(r) {
         type: "result",
         ...(r.failure ? { is_error: true, result: r.failure.message } : { result: r.finalText ?? "" }),
         ...(Object.keys(usage).length > 0 ? { usage } : {}),
+        ...at(r.terminalTs ?? null),
     });
     return out;
 }

package/bundle/server/dist/runners/muse-config-core.js

@@ -123,6 +123,8 @@ export function buildMuseSettings(agentDeck, role = "developer", evidence = NOT_
         headers: {
             "x-agent-deck-deck-id": agentDeck.deckId,
             "x-agent-deck-workspace": agentDeck.workspace,
+            // NOT-305: opaque per-session correlation UUID — observability metadata, not authority.
+            ...(agentDeck.correlationId ? { "x-agent-deck-correlation-id": agentDeck.correlationId } : {}),
         },
         // `mode`, not `required`: writing both drops the whole MCP block. Never "optional".
         mode: "required",
@@ -308,6 +310,14 @@ function validateInput(input) {
     if (!deckId?.trim() || !workspace?.trim()) {
         throw new MuseIsolationError("invalid_input", "agentDeck.deckId and agentDeck.workspace are required");
     }
+    // NOT-305: when a correlation UUID rides the launch config it must be opaque-UUID
+    // shaped — anything else is a caller bug, refused before anything is written.
+    const correlationId = input.agentDeck?.correlationId;
+    if (correlationId !== undefined && correlationId !== null) {
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(correlationId)) {
+            throw new MuseIsolationError("invalid_input", "agentDeck.correlationId must be a UUID");
+        }
+    }
     let workspaceReal;
     try {
         workspaceReal = fs.realpathSync(workspace);
@@ -371,7 +381,14 @@ function snapshotInput(raw) {
     const cred = raw.credential && typeof raw.credential === "object" ? raw.credential : undefined;
     return deepFreeze({
         ...raw,
-        agentDeck: deck ? { url: deck.url, deckId: deck.deckId, workspace: deck.workspace } : raw.agentDeck,
+        agentDeck: deck
+            ? {
+                url: deck.url,
+                deckId: deck.deckId,
+                workspace: deck.workspace,
+                ...(deck.correlationId !== undefined ? { correlationId: deck.correlationId } : {}),
+            }
+            : raw.agentDeck,
         credential: cred ? { ...cred } : raw.credential,
         env: raw.env ? { ...raw.env } : undefined,
     });

package/bundle/server/dist/runners/muse-config.test.js

@@ -625,3 +625,40 @@ test("only muse-config.ts and tests import muse-config-core", () => {
     });
     assert.deepEqual(offenders, []);
 });
+// NOT-305: the worker session's opaque Deck correlation UUID rides the Muse settings as
+// the exact `x-agent-deck-correlation-id` observability header; without one the header
+// is absent, and a malformed one is refused before anything is written.
+test("Muse settings carry the exact correlation header only when the session has one", () => {
+    const correlationId = "bbbbbbbb-2222-4222-b222-bbbbbbbbbbbb";
+    const fx = fixture();
+    const attempt = prepareMuseAttemptPinned(input(fx, "developer", {
+        agentDeck: { url: DECK_URL, deckId: "deck-123", workspace: fx.worktree, correlationId },
+    }));
+    try {
+        const onDisk = JSON.parse(fs.readFileSync(attempt.settingsPath, "utf8"));
+        assert.deepEqual(onDisk.mcpServers["agent-deck"].headers, {
+            "x-agent-deck-deck-id": "deck-123",
+            "x-agent-deck-workspace": fs.realpathSync(fx.worktree),
+            "x-agent-deck-correlation-id": correlationId,
+        });
+        assert.doesNotThrow(() => attempt.verify());
+    }
+    finally {
+        attempt.cleanup();
+    }
+    const fxBare = fixture();
+    const bare = prepareMuseAttemptPinned(input(fxBare, "developer"));
+    try {
+        const onDisk = JSON.parse(fs.readFileSync(bare.settingsPath, "utf8"));
+        assert.equal("x-agent-deck-correlation-id" in onDisk.mcpServers["agent-deck"].headers, false);
+    }
+    finally {
+        bare.cleanup();
+    }
+    const fxBad = fixture();
+    const bad = () => prepareMuseAttemptPinned(input(fxBad, "developer", {
+        agentDeck: { url: DECK_URL, deckId: "deck-123", workspace: fxBad.worktree, correlationId: "not-a-uuid" },
+    }));
+    assert.equal(code(bad), "invalid_input");
+    assert.deepEqual(fs.readdirSync(fxBad.baseDir), []);
+});

package/bundle/server/dist/runners/muse-serve-session.js

@@ -151,6 +151,11 @@ export function foldServeViewItems(items, turnId) {
                 name: name ?? null,
                 outcome: it.status === "inProgress" ? null : failed ? "failure" : "success",
                 error: asString(it.failureReason) ?? null,
+                // NOT-307: the serve turn items carry no per-tool times; exec-lane arrival
+                // stamping does not apply here, so these stay unstamped (no `ts` fallback
+                // is passed for this lane either).
+                startedAt: null,
+                durationMs: null,
             });
         }
     }

package/bundle/server/dist/runners/spawn-cli.js

@@ -55,6 +55,57 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
             let timedOut = false;
             let settled = false;
             let killEscalation;
+            // NOT-307: idle watchdog state. lastActivityMs starts at spawn so a child that
+            // never emits anything is killed after exactly idleTimeoutMs. stdout bytes always
+            // count; progressSource (when supplied) can only move the mark forward, never back.
+            const spawnStartMs = Date.now();
+            let firstOutputMs = null;
+            let lastActivityMs = spawnStartMs;
+            let idleTimedOut = false;
+            let aborted = false;
+            const idleMs = opts.idleTimeoutMs;
+            const idleEnabled = typeof idleMs === "number" && Number.isFinite(idleMs) && idleMs > 0;
+            let idleTimer;
+            let progressTimer;
+            const clearIdle = () => {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                if (progressTimer)
+                    clearInterval(progressTimer);
+                idleTimer = undefined;
+                progressTimer = undefined;
+            };
+            const rescheduleIdle = () => {
+                if (!idleEnabled || settled || aborted)
+                    return;
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(fireIdle, idleMs);
+                idleTimer.unref?.();
+            };
+            const noteActivity = (atMs) => {
+                const now = typeof atMs === "number" && Number.isFinite(atMs) ? atMs : Date.now();
+                // A stale report (an old mtime re-read, a same-millisecond second chunk) leaves
+                // the deadline standing: only genuinely newer activity postpones the kill, so a
+                // source stuck on an old value can never hold the watchdog off indefinitely.
+                if (firstOutputMs === null)
+                    firstOutputMs = Math.max(0, now - spawnStartMs);
+                if (now <= lastActivityMs)
+                    return;
+                lastActivityMs = now;
+                rescheduleIdle();
+            };
+            // Mirror the wall-clock timeout path exactly (same SIGTERM, same finish(124) 500ms
+            // later) so salvage and infra-retry accounting treat an idle kill as a timeout.
+            // Never fires after an abort: a lost lease is not idleness.
+            function fireIdle() {
+                if (settled || aborted)
+                    return;
+                idleTimedOut = true;
+                timedOut = true;
+                killRunProcess(runId);
+                setTimeout(() => finish(124), 500);
+            }
             const logStream = fs.createWriteStream(opts.logPath, { flags: "w" });
             // A WriteStream's 'error' event has no default handler — left unguarded, any
             // stream error (a write after end, ENOSPC, a permissions problem) is an uncaught
@@ -102,6 +153,8 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
             const onAbort = () => {
                 if (settled)
                     return;
+                aborted = true;
+                clearIdle();
                 try {
                     child.kill("SIGTERM");
                 }
@@ -132,11 +185,32 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
                 else
                     opts.signal.addEventListener("abort", onAbort, { once: true });
             }
+            // NOT-307: line splitter for onStdoutLine only — untouched when no hook is set.
+            // Declared before finish() so no path can observe the bindings uninitialized.
+            let lineTail = "";
+            const emitLine = (line) => {
+                const hook = opts.onStdoutLine;
+                if (!hook)
+                    return;
+                try {
+                    hook(line, Date.now());
+                }
+                catch (err) {
+                    console.error(`[spawn-cli] onStdoutLine for ${runId}`, err);
+                }
+            };
             const finish = (exitCode) => {
                 if (settled)
                     return;
                 settled = true;
+                // A final line without a trailing newline still arrived — report it at close time.
+                if (opts.onStdoutLine && lineTail !== "") {
+                    const tail = lineTail;
+                    lineTail = "";
+                    emitLine(tail);
+                }
                 clearTimeout(timer);
+                clearIdle();
                 cleanupAbort();
                 unregisterChild(runId);
                 // Write any stderr BEFORE ending the stream — writing after end() throws
@@ -163,6 +237,10 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
                         exitCode,
                         transcript: stdoutChunks.join(""),
                         timedOut,
+                        idleTimedOut,
+                        firstOutputMs,
+                        lastActivityAt: new Date(lastActivityMs).toISOString(),
+                        idleForMs: idleTimedOut ? Math.max(0, Date.now() - lastActivityMs) : null,
                     });
                 };
                 if (logStream.destroyed || logStream.errored) {
@@ -195,10 +273,47 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
                 killRunProcess(runId);
                 setTimeout(() => finish(124), 500);
             }, opts.timeoutMs);
+            // NOT-307: arm the idle watchdog once the child exists. The first deadline is one
+            // full idle window after spawn (lastActivityMs starts at spawn), so a child that
+            // never emits anything is killed after exactly idleTimeoutMs.
+            if (idleEnabled) {
+                rescheduleIdle();
+                if (opts.progressSource) {
+                    // Sample at most every 30s and at least every handful of ms: frequent enough
+                    // that the kill lands near the bound, sparse enough to never matter for I/O.
+                    const pollMs = Math.min(Math.max(Math.floor(idleMs / 10), 50), 30_000);
+                    progressTimer = setInterval(() => {
+                        if (settled || aborted)
+                            return;
+                        let at = null;
+                        try {
+                            at = opts.progressSource?.() ?? null;
+                        }
+                        catch {
+                            at = null;
+                        }
+                        if (typeof at === "number" && Number.isFinite(at) && at >= spawnStartMs) {
+                            noteActivity(at);
+                        }
+                    }, pollMs);
+                    progressTimer.unref?.();
+                }
+            }
             child.stdout?.on("data", (buf) => {
                 const chunk = buf.toString();
                 stdoutChunks.push(chunk);
                 logStream.write(buf);
+                // NOT-307: any stdout bytes are progress. (stderr deliberately does not count:
+                // the contract defines progress as stdout bytes or the external source.)
+                noteActivity();
+                if (opts.onStdoutLine) {
+                    lineTail += chunk;
+                    let idx;
+                    while ((idx = lineTail.indexOf("\n")) >= 0) {
+                        emitLine(lineTail.slice(0, idx));
+                        lineTail = lineTail.slice(idx + 1);
+                    }
+                }
             });
             child.stderr?.on("data", (buf) => {
                 stderrChunks.push(buf.toString());
@@ -208,6 +323,7 @@ export async function spawnCli(runId, cmd, args, cwd, opts) {
                     return;
                 settled = true;
                 clearTimeout(timer);
+                clearIdle();
                 cleanupAbort();
                 unregisterChild(runId);
                 logStream.end();

package/bundle/server/dist/runners/spawn-cli.test.js

@@ -216,3 +216,127 @@ test("spawnCli stdin close on an instantly-exiting child still settles", async (
     assert.equal(result.exitCode, 3);
     assert.equal(result.timedOut, false);
 });
+// NOT-307: a child that prints nothing for longer than idleTimeoutMs is killed like a
+// wall-clock timeout (timedOut true) with the idle flag set — well before timeoutMs.
+// Fake timers: the child is real (only the parent's clock is mocked), so the SIGTERM
+// kill and the close event need real event-loop turns between mock advances.
+test("spawnCli kills a silent child after idleTimeoutMs, well before timeoutMs", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    try {
+        const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-spawn-cli-")), "out.ndjson");
+        const { cmd, args } = nodeChild("setInterval(() => {}, 1000);");
+        const promise = spawnCli("test-run-idle-kill", cmd, args, process.cwd(), {
+            logPath,
+            timeoutMs: 60_000,
+            idleTimeoutMs: 250,
+        });
+        const flushIo = async (rounds) => {
+            for (let i = 0; i < rounds; i++)
+                await new Promise((r) => setImmediate(r));
+        };
+        t.mock.timers.tick(1000); // the 250ms idle bound fires; the 60s wall clock does not
+        await flushIo(50); // let the SIGTERM kill land and the close event arrive
+        t.mock.timers.tick(1000); // the finish(124) 500ms delay after the kill
+        const result = await promise;
+        assert.equal(result.timedOut, true, "an idle kill reads as a timeout downstream");
+        assert.equal(result.idleTimedOut, true);
+        assert.equal(result.transcript, "");
+        assert.equal(result.firstOutputMs, null, "a silent child never produced output");
+        assert.ok(typeof result.idleForMs === "number" && result.idleForMs >= 250, `idleForMs reports the observed silence, got ${result.idleForMs}`);
+    }
+    finally {
+        t.mock.timers.reset();
+    }
+});
+// NOT-307: a progressSource that keeps reporting fresh activity holds the watchdog off.
+// The child prints once then idles forever; after forty idle windows of mock time it must
+// still be alive (the abort below ends it — an idle kill would have beaten the abort).
+test("spawnCli does not idle-kill while the progress source reports activity", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    try {
+        const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-spawn-cli-")), "out.ndjson");
+        const { cmd, args } = nodeChild("console.log('started'); setInterval(() => {}, 1000);");
+        const controller = new AbortController();
+        const promise = spawnCli("test-run-idle-source", cmd, args, process.cwd(), {
+            logPath,
+            timeoutMs: 3_600_000,
+            idleTimeoutMs: 250,
+            progressSource: () => Date.now(),
+            signal: controller.signal,
+        });
+        // Real-time wait for the child to actually print (mock-safe: no timer calls) —
+        // otherwise the abort below can race child startup and prove nothing.
+        for (let i = 0; i < 20000; i++) {
+            try {
+                if (fs.readFileSync(logPath, "utf8").includes("started"))
+                    break;
+            }
+            catch {
+                // The log file is created asynchronously by the write stream — keep polling.
+            }
+            if (i === 19999)
+                throw new Error("child never reported that it had started");
+            await new Promise((r) => setImmediate(r));
+        }
+        for (let i = 0; i < 40; i++) {
+            t.mock.timers.tick(250);
+            await new Promise((r) => setImmediate(r));
+        }
+        controller.abort();
+        const result = await promise;
+        assert.equal(result.timedOut, false, "the abort ends it, not any timeout");
+        assert.equal(result.idleTimedOut, false, "forty idle windows passed with no idle kill");
+        assert.match(result.transcript, /started/);
+    }
+    finally {
+        t.mock.timers.reset();
+    }
+});
+// NOT-307: frequent stdout (faster than idleTimeoutMs, real timers) is progress — the
+// child is never killed and the timing fields are populated.
+test("spawnCli does not idle-kill a child that emits output more often than idleTimeoutMs", async () => {
+    const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-spawn-cli-")), "out.ndjson");
+    const { cmd, args } = nodeChild("let i = 0; const t = setInterval(() => { console.log('tick-' + i++); if (i >= 8) clearInterval(t); }, 50);");
+    const result = await spawnCli("test-run-idle-chatty", cmd, args, process.cwd(), {
+        logPath,
+        timeoutMs: 30_000,
+        idleTimeoutMs: 500,
+    });
+    assert.equal(result.exitCode, 0);
+    assert.equal(result.timedOut, false);
+    assert.equal(result.idleTimedOut, false);
+    assert.equal(result.idleForMs, null);
+    assert.match(result.transcript, /tick-7/);
+    assert.ok(typeof result.firstOutputMs === "number" && result.firstOutputMs >= 0, `firstOutputMs is measured, got ${result.firstOutputMs}`);
+    assert.ok(result.lastActivityAt !== null, "lastActivityAt is recorded");
+});
+// NOT-307: the line hook reports each stdout line with a non-decreasing arrival time —
+// the arrival stamps muse-spawn joins back to stream envelopes for per-event `ts`.
+test("spawnCli onStdoutLine reports every line with arrival times", async () => {
+    const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-spawn-cli-")), "out.ndjson");
+    const { cmd, args } = nodeChild("console.log('line-one'); setTimeout(() => console.log('line-two'), 120);");
+    const seen = [];
+    const startedAt = Date.now();
+    const result = await spawnCli("test-run-lines", cmd, args, process.cwd(), {
+        logPath,
+        timeoutMs: 10_000,
+        onStdoutLine: (line, atMs) => seen.push({ line, atMs }),
+    });
+    assert.equal(result.exitCode, 0);
+    assert.deepEqual(seen.map((s) => s.line), ["line-one", "line-two"]);
+    assert.ok(seen[0].atMs >= startedAt && seen[0].atMs <= Date.now());
+    assert.ok(seen[1].atMs >= seen[0].atMs, "arrival times never run backwards");
+    assert.ok(seen[1].atMs - seen[0].atMs >= 50, `the 120ms gap is visible, got ${seen[1].atMs - seen[0].atMs}ms`);
+});
+// NOT-307: with idleTimeoutMs unset the watchdog is disabled — a silent child runs to
+// the wall clock exactly as before, and idleTimedOut reads false.
+test("spawnCli without idleTimeoutMs times out on the wall clock with idleTimedOut false", async () => {
+    const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-spawn-cli-")), "out.ndjson");
+    const { cmd, args } = nodeChild("setInterval(() => {}, 1000);");
+    const result = await spawnCli("test-run-no-idle", cmd, args, process.cwd(), {
+        logPath,
+        timeoutMs: 400,
+    });
+    assert.equal(result.timedOut, true);
+    assert.equal(result.idleTimedOut, false);
+});

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.2.7",
+    "@agent-dealer/shared": "1.2.9",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",