@gevezex/gdt 0.4.0 → 0.5.0

package/dist/prompts.js

@@ -37,6 +37,16 @@ export function pendingDirectives(records, trustedAuthors, role, afterCommentId)
         .filter((r) => trustedAuthors.includes(r.author) && r.data.role === role && r.comment_id > afterCommentId)
         .map((r) => ({ comment_id: r.comment_id, directive: r.data.directive }));
 }
+/**
+ * The record schema as embedded in a prompt. `z.toJSONSchema` starts with a `"$schema"` key and
+ * agents copy it into their record, where the strict schema rejects it; the key is dropped from the
+ * prompt (AC-3).
+ */
+function recordSchema(kind) {
+    const schema = { ...z.toJSONSchema(schemas[kind]) };
+    delete schema["$schema"];
+    return JSON.stringify(schema, null, 2);
+}
 function schemaSection(kind) {
     return [
         `## Protocol: ${marker(kind)}`,
@@ -44,8 +54,10 @@ function schemaSection(kind) {
         `Close the record with ${marker(kind, true)}. The JSON object must match this JSON Schema:`,
         "",
         "```json",
-        JSON.stringify(z.toJSONSchema(schemas[kind]), null, 2),
+        recordSchema(kind),
         "```",
+        "",
+        `The record must not contain a \`"$schema"\` key.`,
     ].join("\n");
 }
 /** The prompt for one turn: role file, dispatch facts, language, protocol, directives and project rules. */
@@ -77,6 +89,16 @@ export function buildPrompt(role, dispatch, project) {
         `Acceptance-criterion fields: ${f.given}, ${f.when}, ${f.then}, ${f.example}`,
         `"None" marker: ${locale.markers.none}`,
     ].join("\n"));
+    // AC-2: the retried turn is told which record was rejected and why, so it can post a fixed one.
+    if (dispatch.invalid_record !== undefined) {
+        const rejected = dispatch.invalid_record;
+        parts.push([
+            `## Invalid record in comment ${rejected.comment_id}`,
+            "",
+            `Your previous ${marker(rejected.kind)} record in comment ${rejected.comment_id} was rejected: ${rejected.reason}`,
+            `Post a new, complete record ${marker(rejected.kind)} that matches the schema exactly.`,
+        ].join("\n"));
+    }
     parts.push(schemaSection(RECORD_OF[role]), schemaSection("question"));
     if (dispatch.directives.length > 0) {
         parts.push([

package/dist/protocol.js

@@ -63,6 +63,14 @@ export const schemas = {
 export function marker(kind, closing = false) {
     return `[${closing ? "/" : ""}gdt-${kind}:v1]`;
 }
+/** AC-1: the blocked reason for a turn whose role posted only an invalid record. */
+export function invalidRecordReason(role, diagnostic) {
+    return `${role} posted an invalid record ${marker(diagnostic.kind)} in comment ${diagnostic.comment_id}: ${diagnostic.reason}`;
+}
+/** True when a blocked reason reports an invalid record, so `gdt retry` can lift it (AC-1). */
+export function isInvalidRecordReason(reason) {
+    return reason.includes(" posted an invalid record ");
+}
 /** The comment body carrying one record: opening marker, JSON object and closing marker. */
 export function formatRecord(kind, data) {
     return `${marker(kind)}\n${JSON.stringify(data, null, 2)}\n${marker(kind, true)}\n`;
@@ -93,12 +101,12 @@ export function parseRecords(comments) {
                 json = JSON.parse(unfence(match[2] ?? ""));
             }
             catch {
-                diagnostics.push({ comment_id: comment.id, kind, reason: "invalid JSON" });
+                diagnostics.push({ comment_id: comment.id, author: comment.author, kind, reason: "invalid JSON" });
                 continue;
             }
             const parsed = schemas[kind].safeParse(json);
             if (!parsed.success) {
-                diagnostics.push({ comment_id: comment.id, kind, reason: schemaReason(parsed.error) });
+                diagnostics.push({ comment_id: comment.id, author: comment.author, kind, reason: schemaReason(parsed.error) });
                 continue;
             }
             records.push({

package/dist/state.js

@@ -31,6 +31,7 @@ export function paths(root, issue, env) {
         lock: join(dir, "supervisor.lock"),
         pause: join(dir, "paused"),
         stopping: join(dir, "stopping"),
+        extend: join(dir, "extend.json"),
         overrides: join(dir, "overrides.json"),
         logs: join(dir, "logs"),
         panes: join(dir, "panes.json"),
@@ -39,6 +40,7 @@ export function paths(root, issue, env) {
         started: (key) => join(dir, "runs", `${key}.started`),
         result: (key) => join(dir, "runs", `${key}.result.json`),
         prompt: (key) => join(dir, "runs", `${key}.prompt.md`),
+        agent: (key) => join(dir, "runs", `${key}.agent`),
     };
 }
 /** A log line timestamp in local time, `YYYY-MM-DD hh:mm:ss`. */

package/dist/supervisor.js

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { formatSignals, groupUsage, nextBaseline, opencodeDatabase, sample, signals } from "./activity.js";
 import { backendFor } from "./backends/index.js";
 import { loadConfig, ROLES } from "./config.js";
 import { sectionText, validateContract } from "./contract.js";
@@ -9,8 +12,8 @@ import { comments, issueSnapshot, pullRequest, repository, viewer } from "./gith
 import { loadLocale } from "./locale.js";
 import { notify } from "./notify.js";
 import { pendingDirectives } from "./prompts.js";
-import { parseRecords } from "./protocol.js";
-import { acquireLock, logTimestamp, NOTIFY_STATUSES, paths, readJson, readState, writeJsonAtomic, writeState, } from "./state.js";
+import { invalidRecordReason, parseRecords } from "./protocol.js";
+import { acquireLock, logTimestamp, NOTIFY_STATUSES, paths, readJson, readOverrides, readState, writeJsonAtomic, writeState, } from "./state.js";
 /** AC-4: the herdr agent state reported for each role pane state. */
 const ROLE_PANE_STATE = {
     RUNNING: "working",
@@ -32,6 +35,43 @@ export function cliPath() {
 export function sha256(text) {
     return createHash("sha256").update(text).digest("hex");
 }
+/** AC-1: the running reason of a turn past its deadline that is still active. */
+export function activeReason(role, limit) {
+    return `${role} turn past the ${limit}-minute limit, still active`;
+}
+/** AC-2: the blocked reason of a turn stopped because it was inactive after its deadline. */
+export function inactiveReason(role, idle, limit) {
+    return `${role} turn inactive for ${idle} minutes after the ${limit}-minute limit`;
+}
+/** AC-4: the blocked reason of a turn that is still active at its hard limit. */
+export function hardLimitReason(role, minutes) {
+    return `${role} turn still active after ${minutes} minutes`;
+}
+/** AC-6: the blocked reason of a turn whose agent and worker are gone without a result. */
+export function exitedReason(role) {
+    return `${role} agent exited without a result`;
+}
+/** The deadline of a turn dispatched at `dispatchedAt`, with `minutes` as the configured limit. */
+export function turnDeadline(dispatchedAt, minutes) {
+    return new Date(new Date(dispatchedAt).getTime() + minutes * 60_000);
+}
+/** AC-8: the turn's last activity: `dispatched_at` until an activity signal fires. */
+export function turnLastActivity(inflight) {
+    return inflight.last_activity ?? inflight.dispatched_at;
+}
+/** AC-8: the turn's hard limit: `dispatched_at + turn_max_minutes` until `gdt extend` moves it. */
+export function turnHardLimit(inflight, maxMinutes) {
+    return inflight.hard_limit === undefined ? turnDeadline(inflight.dispatched_at, maxMinutes) : new Date(inflight.hard_limit);
+}
+/** AC-2/AC-6: true when a blocked reason is a stopped or exited turn, so `gdt retry` can lift it. */
+export function isTimeoutReason(reason) {
+    return /^\w+ turn inactive for [\d.]+ minutes after the [\d.]+-minute limit$/.test(reason) || / agent exited without a result$/.test(reason);
+}
+/** AC-4: true when a blocked reason is a turn still active at its hard limit. */
+export function isHardLimitReason(reason) {
+    return /^\w+ turn still active after [\d.]+ minutes$/.test(reason);
+}
+const NO_SIGNALS = { cpu: false, tree: false, log: false, opencode: false };
 /** One key per role, round, head and contract; a resumed question makes the resumed turn distinct. */
 export function dispatchKey(decision, head, bodySha) {
     const parts = [decision.role, `r${decision.round}`, head ?? "no-pr", bodySha];
@@ -53,6 +93,18 @@ function roleOf(record) {
             return null;
     }
 }
+/** The record kind each workflow role writes; a diagnostic of another kind is never that role's. */
+const ROLE_OF_KIND = { handoff: "developer", test: "tester", review: "reviewer" };
+/** AC-1: the newest invalid role record the role posted after the turn's `after_comment_id`. */
+function invalidRecordFor(inflight, diagnostics, trusted) {
+    return diagnostics
+        .filter((d) => ROLE_OF_KIND[d.kind] === inflight.role && trusted.includes(d.author) && d.comment_id > inflight.after_comment_id)
+        // Newest comment wins when the role posted several invalid records.
+        .sort((a, b) => b.comment_id - a.comment_id)[0];
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
 function sleep(ms) {
     return new Promise((done) => setTimeout(done, ms));
 }
@@ -107,6 +159,16 @@ class Supervisor {
         this.backend.setTitle(role, this.roleTitle(role, state));
         this.reportState(role, ROLE_PANE_STATE[state]);
     }
+    /**
+     * AC-1: ends a role's worker, which stops its agent process group on SIGTERM. Its pid is dropped so
+     * a later `gdt retry` does not try to stop an already-dead process.
+     */
+    stopRole(role) {
+        const pid = this.state.pids.workers[role];
+        if (pid !== undefined && this.backend.alive(pid))
+            this.backend.close(pid);
+        this.state.pids.workers = Object.fromEntries(Object.entries(this.state.pids.workers).filter(([name]) => name !== role));
+    }
     /** AC-1: sets the display-only agent label, for example `developer · opencode` or `gdt · supervisor`. */
     setDisplay(name, label) {
         try {
@@ -119,6 +181,21 @@ class Supervisor {
             log(`warning: herdr display label failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    /** The agent of a role's next turn: its `gdt set-agent` override, otherwise the config agent. */
+    effectiveAgent(role) {
+        return readOverrides(this.p)[role]?.agent ?? this.agents[role];
+    }
+    /**
+     * #68 AC-1/AC-2: sets a role label naming the effective agent. A `gdt set-agent` that writes its
+     * override and label between our read and our write would be overwritten, so the label is written
+     * again until the override read after writing it matches.
+     */
+    setRoleDisplay(role) {
+        for (let agent = this.effectiveAgent(role), written = ""; agent !== written; agent = this.effectiveAgent(role)) {
+            this.setDisplay(role, `${role} · ${agent}`);
+            written = agent;
+        }
+    }
     /** Records a status; notifies once when entering a notifying status. */
     setStatus(status, reason, extra = {}) {
         if (this.state.status !== status || this.state.reason !== reason)
@@ -138,15 +215,169 @@ class Supervisor {
         }
         this.save();
     }
+    /** The agent process group id the worker recorded for the turn, or null before the agent started. */
+    agentGroup(key) {
+        try {
+            const pid = Number(readFileSync(this.p.agent(key), "utf8").trim());
+            return Number.isInteger(pid) && pid > 0 ? pid : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** AC-2: ends what is left of the agent process group once its worker is stopped. */
+    stopGroup(pgid) {
+        if (pgid === null)
+            return;
+        for (const signal of ["SIGTERM", "SIGKILL"]) {
+            if (groupUsage(pgid, this.env).processes === 0)
+                return;
+            try {
+                process.kill(-pgid, signal);
+            }
+            catch {
+                return;
+            }
+            for (let waited = 0; waited < 2000 && groupUsage(pgid, this.env).processes !== 0; waited += 100)
+                sleepSync(100);
+        }
+    }
+    /** The activity sample of an in-flight turn (issue Definitions). */
+    sampleTurn(running, pgid) {
+        const agent = this.effectiveAgent(running.role);
+        const home = this.env.HOME === undefined || this.env.HOME === "" ? homedir() : this.env.HOME;
+        return sample({
+            root: this.p.root,
+            env: this.env,
+            pgid,
+            logFile: this.config.workflow.terminal === "headless" ? join(this.p.logs, `${running.role}.log`) : null,
+            opencodeDb: agent === "opencode" ? opencodeDatabase(this.env, home) : null,
+        });
+    }
+    /**
+     * AC-5: applies a hard limit granted by `gdt extend` for this turn. Returns true when a request was
+     * read; the caller removes it only after saving the poll's status, so `gdt status` never sees the
+     * turn blocked again in between.
+     */
+    applyExtension(running) {
+        const extension = readJson(this.p.extend);
+        if (extension === null)
+            return false;
+        if (extension.key === running.key) {
+            running.hard_limit = extension.hard_limit;
+            running.at_hard_limit = false;
+            log(`${running.role} turn hard limit extended to ${extension.hard_limit}`);
+        }
+        return true;
+    }
+    /** Blocks the workflow on a stopped or exited turn; the block stays until `gdt retry`. */
+    blockStopped(running) {
+        this.setRoleState(running.role, "FAILED");
+        this.setStatus("blocked", running.stop_reason ?? exitedReason(running.role), { role: running.role, round: running.round });
+        return "continue";
+    }
+    /**
+     * Checks a result-less in-flight turn on every poll, before any GitHub fetch, so a failing `gh`
+     * call never postpones it. It samples the turn's activity and moves its last activity when a
+     * signal fires. AC-6: a turn whose worker and agent are gone on two consecutive polls blocks at
+     * once. Past the deadline, AC-1: an active turn keeps running; AC-2: an inactive one is stopped
+     * and blocked; AC-4: an active one at its hard limit blocks without being stopped. A result file
+     * ends the turn, also at the hard limit; a stopped turn stays blocked even if a result appears.
+     * With `startup`, the worker was not started yet, so a missing worker is not an exited agent.
+     * Returns "continue" when the poll ends here, or null to let `tick` go on.
+     */
+    settleTurn(now, startup = false) {
+        const running = this.state.inflight;
+        if (running === null || running.violation !== undefined || running.missing)
+            return null;
+        if (running.stop_reason !== undefined)
+            return this.blockStopped(running);
+        if (readJson(this.p.result(running.key)) !== null)
+            return null;
+        const extended = this.applyExtension(running);
+        const outcome = this.checkActivity(running, now, startup);
+        if (extended) {
+            this.save();
+            rmSync(this.p.extend, { force: true });
+        }
+        return outcome;
+    }
+    /** The activity part of `settleTurn` for a result-less in-flight turn. */
+    checkActivity(running, now, startup) {
+        const workflow = this.config.workflow;
+        const pgid = this.agentGroup(running.key);
+        const current = this.sampleTurn(running, pgid);
+        // On startup the agent of the previous run is gone and gdt's own stop line grew the log, so the
+        // sample only becomes the new baseline: the kept last activity gets no fresh window.
+        const fired = startup ? NO_SIGNALS : signals(current, running.activity);
+        const active = fired.cpu || fired.tree || fired.log || fired.opencode;
+        running.activity = nextBaseline(current, startup ? undefined : running.activity, startup || active);
+        if (active)
+            running.last_activity = now.toISOString();
+        // AC-6: an exited agent needs two consecutive polls, so a single unlucky sample never blocks a turn.
+        const workerAlive = this.backend.alive(this.state.pids.workers[running.role] ?? -1);
+        running.exited_polls = !startup && !workerAlive && current.processes === 0 ? (running.exited_polls ?? 0) + 1 : 0;
+        if (running.exited_polls >= 2) {
+            running.stop_reason = exitedReason(running.role);
+            this.stopRole(running.role);
+            log(`${running.role} agent exited without a result`);
+            return this.blockStopped(running);
+        }
+        const limit = workflow.turn_timeout_minutes;
+        if (now.getTime() < turnDeadline(running.dispatched_at, limit).getTime())
+            return null;
+        const lastActivity = turnLastActivity(running);
+        // AC-1/AC-3: one line per poll past the deadline, naming every signal and whether it fired.
+        log(`activity check for ${running.key}: ${formatSignals(fired)}; last activity ${lastActivity}`);
+        const context = { role: running.role, round: running.round };
+        const hardLimit = turnHardLimit(running, workflow.turn_max_minutes);
+        const hardMinutes = Math.round(((hardLimit.getTime() - Date.parse(running.dispatched_at)) / 60_000) * 100) / 100;
+        if (running.at_hard_limit === true) {
+            // AC-4: the turn keeps running until `gdt extend`, `gdt retry` or its result.
+            this.setStatus("blocked", hardLimitReason(running.role, hardMinutes), context);
+            return "continue";
+        }
+        if (now.getTime() - Date.parse(lastActivity) >= workflow.turn_idle_minutes * 60_000) {
+            running.timed_out = true;
+            running.stop_reason = inactiveReason(running.role, workflow.turn_idle_minutes, limit);
+            this.stopRole(running.role);
+            this.stopGroup(pgid);
+            log(`${running.stop_reason}; worker and agent stopped`);
+            return this.blockStopped(running);
+        }
+        if (now.getTime() >= hardLimit.getTime()) {
+            running.at_hard_limit = true;
+            this.setStatus("blocked", hardLimitReason(running.role, hardMinutes), context);
+            return "continue";
+        }
+        this.setStatus("running", activeReason(running.role, limit), context);
+        return "continue";
+    }
+    /**
+     * Settles an in-flight turn before replacement workers start. A replacement worker that finds the
+     * turn's `started` marker writes an interruption result (exit code null), which would otherwise
+     * turn an inactive overdue turn into `failed` instead of the retryable `blocked`. Returns the
+     * stopped role, so `startWorkers` keeps its FAILED pane and starts no worker for it.
+     */
+    settleOverdueTurn(now) {
+        this.settleTurn(now, true);
+        const running = this.state.inflight;
+        return running?.stop_reason === undefined ? null : running.role;
+    }
     startWorkers() {
         this.backend.ensureWorkspace();
         // AC-1: the agents overview shows the role next to the agent name, once per `gdt start`.
         this.setDisplay("supervisor", "gdt · supervisor");
         this.backend.setTitle("supervisor", "supervisor · starting");
         this.reportState("supervisor", supervisorAgentState(this.state.status));
+        // AC-1: settle an overdue in-flight turn before its replacement worker can write a result.
+        const settled = this.settleOverdueTurn(new Date());
         for (const role of ROLES) {
+            // A settled role keeps its FAILED pane and gets no worker until `gdt retry` and `gdt start`.
+            if (role === settled)
+                continue;
             this.setRoleState(role, "WAITING");
-            this.setDisplay(role, `${role} · ${this.agents[role]}`);
+            this.setRoleDisplay(role);
             if (this.backend.alive(this.state.pids.workers[role] ?? -1))
                 continue;
             this.state.pids.workers[role] = this.backend.spawnPane(role, [process.execPath, cliPath(), "_worker", String(this.issue), role]);
@@ -164,6 +395,10 @@ class Supervisor {
             this.setStatus("paused", "", { role: null });
             return "continue";
         }
+        // The turn check runs before any GitHub fetch, so a failing `gh` call cannot postpone it and
+        // leave a hung turn `running` forever.
+        if (this.settleTurn(now) !== null)
+            return "continue";
         const { body, pullRequests } = issueSnapshot(this.issue, this.p.root, this.env);
         const bodySha = sha256(body);
         const changelog = sectionText(body, this.locale.sections.changelog) ?? "";
@@ -193,10 +428,13 @@ class Supervisor {
                 return "continue";
             }
             if (running.missing) {
-                // Also restores the status after a stop and start.
-                this.setStatus("blocked", `${running.role} finished without a visible handoff`, { role: running.role, round: running.round });
+                // Also restores the status after a stop and start. AC-1: an invalid record keeps its reason.
+                const reason = running.missing_reason ?? `${running.role} finished without a visible handoff`;
+                this.setStatus("blocked", reason, { role: running.role, round: running.round });
                 return "continue";
             }
+            // A turn past its deadline was already settled at the top of this tick, before the GitHub
+            // fetch. A result-less turn that reaches this point is still before its deadline.
             const result = readJson(this.p.result(running.key));
             if (result === null) {
                 this.setStatus("running", `${running.role} turn in progress`, { role: running.role, round: running.round });
@@ -237,17 +475,30 @@ class Supervisor {
         const thread = [...comments(this.state.repository, this.issue, this.p.root, this.env)];
         if (pr !== null)
             thread.push(...comments(this.state.repository, pr.number, this.p.root, this.env));
-        const { records } = parseRecords(thread);
+        const { records, diagnostics } = parseRecords(thread);
         const trusted = records.filter((r) => this.trusted.includes(r.author));
         const inflight = this.state.inflight;
         if (inflight !== null) {
             const visible = trusted.some((r) => roleOf(r) === inflight.role && r.comment_id > inflight.after_comment_id);
             if (!visible) {
                 inflight.checks += 1;
-                log(`handoff check ${inflight.checks}/${this.config.workflow.handoff_checks} for ${inflight.key}: not visible`);
+                // AC-1: an invalid record is named with its validation error instead of `not visible`;
+                // AC-4: without any role record the message and log line stay as before.
+                const invalid = invalidRecordFor(inflight, diagnostics, this.trusted);
+                log(`handoff check ${inflight.checks}/${this.config.workflow.handoff_checks} for ${inflight.key}: ` +
+                    (invalid === undefined ? "not visible" : invalid.reason));
                 if (inflight.checks >= this.config.workflow.handoff_checks) {
                     inflight.missing = true;
-                    this.setStatus("blocked", `${inflight.role} finished without a visible handoff`);
+                    const reason = invalid === undefined
+                        ? `${inflight.role} finished without a visible handoff`
+                        : invalidRecordReason(inflight.role, invalid);
+                    inflight.missing_reason = reason;
+                    const extra = { role: inflight.role, round: inflight.round };
+                    // AC-2: `gdt retry` keeps this record; the role's next turn reads it into its prompt.
+                    if (invalid !== undefined) {
+                        extra.retry_record = { role: inflight.role, kind: invalid.kind, comment_id: invalid.comment_id, reason: invalid.reason };
+                    }
+                    this.setStatus("blocked", reason, extra);
                 }
                 else {
                     this.setStatus("running", `waiting for the ${inflight.role} handoff to become visible`, { role: inflight.role, round: inflight.round });
@@ -255,6 +506,9 @@ class Supervisor {
                 return "continue";
             }
             this.state.inflight = null;
+            // AC-2: the role's rejection explanation is spent once a valid record is visible.
+            if (this.state.retry_record?.role === inflight.role)
+                this.state.retry_record = null;
         }
         const snapshot = {
             repository: this.state.repository,

package/dist/worker.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { closeSync, existsSync, mkdirSync, openSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { renderClaudeLine } from "./agents/claude-stream.js";
 import { adapterFor } from "./agents/index.js";
 import { loadConfig, TEST_AGENT, testAgentsEnabled } from "./config.js";
 import { changedFiles, checkout } from "./git.js";
@@ -77,7 +79,7 @@ export function boundaryViolation(role, before, root, env) {
     return undefined;
 }
 /** Runs one invocation and passes the agent's exit code through unchanged (null when killed by a signal). */
-export function runInvocation(inv, cwd, env) {
+export function runInvocation(inv, cwd, env, onSpawn) {
     const [command, ...args] = inv.argv;
     return new Promise((done) => {
         let stdin = "ignore";
@@ -90,18 +92,39 @@ export function runInvocation(inv, cwd, env) {
             done(66);
             return;
         }
-        // Its own process group, so a stop can end the agent and the children it started.
+        const rendered = inv.output === "claude-stream-json";
+        // Its own process group, so a stop can end the agent and the children it started. A rendered
+        // stream is read in this process, so the renderer adds no process that could outlive the agent.
         const child = spawn(command ?? "", args, {
             cwd,
             env: { ...env, ...inv.env },
-            stdio: [stdin, "inherit", "inherit"],
+            stdio: [stdin, rendered ? "pipe" : "inherit", "inherit"],
             detached: true,
         });
         activeAgent = child;
+        // The agent's pid is its process group id; the supervisor samples that group's activity.
+        if (child.pid !== undefined)
+            onSpawn?.(child.pid);
         const close = () => {
             if (typeof stdin === "number")
                 closeSync(stdin);
         };
+        // With a rendered stream the turn ends once the agent has exited and its last line is written.
+        let pending = rendered && child.stdout !== null ? 2 : 1;
+        let exitCode = null;
+        const settle = () => {
+            if (--pending === 0)
+                done(exitCode);
+        };
+        if (rendered && child.stdout !== null) {
+            const tty = process.stdout.isTTY === true;
+            const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+            lines.on("line", (line) => {
+                for (const out of renderClaudeLine(line, tty))
+                    process.stdout.write(`${out}\n`);
+            });
+            lines.on("close", settle);
+        }
         child.on("error", (err) => {
             activeAgent = null;
             log(`agent could not start: ${err.message}`);
@@ -111,7 +134,8 @@ export function runInvocation(inv, cwd, env) {
         child.on("close", (code) => {
             activeAgent = null;
             close();
-            done(code);
+            exitCode = code;
+            settle();
         });
     });
 }
@@ -142,8 +166,12 @@ async function turn(root, role, dispatch, env, p) {
         return finish(78);
     }
     const promptFile = p.prompt(dispatch.key);
+    // AC-2: a retried turn is told how its previous record was rejected. Reading the state (rather than
+    // the dispatch file) avoids a race with the worker that started before `gdt retry` finished.
+    const rejected = readState(p)?.retry_record;
+    const promptDispatch = rejected != null && rejected.role === role ? { ...dispatch, invalid_record: rejected } : dispatch;
     try {
-        writeFileSync(promptFile, buildPrompt(role, dispatch, { root, extraRules: report.contract.extra_rules }));
+        writeFileSync(promptFile, buildPrompt(role, promptDispatch, { root, extraRules: report.contract.extra_rules }));
     }
     catch (err) {
         log(`cannot build the prompt: ${err instanceof Error ? err.message : String(err)}`);
@@ -173,7 +201,7 @@ async function turn(root, role, dispatch, env, p) {
         GDT_DISPATCH_KEY: dispatch.key,
     };
     const before = checkout(root, env);
-    const exitCode = await runInvocation(inv, root, turnEnv);
+    const exitCode = await runInvocation(inv, root, turnEnv, (pid) => writeFileSync(p.agent(dispatch.key), `${pid}\n`));
     const violation = boundaryViolation(role, before, root, env);
     if (violation !== undefined)
         log(violation);